xref: /illumos-gate/usr/src/lib/libscf/common/lowlevel.c (revision 1f6eb0216cb17ca5fdff9563329f1dda47c8b801)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5103b2b15Sgww  * Common Development and Distribution License (the "License").
6103b2b15Sgww  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21a574db85Sraf 
227c478bd9Sstevel@tonic-gate /*
235b7f77adStw  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate /*
287c478bd9Sstevel@tonic-gate  * This is the main implementation file for the low-level repository
297c478bd9Sstevel@tonic-gate  * interface.
307c478bd9Sstevel@tonic-gate  */
317c478bd9Sstevel@tonic-gate 
327c478bd9Sstevel@tonic-gate #include "lowlevel_impl.h"
337c478bd9Sstevel@tonic-gate 
347c478bd9Sstevel@tonic-gate #include "repcache_protocol.h"
357c478bd9Sstevel@tonic-gate #include "scf_type.h"
367c478bd9Sstevel@tonic-gate 
377c478bd9Sstevel@tonic-gate #include <assert.h>
387c478bd9Sstevel@tonic-gate #include <alloca.h>
397c478bd9Sstevel@tonic-gate #include <door.h>
407c478bd9Sstevel@tonic-gate #include <errno.h>
417c478bd9Sstevel@tonic-gate #include <fcntl.h>
427c478bd9Sstevel@tonic-gate #include <fnmatch.h>
437c478bd9Sstevel@tonic-gate #include <libuutil.h>
447c478bd9Sstevel@tonic-gate #include <poll.h>
457c478bd9Sstevel@tonic-gate #include <pthread.h>
467c478bd9Sstevel@tonic-gate #include <stddef.h>
477c478bd9Sstevel@tonic-gate #include <stdio.h>
487c478bd9Sstevel@tonic-gate #include <stdlib.h>
497c478bd9Sstevel@tonic-gate #include <string.h>
507c478bd9Sstevel@tonic-gate #include <sys/mman.h>
517c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
527c478bd9Sstevel@tonic-gate #include <unistd.h>
537c478bd9Sstevel@tonic-gate 
547c478bd9Sstevel@tonic-gate #define	ENV_SCF_DEBUG		"LIBSCF_DEBUG"
557c478bd9Sstevel@tonic-gate #define	ENV_SCF_DOORPATH	"LIBSCF_DOORPATH"
567c478bd9Sstevel@tonic-gate 
577c478bd9Sstevel@tonic-gate static uint32_t default_debug = 0;
587c478bd9Sstevel@tonic-gate static const char *default_door_path = REPOSITORY_DOOR_NAME;
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate #define	CALL_FAILED		-1
617c478bd9Sstevel@tonic-gate #define	RESULT_TOO_BIG		-2
627c478bd9Sstevel@tonic-gate #define	NOT_BOUND		-3
637c478bd9Sstevel@tonic-gate 
647c478bd9Sstevel@tonic-gate static pthread_mutex_t	lowlevel_init_lock;
657c478bd9Sstevel@tonic-gate static int32_t		lowlevel_inited;
667c478bd9Sstevel@tonic-gate 
677c478bd9Sstevel@tonic-gate static uu_list_pool_t	*tran_entry_pool;
687c478bd9Sstevel@tonic-gate static uu_list_pool_t	*datael_pool;
697c478bd9Sstevel@tonic-gate static uu_list_pool_t	*iter_pool;
707c478bd9Sstevel@tonic-gate 
71*1f6eb021SLiane Praza /*
72*1f6eb021SLiane Praza  * base32[] index32[] are used in base32 encoding and decoding.
73*1f6eb021SLiane Praza  */
74*1f6eb021SLiane Praza static char base32[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
75*1f6eb021SLiane Praza static char index32[128] = {
76*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 0-7 */
77*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 8-15 */
78*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 16-23 */
79*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 24-31 */
80*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 32-39 */
81*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 40-47 */
82*1f6eb021SLiane Praza 	-1, -1, 26, 27, 28, 29, 30, 31,	/* 48-55 */
83*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 56-63 */
84*1f6eb021SLiane Praza 	-1, 0, 1, 2, 3, 4, 5, 6,	/* 64-71 */
85*1f6eb021SLiane Praza 	7, 8, 9, 10, 11, 12, 13, 14,	/* 72-79 */
86*1f6eb021SLiane Praza 	15, 16, 17, 18, 19, 20, 21, 22,	/* 80-87 */
87*1f6eb021SLiane Praza 	23, 24, 25, -1, -1, -1, -1, -1,	/* 88-95 */
88*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 96-103 */
89*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 104-111 */
90*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1,	/* 112-119 */
91*1f6eb021SLiane Praza 	-1, -1, -1, -1, -1, -1, -1, -1	/* 120-127 */
92*1f6eb021SLiane Praza };
93*1f6eb021SLiane Praza 
94*1f6eb021SLiane Praza #define	DECODE32_GS	(8)	/* scf_decode32 group size */
95*1f6eb021SLiane Praza 
967c478bd9Sstevel@tonic-gate /*
977c478bd9Sstevel@tonic-gate  * We want MUTEX_HELD, but we also want pthreads.
987c478bd9Sstevel@tonic-gate  */
997c478bd9Sstevel@tonic-gate struct _lwp_mutex;
1007c478bd9Sstevel@tonic-gate extern int _mutex_held(struct _lwp_mutex *);
1017c478bd9Sstevel@tonic-gate #define	MUTEX_HELD(m)		_mutex_held((struct _lwp_mutex *)(m))
1027c478bd9Sstevel@tonic-gate 
1037c478bd9Sstevel@tonic-gate #ifdef lint
1047c478bd9Sstevel@tonic-gate #define	assert_nolint(x) (void)0
1057c478bd9Sstevel@tonic-gate #else
1067c478bd9Sstevel@tonic-gate #define	assert_nolint(x) assert(x)
1077c478bd9Sstevel@tonic-gate #endif
1087c478bd9Sstevel@tonic-gate 
1097c478bd9Sstevel@tonic-gate static void scf_iter_reset_locked(scf_iter_t *iter);
1107c478bd9Sstevel@tonic-gate static void scf_value_reset_locked(scf_value_t *val, int and_destroy);
1117c478bd9Sstevel@tonic-gate 
1127c478bd9Sstevel@tonic-gate #define	TYPE_VALUE	(-100)
1137c478bd9Sstevel@tonic-gate 
1147c478bd9Sstevel@tonic-gate /*
1157c478bd9Sstevel@tonic-gate  * Hold and release subhandles.  We only allow one thread access to the
1167c478bd9Sstevel@tonic-gate  * subhandles at a time, and he can use any subset, grabbing and releasing
1177c478bd9Sstevel@tonic-gate  * them in any order.  The only restrictions are that you cannot hold an
1187c478bd9Sstevel@tonic-gate  * already-held subhandle, and all subhandles must be released before
1197c478bd9Sstevel@tonic-gate  * returning to the original caller.
1207c478bd9Sstevel@tonic-gate  */
1217c478bd9Sstevel@tonic-gate static void
1227c478bd9Sstevel@tonic-gate handle_hold_subhandles(scf_handle_t *h, int mask)
1237c478bd9Sstevel@tonic-gate {
1247c478bd9Sstevel@tonic-gate 	assert(mask != 0 && (mask & ~RH_HOLD_ALL) == 0);
1257c478bd9Sstevel@tonic-gate 
1267c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
127a574db85Sraf 	while (h->rh_hold_flags != 0 && h->rh_holder != pthread_self()) {
128a574db85Sraf 		int cancel_state;
129a574db85Sraf 
130a574db85Sraf 		(void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
131a574db85Sraf 		    &cancel_state);
132a574db85Sraf 		(void) pthread_cond_wait(&h->rh_cv, &h->rh_lock);
133a574db85Sraf 		(void) pthread_setcancelstate(cancel_state, NULL);
134a574db85Sraf 	}
1357c478bd9Sstevel@tonic-gate 	if (h->rh_hold_flags == 0)
1367c478bd9Sstevel@tonic-gate 		h->rh_holder = pthread_self();
1377c478bd9Sstevel@tonic-gate 	assert(!(h->rh_hold_flags & mask));
1387c478bd9Sstevel@tonic-gate 	h->rh_hold_flags |= mask;
1397c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
1407c478bd9Sstevel@tonic-gate }
1417c478bd9Sstevel@tonic-gate 
1427c478bd9Sstevel@tonic-gate static void
1437c478bd9Sstevel@tonic-gate handle_rele_subhandles(scf_handle_t *h, int mask)
1447c478bd9Sstevel@tonic-gate {
1457c478bd9Sstevel@tonic-gate 	assert(mask != 0 && (mask & ~RH_HOLD_ALL) == 0);
1467c478bd9Sstevel@tonic-gate 
1477c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
1487c478bd9Sstevel@tonic-gate 	assert(h->rh_holder == pthread_self());
1497c478bd9Sstevel@tonic-gate 	assert((h->rh_hold_flags & mask));
1507c478bd9Sstevel@tonic-gate 
1517c478bd9Sstevel@tonic-gate 	h->rh_hold_flags &= ~mask;
1527c478bd9Sstevel@tonic-gate 	if (h->rh_hold_flags == 0)
1537c478bd9Sstevel@tonic-gate 		(void) pthread_cond_signal(&h->rh_cv);
1547c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
1557c478bd9Sstevel@tonic-gate }
1567c478bd9Sstevel@tonic-gate 
1577c478bd9Sstevel@tonic-gate #define	HOLD_HANDLE(h, flag, field) \
1587c478bd9Sstevel@tonic-gate 	(handle_hold_subhandles((h), (flag)), (h)->field)
1597c478bd9Sstevel@tonic-gate 
1607c478bd9Sstevel@tonic-gate #define	RELE_HANDLE(h, flag) \
1617c478bd9Sstevel@tonic-gate 	(handle_rele_subhandles((h), (flag)))
1627c478bd9Sstevel@tonic-gate 
1637c478bd9Sstevel@tonic-gate /*
1647c478bd9Sstevel@tonic-gate  * convenience macros, for functions that only need a one or two handles at
1657c478bd9Sstevel@tonic-gate  * any given time
1667c478bd9Sstevel@tonic-gate  */
1677c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_ITER(h)	HOLD_HANDLE((h), RH_HOLD_ITER, rh_iter)
1687c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_SCOPE(h)	HOLD_HANDLE((h), RH_HOLD_SCOPE, rh_scope)
1697c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_SERVICE(h)	HOLD_HANDLE((h), RH_HOLD_SERVICE, rh_service)
1707c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_INSTANCE(h)	HOLD_HANDLE((h), RH_HOLD_INSTANCE, rh_instance)
1717c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_SNAPSHOT(h)	HOLD_HANDLE((h), RH_HOLD_SNAPSHOT, rh_snapshot)
1727c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_SNAPLVL(h)	HOLD_HANDLE((h), RH_HOLD_SNAPLVL, rh_snaplvl)
1737c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_PG(h)	HOLD_HANDLE((h), RH_HOLD_PG, rh_pg)
1747c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_PROPERTY(h)	HOLD_HANDLE((h), RH_HOLD_PROPERTY, rh_property)
1757c478bd9Sstevel@tonic-gate #define	HANDLE_HOLD_VALUE(h)	HOLD_HANDLE((h), RH_HOLD_VALUE, rh_value)
1767c478bd9Sstevel@tonic-gate 
1777c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_ITER(h)	RELE_HANDLE((h), RH_HOLD_ITER)
1787c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_SCOPE(h)	RELE_HANDLE((h), RH_HOLD_SCOPE)
1797c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_SERVICE(h)	RELE_HANDLE((h), RH_HOLD_SERVICE)
1807c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_INSTANCE(h)	RELE_HANDLE((h), RH_HOLD_INSTANCE)
1817c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_SNAPSHOT(h)	RELE_HANDLE((h), RH_HOLD_SNAPSHOT)
1827c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_SNAPLVL(h)	RELE_HANDLE((h), RH_HOLD_SNAPLVL)
1837c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_PG(h)	RELE_HANDLE((h), RH_HOLD_PG)
1847c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_PROPERTY(h)	RELE_HANDLE((h), RH_HOLD_PROPERTY)
1857c478bd9Sstevel@tonic-gate #define	HANDLE_RELE_VALUE(h)	RELE_HANDLE((h), RH_HOLD_VALUE)
1867c478bd9Sstevel@tonic-gate 
1877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1887c478bd9Sstevel@tonic-gate static int
1897c478bd9Sstevel@tonic-gate transaction_entry_compare(const void *l_arg, const void *r_arg, void *private)
1907c478bd9Sstevel@tonic-gate {
1917c478bd9Sstevel@tonic-gate 	const char *l_prop =
1927c478bd9Sstevel@tonic-gate 	    ((scf_transaction_entry_t *)l_arg)->entry_property;
1937c478bd9Sstevel@tonic-gate 	const char *r_prop =
1947c478bd9Sstevel@tonic-gate 	    ((scf_transaction_entry_t *)r_arg)->entry_property;
1957c478bd9Sstevel@tonic-gate 
1967c478bd9Sstevel@tonic-gate 	int ret;
1977c478bd9Sstevel@tonic-gate 
1987c478bd9Sstevel@tonic-gate 	ret = strcmp(l_prop, r_prop);
1997c478bd9Sstevel@tonic-gate 	if (ret > 0)
2007c478bd9Sstevel@tonic-gate 		return (1);
2018918dff3Sjwadams 	if (ret < 0)
2028918dff3Sjwadams 		return (-1);
2038918dff3Sjwadams 	return (0);
2048918dff3Sjwadams }
2058918dff3Sjwadams 
2068918dff3Sjwadams static int
2078918dff3Sjwadams datael_compare(const void *l_arg, const void *r_arg, void *private)
2088918dff3Sjwadams {
2098918dff3Sjwadams 	uint32_t l_id = ((scf_datael_t *)l_arg)->rd_entity;
2108918dff3Sjwadams 	uint32_t r_id = (r_arg != NULL) ? ((scf_datael_t *)r_arg)->rd_entity :
2118918dff3Sjwadams 	    *(uint32_t *)private;
2128918dff3Sjwadams 
2138918dff3Sjwadams 	if (l_id > r_id)
2148918dff3Sjwadams 		return (1);
2158918dff3Sjwadams 	if (l_id < r_id)
2168918dff3Sjwadams 		return (-1);
2178918dff3Sjwadams 	return (0);
2188918dff3Sjwadams }
2198918dff3Sjwadams 
2208918dff3Sjwadams static int
2218918dff3Sjwadams iter_compare(const void *l_arg, const void *r_arg, void *private)
2228918dff3Sjwadams {
2238918dff3Sjwadams 	uint32_t l_id = ((scf_iter_t *)l_arg)->iter_id;
2248918dff3Sjwadams 	uint32_t r_id = (r_arg != NULL) ? ((scf_iter_t *)r_arg)->iter_id :
2258918dff3Sjwadams 	    *(uint32_t *)private;
2268918dff3Sjwadams 
2278918dff3Sjwadams 	if (l_id > r_id)
2288918dff3Sjwadams 		return (1);
2298918dff3Sjwadams 	if (l_id < r_id)
2307c478bd9Sstevel@tonic-gate 		return (-1);
2317c478bd9Sstevel@tonic-gate 	return (0);
2327c478bd9Sstevel@tonic-gate }
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate static int
2357c478bd9Sstevel@tonic-gate lowlevel_init(void)
2367c478bd9Sstevel@tonic-gate {
2377c478bd9Sstevel@tonic-gate 	const char *debug;
2387c478bd9Sstevel@tonic-gate 	const char *door_path;
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&lowlevel_init_lock);
2417c478bd9Sstevel@tonic-gate 	if (lowlevel_inited == 0) {
2427c478bd9Sstevel@tonic-gate 		if (!issetugid() &&
2437c478bd9Sstevel@tonic-gate 		    (debug = getenv(ENV_SCF_DEBUG)) != NULL && debug[0] != 0 &&
2447c478bd9Sstevel@tonic-gate 		    uu_strtoint(debug, &default_debug, sizeof (default_debug),
2457c478bd9Sstevel@tonic-gate 		    0, 0, 0) == -1) {
2467c478bd9Sstevel@tonic-gate 			(void) fprintf(stderr, "LIBSCF: $%s (%s): %s",
2477c478bd9Sstevel@tonic-gate 			    ENV_SCF_DEBUG, debug,
2487c478bd9Sstevel@tonic-gate 			    uu_strerror(uu_error()));
2497c478bd9Sstevel@tonic-gate 		}
2507c478bd9Sstevel@tonic-gate 
2517c478bd9Sstevel@tonic-gate 		if (!issetugid() &&
2527c478bd9Sstevel@tonic-gate 		    (door_path = getenv(ENV_SCF_DOORPATH)) != NULL &&
2537c478bd9Sstevel@tonic-gate 		    door_path[0] != 0) {
2547c478bd9Sstevel@tonic-gate 			default_door_path = strdup(door_path);
2557c478bd9Sstevel@tonic-gate 			if (default_door_path == NULL)
2567c478bd9Sstevel@tonic-gate 				default_door_path = door_path;
2577c478bd9Sstevel@tonic-gate 		}
2587c478bd9Sstevel@tonic-gate 
2597c478bd9Sstevel@tonic-gate 		datael_pool = uu_list_pool_create("SUNW,libscf_datael",
2607c478bd9Sstevel@tonic-gate 		    sizeof (scf_datael_t), offsetof(scf_datael_t, rd_node),
2618918dff3Sjwadams 		    datael_compare, UU_LIST_POOL_DEBUG);
2627c478bd9Sstevel@tonic-gate 
2637c478bd9Sstevel@tonic-gate 		iter_pool = uu_list_pool_create("SUNW,libscf_iter",
2647c478bd9Sstevel@tonic-gate 		    sizeof (scf_iter_t), offsetof(scf_iter_t, iter_node),
2658918dff3Sjwadams 		    iter_compare, UU_LIST_POOL_DEBUG);
2667c478bd9Sstevel@tonic-gate 
2677c478bd9Sstevel@tonic-gate 		assert_nolint(offsetof(scf_transaction_entry_t,
2687c478bd9Sstevel@tonic-gate 		    entry_property) == 0);
2697c478bd9Sstevel@tonic-gate 		tran_entry_pool = uu_list_pool_create(
2707c478bd9Sstevel@tonic-gate 		    "SUNW,libscf_transaction_entity",
2717c478bd9Sstevel@tonic-gate 		    sizeof (scf_transaction_entry_t),
2727c478bd9Sstevel@tonic-gate 		    offsetof(scf_transaction_entry_t, entry_link),
2737c478bd9Sstevel@tonic-gate 		    transaction_entry_compare, UU_LIST_POOL_DEBUG);
2747c478bd9Sstevel@tonic-gate 
2757c478bd9Sstevel@tonic-gate 		if (datael_pool == NULL || iter_pool == NULL ||
2767c478bd9Sstevel@tonic-gate 		    tran_entry_pool == NULL) {
2777c478bd9Sstevel@tonic-gate 			lowlevel_inited = -1;
2787c478bd9Sstevel@tonic-gate 			goto end;
2797c478bd9Sstevel@tonic-gate 		}
2807c478bd9Sstevel@tonic-gate 
2817c478bd9Sstevel@tonic-gate 		if (!scf_setup_error()) {
2827c478bd9Sstevel@tonic-gate 			lowlevel_inited = -1;
2837c478bd9Sstevel@tonic-gate 			goto end;
2847c478bd9Sstevel@tonic-gate 		}
2857c478bd9Sstevel@tonic-gate 		lowlevel_inited = 1;
2867c478bd9Sstevel@tonic-gate 	}
2877c478bd9Sstevel@tonic-gate end:
2887c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&lowlevel_init_lock);
2897c478bd9Sstevel@tonic-gate 	if (lowlevel_inited > 0)
2907c478bd9Sstevel@tonic-gate 		return (1);
2917c478bd9Sstevel@tonic-gate 	return (0);
2927c478bd9Sstevel@tonic-gate }
2937c478bd9Sstevel@tonic-gate 
2947c478bd9Sstevel@tonic-gate static const struct {
2957c478bd9Sstevel@tonic-gate 	scf_type_t ti_type;
2967c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t ti_proto_type;
2977c478bd9Sstevel@tonic-gate 	const char *ti_name;
2987c478bd9Sstevel@tonic-gate } scf_type_info[] = {
2997c478bd9Sstevel@tonic-gate 	{SCF_TYPE_BOOLEAN,	REP_PROTOCOL_TYPE_BOOLEAN,	"boolean"},
3007c478bd9Sstevel@tonic-gate 	{SCF_TYPE_COUNT,	REP_PROTOCOL_TYPE_COUNT,	"count"},
3017c478bd9Sstevel@tonic-gate 	{SCF_TYPE_INTEGER,	REP_PROTOCOL_TYPE_INTEGER,	"integer"},
3027c478bd9Sstevel@tonic-gate 	{SCF_TYPE_TIME,		REP_PROTOCOL_TYPE_TIME,		"time"},
3037c478bd9Sstevel@tonic-gate 	{SCF_TYPE_ASTRING,	REP_PROTOCOL_TYPE_STRING,	"astring"},
3047c478bd9Sstevel@tonic-gate 	{SCF_TYPE_OPAQUE,	REP_PROTOCOL_TYPE_OPAQUE,	"opaque"},
3057c478bd9Sstevel@tonic-gate 	{SCF_TYPE_USTRING,	REP_PROTOCOL_SUBTYPE_USTRING,	"ustring"},
3067c478bd9Sstevel@tonic-gate 	{SCF_TYPE_URI,		REP_PROTOCOL_SUBTYPE_URI,	"uri"},
3077c478bd9Sstevel@tonic-gate 	{SCF_TYPE_FMRI,		REP_PROTOCOL_SUBTYPE_FMRI,	"fmri"},
3087c478bd9Sstevel@tonic-gate 	{SCF_TYPE_HOST,		REP_PROTOCOL_SUBTYPE_HOST,	"host"},
3097c478bd9Sstevel@tonic-gate 	{SCF_TYPE_HOSTNAME,	REP_PROTOCOL_SUBTYPE_HOSTNAME,	"hostname"},
3107c478bd9Sstevel@tonic-gate 	{SCF_TYPE_NET_ADDR_V4,	REP_PROTOCOL_SUBTYPE_NETADDR_V4,
3117c478bd9Sstevel@tonic-gate 	    "net_address_v4"},
3127c478bd9Sstevel@tonic-gate 	{SCF_TYPE_NET_ADDR_V6,	REP_PROTOCOL_SUBTYPE_NETADDR_V6,
3137c478bd9Sstevel@tonic-gate 	    "net_address_v6"}
3147c478bd9Sstevel@tonic-gate };
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate #define	SCF_TYPE_INFO_COUNT (sizeof (scf_type_info) / sizeof (*scf_type_info))
3177c478bd9Sstevel@tonic-gate static rep_protocol_value_type_t
3187c478bd9Sstevel@tonic-gate scf_type_to_protocol_type(scf_type_t t)
3197c478bd9Sstevel@tonic-gate {
3207c478bd9Sstevel@tonic-gate 	int i;
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate 	for (i = 0; i < SCF_TYPE_INFO_COUNT; i++)
3237c478bd9Sstevel@tonic-gate 		if (scf_type_info[i].ti_type == t)
3247c478bd9Sstevel@tonic-gate 			return (scf_type_info[i].ti_proto_type);
3257c478bd9Sstevel@tonic-gate 
3267c478bd9Sstevel@tonic-gate 	return (REP_PROTOCOL_TYPE_INVALID);
3277c478bd9Sstevel@tonic-gate }
3287c478bd9Sstevel@tonic-gate 
3297c478bd9Sstevel@tonic-gate static scf_type_t
3307c478bd9Sstevel@tonic-gate scf_protocol_type_to_type(rep_protocol_value_type_t t)
3317c478bd9Sstevel@tonic-gate {
3327c478bd9Sstevel@tonic-gate 	int i;
3337c478bd9Sstevel@tonic-gate 
3347c478bd9Sstevel@tonic-gate 	for (i = 0; i < SCF_TYPE_INFO_COUNT; i++)
3357c478bd9Sstevel@tonic-gate 		if (scf_type_info[i].ti_proto_type == t)
3367c478bd9Sstevel@tonic-gate 			return (scf_type_info[i].ti_type);
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 	return (SCF_TYPE_INVALID);
3397c478bd9Sstevel@tonic-gate }
3407c478bd9Sstevel@tonic-gate 
3417c478bd9Sstevel@tonic-gate const char *
3427c478bd9Sstevel@tonic-gate scf_type_to_string(scf_type_t ty)
3437c478bd9Sstevel@tonic-gate {
3447c478bd9Sstevel@tonic-gate 	int i;
3457c478bd9Sstevel@tonic-gate 
3467c478bd9Sstevel@tonic-gate 	for (i = 0; i < SCF_TYPE_INFO_COUNT; i++)
3477c478bd9Sstevel@tonic-gate 		if (scf_type_info[i].ti_type == ty)
3487c478bd9Sstevel@tonic-gate 			return (scf_type_info[i].ti_name);
3497c478bd9Sstevel@tonic-gate 
3507c478bd9Sstevel@tonic-gate 	return ("unknown");
3517c478bd9Sstevel@tonic-gate }
3527c478bd9Sstevel@tonic-gate 
3537c478bd9Sstevel@tonic-gate scf_type_t
3547c478bd9Sstevel@tonic-gate scf_string_to_type(const char *name)
3557c478bd9Sstevel@tonic-gate {
3567c478bd9Sstevel@tonic-gate 	int i;
3577c478bd9Sstevel@tonic-gate 
3587c478bd9Sstevel@tonic-gate 	for (i = 0; i < sizeof (scf_type_info) / sizeof (*scf_type_info); i++)
3597c478bd9Sstevel@tonic-gate 		if (strcmp(scf_type_info[i].ti_name, name) == 0)
3607c478bd9Sstevel@tonic-gate 			return (scf_type_info[i].ti_type);
3617c478bd9Sstevel@tonic-gate 
3627c478bd9Sstevel@tonic-gate 	return (SCF_TYPE_INVALID);
3637c478bd9Sstevel@tonic-gate }
3647c478bd9Sstevel@tonic-gate 
3657c478bd9Sstevel@tonic-gate int
3667c478bd9Sstevel@tonic-gate scf_type_base_type(scf_type_t type, scf_type_t *out)
3677c478bd9Sstevel@tonic-gate {
3687c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t t = scf_type_to_protocol_type(type);
3697c478bd9Sstevel@tonic-gate 	if (t == REP_PROTOCOL_TYPE_INVALID)
3707c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
3717c478bd9Sstevel@tonic-gate 
3727c478bd9Sstevel@tonic-gate 	*out = scf_protocol_type_to_type(scf_proto_underlying_type(t));
3737c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
3747c478bd9Sstevel@tonic-gate }
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate /*
3777c478bd9Sstevel@tonic-gate  * Convert a protocol error code into an SCF_ERROR_* code.
3787c478bd9Sstevel@tonic-gate  */
3797c478bd9Sstevel@tonic-gate static scf_error_t
3807c478bd9Sstevel@tonic-gate proto_error(rep_protocol_responseid_t e)
3817c478bd9Sstevel@tonic-gate {
3827c478bd9Sstevel@tonic-gate 	switch (e) {
3837c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_MISORDERED:
3847c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_UNKNOWN_ID:
3857c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_INVALID_TYPE:
3867c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_TRUNCATED:
3877c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_TYPE_MISMATCH:
3887c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_NOT_APPLICABLE:
3897c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_UNKNOWN:
3907c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_INTERNAL);
3917c478bd9Sstevel@tonic-gate 
3927c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_BAD_TX:
3937c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_INVALID_ARGUMENT);
3947c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_BAD_REQUEST:
3957c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_INVALID_ARGUMENT);
3967c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_NO_RESOURCES:
3977c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_NO_RESOURCES);
3987c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_NOT_FOUND:
3997c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_NOT_FOUND);
4007c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_DELETED:
4017c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_DELETED);
4027c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_NOT_SET:
4037c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_NOT_SET);
4047c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_EXISTS:
4057c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_EXISTS);
4067c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_DUPLICATE_ID:
4077c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_EXISTS);
4087c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_PERMISSION_DENIED:
4097c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_PERMISSION_DENIED);
4107c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_BACKEND_ACCESS:
4117c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_BACKEND_ACCESS);
4127c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_BACKEND_READONLY:
4137c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_BACKEND_READONLY);
4147c478bd9Sstevel@tonic-gate 
4157c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_SUCCESS:
4167c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_DONE:
4177c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_FAIL_NOT_LATEST:	/* TX code should handle this */
4187c478bd9Sstevel@tonic-gate 	default:
4197c478bd9Sstevel@tonic-gate #ifndef NDEBUG
4207c478bd9Sstevel@tonic-gate 		uu_warn("%s:%d: Bad error code %d passed to proto_error().\n",
4217c478bd9Sstevel@tonic-gate 		    __FILE__, __LINE__, e);
4227c478bd9Sstevel@tonic-gate #endif
4237c478bd9Sstevel@tonic-gate 		abort();
4247c478bd9Sstevel@tonic-gate 		/*NOTREACHED*/
4257c478bd9Sstevel@tonic-gate 	}
4267c478bd9Sstevel@tonic-gate }
4277c478bd9Sstevel@tonic-gate 
4287c478bd9Sstevel@tonic-gate ssize_t
4297c478bd9Sstevel@tonic-gate scf_limit(uint32_t limit)
4307c478bd9Sstevel@tonic-gate {
4317c478bd9Sstevel@tonic-gate 	switch (limit) {
4327c478bd9Sstevel@tonic-gate 	case SCF_LIMIT_MAX_NAME_LENGTH:
4337c478bd9Sstevel@tonic-gate 	case SCF_LIMIT_MAX_PG_TYPE_LENGTH:
4347c478bd9Sstevel@tonic-gate 		return (REP_PROTOCOL_NAME_LEN - 1);
4357c478bd9Sstevel@tonic-gate 	case SCF_LIMIT_MAX_VALUE_LENGTH:
4367c478bd9Sstevel@tonic-gate 		return (REP_PROTOCOL_VALUE_LEN - 1);
4377c478bd9Sstevel@tonic-gate 	case SCF_LIMIT_MAX_FMRI_LENGTH:
4387c478bd9Sstevel@tonic-gate 		return (SCF_FMRI_PREFIX_MAX_LEN +
4397c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_SCOPE_PREFIX) - 1 +
4407c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1 +
4417c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_SERVICE_PREFIX) - 1 +
4427c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1 +
4437c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1 +
4447c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1 +
4457c478bd9Sstevel@tonic-gate 		    5 * (REP_PROTOCOL_NAME_LEN - 1));
4467c478bd9Sstevel@tonic-gate 	default:
4477c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
4487c478bd9Sstevel@tonic-gate 	}
4497c478bd9Sstevel@tonic-gate }
4507c478bd9Sstevel@tonic-gate 
4517c478bd9Sstevel@tonic-gate static size_t
4527c478bd9Sstevel@tonic-gate scf_opaque_decode(char *out_arg, const char *in, size_t max_out)
4537c478bd9Sstevel@tonic-gate {
4547c478bd9Sstevel@tonic-gate 	char a, b;
4557c478bd9Sstevel@tonic-gate 	char *out = out_arg;
4567c478bd9Sstevel@tonic-gate 
4577c478bd9Sstevel@tonic-gate 	while (max_out > 0 && (a = in[0]) != 0 && (b = in[1]) != 0) {
4587c478bd9Sstevel@tonic-gate 		in += 2;
4597c478bd9Sstevel@tonic-gate 
4607c478bd9Sstevel@tonic-gate 		if (a >= '0' && a <= '9')
4617c478bd9Sstevel@tonic-gate 			a -= '0';
4627c478bd9Sstevel@tonic-gate 		else if (a >= 'a' && a <= 'f')
4637c478bd9Sstevel@tonic-gate 			a = a - 'a' + 10;
4647c478bd9Sstevel@tonic-gate 		else if (a >= 'A' && a <= 'F')
4657c478bd9Sstevel@tonic-gate 			a = a - 'A' + 10;
4667c478bd9Sstevel@tonic-gate 		else
4677c478bd9Sstevel@tonic-gate 			break;
4687c478bd9Sstevel@tonic-gate 
4697c478bd9Sstevel@tonic-gate 		if (b >= '0' && b <= '9')
4707c478bd9Sstevel@tonic-gate 			b -= '0';
4717c478bd9Sstevel@tonic-gate 		else if (b >= 'a' && b <= 'f')
4727c478bd9Sstevel@tonic-gate 			b = b - 'a' + 10;
4737c478bd9Sstevel@tonic-gate 		else if (b >= 'A' && b <= 'F')
4747c478bd9Sstevel@tonic-gate 			b = b - 'A' + 10;
4757c478bd9Sstevel@tonic-gate 		else
4767c478bd9Sstevel@tonic-gate 			break;
4777c478bd9Sstevel@tonic-gate 
4787c478bd9Sstevel@tonic-gate 		*out++ = (a << 4) | b;
4797c478bd9Sstevel@tonic-gate 		max_out--;
4807c478bd9Sstevel@tonic-gate 	}
4817c478bd9Sstevel@tonic-gate 
4827c478bd9Sstevel@tonic-gate 	return (out - out_arg);
4837c478bd9Sstevel@tonic-gate }
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate static size_t
4867c478bd9Sstevel@tonic-gate scf_opaque_encode(char *out_arg, const char *in_arg, size_t in_sz)
4877c478bd9Sstevel@tonic-gate {
4887c478bd9Sstevel@tonic-gate 	uint8_t *in = (uint8_t *)in_arg;
4897c478bd9Sstevel@tonic-gate 	uint8_t *end = in + in_sz;
4907c478bd9Sstevel@tonic-gate 	char *out = out_arg;
4917c478bd9Sstevel@tonic-gate 
4927c478bd9Sstevel@tonic-gate 	if (out == NULL)
4937c478bd9Sstevel@tonic-gate 		return (2 * in_sz);
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate 	while (in < end) {
4967c478bd9Sstevel@tonic-gate 		uint8_t c = *in++;
4977c478bd9Sstevel@tonic-gate 
4987c478bd9Sstevel@tonic-gate 		uint8_t a = (c & 0xf0) >> 4;
4997c478bd9Sstevel@tonic-gate 		uint8_t b = (c & 0x0f);
5007c478bd9Sstevel@tonic-gate 
5017c478bd9Sstevel@tonic-gate 		if (a <= 9)
5027c478bd9Sstevel@tonic-gate 			*out++ = a + '0';
5037c478bd9Sstevel@tonic-gate 		else
5047c478bd9Sstevel@tonic-gate 			*out++ = a + 'a' - 10;
5057c478bd9Sstevel@tonic-gate 
5067c478bd9Sstevel@tonic-gate 		if (b <= 9)
5077c478bd9Sstevel@tonic-gate 			*out++ = b + '0';
5087c478bd9Sstevel@tonic-gate 		else
5097c478bd9Sstevel@tonic-gate 			*out++ = b + 'a' - 10;
5107c478bd9Sstevel@tonic-gate 	}
5117c478bd9Sstevel@tonic-gate 
5127c478bd9Sstevel@tonic-gate 	*out = 0;
5137c478bd9Sstevel@tonic-gate 
5147c478bd9Sstevel@tonic-gate 	return (out - out_arg);
5157c478bd9Sstevel@tonic-gate }
5167c478bd9Sstevel@tonic-gate 
5177c478bd9Sstevel@tonic-gate static void
5187c478bd9Sstevel@tonic-gate handle_do_close(scf_handle_t *h)
5197c478bd9Sstevel@tonic-gate {
5207c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
5217c478bd9Sstevel@tonic-gate 	assert(h->rh_doorfd != -1);
5227c478bd9Sstevel@tonic-gate 
5237c478bd9Sstevel@tonic-gate 	/*
5247c478bd9Sstevel@tonic-gate 	 * if there are any active FD users, we just move the FD over
5257c478bd9Sstevel@tonic-gate 	 * to rh_doorfd_old -- they'll close it when they finish.
5267c478bd9Sstevel@tonic-gate 	 */
5277c478bd9Sstevel@tonic-gate 	if (h->rh_fd_users > 0) {
5287c478bd9Sstevel@tonic-gate 		h->rh_doorfd_old = h->rh_doorfd;
5297c478bd9Sstevel@tonic-gate 		h->rh_doorfd = -1;
5307c478bd9Sstevel@tonic-gate 	} else {
5317c478bd9Sstevel@tonic-gate 		assert(h->rh_doorfd_old == -1);
5327c478bd9Sstevel@tonic-gate 		(void) close(h->rh_doorfd);
5337c478bd9Sstevel@tonic-gate 		h->rh_doorfd = -1;
5347c478bd9Sstevel@tonic-gate 	}
5357c478bd9Sstevel@tonic-gate }
5367c478bd9Sstevel@tonic-gate 
5377c478bd9Sstevel@tonic-gate /*
5387c478bd9Sstevel@tonic-gate  * Check if a handle is currently bound.  fork()ing implicitly unbinds
5397c478bd9Sstevel@tonic-gate  * the handle in the child.
5407c478bd9Sstevel@tonic-gate  */
5417c478bd9Sstevel@tonic-gate static int
5427c478bd9Sstevel@tonic-gate handle_is_bound(scf_handle_t *h)
5437c478bd9Sstevel@tonic-gate {
5447c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
5457c478bd9Sstevel@tonic-gate 
5467c478bd9Sstevel@tonic-gate 	if (h->rh_doorfd == -1)
5477c478bd9Sstevel@tonic-gate 		return (0);
5487c478bd9Sstevel@tonic-gate 
5497c478bd9Sstevel@tonic-gate 	if (getpid() == h->rh_doorpid)
5507c478bd9Sstevel@tonic-gate 		return (1);
5517c478bd9Sstevel@tonic-gate 
5527c478bd9Sstevel@tonic-gate 	/* forked since our last bind -- initiate handle close */
5537c478bd9Sstevel@tonic-gate 	handle_do_close(h);
5547c478bd9Sstevel@tonic-gate 	return (0);
5557c478bd9Sstevel@tonic-gate }
5567c478bd9Sstevel@tonic-gate 
5577c478bd9Sstevel@tonic-gate static int
5588918dff3Sjwadams handle_has_server_locked(scf_handle_t *h)
5597c478bd9Sstevel@tonic-gate {
5607c478bd9Sstevel@tonic-gate 	door_info_t i;
5618918dff3Sjwadams 	assert(MUTEX_HELD(&h->rh_lock));
5628918dff3Sjwadams 
5638918dff3Sjwadams 	return (handle_is_bound(h) && door_info(h->rh_doorfd, &i) != -1 &&
5648918dff3Sjwadams 	    i.di_target != -1);
5658918dff3Sjwadams }
5668918dff3Sjwadams 
5678918dff3Sjwadams static int
5688918dff3Sjwadams handle_has_server(scf_handle_t *h)
5698918dff3Sjwadams {
5707c478bd9Sstevel@tonic-gate 	int ret;
5717c478bd9Sstevel@tonic-gate 
5727c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
5738918dff3Sjwadams 	ret = handle_has_server_locked(h);
5747c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
5757c478bd9Sstevel@tonic-gate 
5767c478bd9Sstevel@tonic-gate 	return (ret);
5777c478bd9Sstevel@tonic-gate }
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate /*
5807c478bd9Sstevel@tonic-gate  * This makes a door request on the client door associated with handle h.
5817c478bd9Sstevel@tonic-gate  * It will automatically retry calls which fail on EINTR.  If h is not bound,
5827c478bd9Sstevel@tonic-gate  * returns NOT_BOUND.  If the door call fails or the server response is too
5837c478bd9Sstevel@tonic-gate  * small, returns CALL_FAILED.  If the server response is too big, truncates the
5847c478bd9Sstevel@tonic-gate  * response and returns RESULT_TOO_BIG.  Otherwise, the size of the result is
5857c478bd9Sstevel@tonic-gate  * returned.
5867c478bd9Sstevel@tonic-gate  */
5877c478bd9Sstevel@tonic-gate static ssize_t
5887c478bd9Sstevel@tonic-gate make_door_call(scf_handle_t *h, const void *req, size_t req_sz,
5897c478bd9Sstevel@tonic-gate     void *res, size_t res_sz)
5907c478bd9Sstevel@tonic-gate {
5917c478bd9Sstevel@tonic-gate 	door_arg_t arg;
5927c478bd9Sstevel@tonic-gate 	int r;
5937c478bd9Sstevel@tonic-gate 
5947c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
5957c478bd9Sstevel@tonic-gate 
5967c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(h)) {
5977c478bd9Sstevel@tonic-gate 		return (NOT_BOUND);
5987c478bd9Sstevel@tonic-gate 	}
5997c478bd9Sstevel@tonic-gate 
6007c478bd9Sstevel@tonic-gate 	arg.data_ptr = (void *)req;
6017c478bd9Sstevel@tonic-gate 	arg.data_size = req_sz;
6027c478bd9Sstevel@tonic-gate 	arg.desc_ptr = NULL;
6037c478bd9Sstevel@tonic-gate 	arg.desc_num = 0;
6047c478bd9Sstevel@tonic-gate 	arg.rbuf = res;
6057c478bd9Sstevel@tonic-gate 	arg.rsize = res_sz;
6067c478bd9Sstevel@tonic-gate 
6077c478bd9Sstevel@tonic-gate 	while ((r = door_call(h->rh_doorfd, &arg)) < 0) {
6087c478bd9Sstevel@tonic-gate 		if (errno != EINTR)
6097c478bd9Sstevel@tonic-gate 			break;
6107c478bd9Sstevel@tonic-gate 	}
6117c478bd9Sstevel@tonic-gate 
6127c478bd9Sstevel@tonic-gate 	if (r < 0) {
6137c478bd9Sstevel@tonic-gate 		return (CALL_FAILED);
6147c478bd9Sstevel@tonic-gate 	}
6157c478bd9Sstevel@tonic-gate 
6167c478bd9Sstevel@tonic-gate 	if (arg.desc_num > 0) {
6177c478bd9Sstevel@tonic-gate 		while (arg.desc_num > 0) {
6187c478bd9Sstevel@tonic-gate 			if (arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) {
6197c478bd9Sstevel@tonic-gate 				int cfd = arg.desc_ptr->d_data.d_desc.d_id;
6207c478bd9Sstevel@tonic-gate 				(void) close(cfd);
6217c478bd9Sstevel@tonic-gate 			}
6227c478bd9Sstevel@tonic-gate 			arg.desc_ptr++;
6237c478bd9Sstevel@tonic-gate 			arg.desc_num--;
6247c478bd9Sstevel@tonic-gate 		}
6257c478bd9Sstevel@tonic-gate 	}
6267c478bd9Sstevel@tonic-gate 	if (arg.data_ptr != res && arg.data_size > 0)
6277c478bd9Sstevel@tonic-gate 		(void) memmove(res, arg.data_ptr, MIN(arg.data_size, res_sz));
6287c478bd9Sstevel@tonic-gate 
6297c478bd9Sstevel@tonic-gate 	if (arg.rbuf != res)
6307c478bd9Sstevel@tonic-gate 		(void) munmap(arg.rbuf, arg.rsize);
6317c478bd9Sstevel@tonic-gate 
6327c478bd9Sstevel@tonic-gate 	if (arg.data_size > res_sz)
6337c478bd9Sstevel@tonic-gate 		return (RESULT_TOO_BIG);
6347c478bd9Sstevel@tonic-gate 
6357c478bd9Sstevel@tonic-gate 	if (arg.data_size < sizeof (uint32_t))
6367c478bd9Sstevel@tonic-gate 		return (CALL_FAILED);
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate 	return (arg.data_size);
6397c478bd9Sstevel@tonic-gate }
6407c478bd9Sstevel@tonic-gate 
6417c478bd9Sstevel@tonic-gate /*
6427c478bd9Sstevel@tonic-gate  * Should only be used when r < 0.
6437c478bd9Sstevel@tonic-gate  */
6447c478bd9Sstevel@tonic-gate #define	DOOR_ERRORS_BLOCK(r)	{					\
6457c478bd9Sstevel@tonic-gate 	switch (r) {							\
6467c478bd9Sstevel@tonic-gate 	case NOT_BOUND:							\
6477c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_BOUND));		\
6487c478bd9Sstevel@tonic-gate 									\
6497c478bd9Sstevel@tonic-gate 	case CALL_FAILED:						\
6507c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));	\
6517c478bd9Sstevel@tonic-gate 									\
6527c478bd9Sstevel@tonic-gate 	case RESULT_TOO_BIG:						\
6537c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INTERNAL));		\
6547c478bd9Sstevel@tonic-gate 									\
6557c478bd9Sstevel@tonic-gate 	default:							\
6567c478bd9Sstevel@tonic-gate 		assert(r == NOT_BOUND || r == CALL_FAILED ||		\
6577c478bd9Sstevel@tonic-gate 		    r == RESULT_TOO_BIG);				\
6587c478bd9Sstevel@tonic-gate 		abort();						\
6597c478bd9Sstevel@tonic-gate 	}								\
6607c478bd9Sstevel@tonic-gate }
6617c478bd9Sstevel@tonic-gate 
6627c478bd9Sstevel@tonic-gate /*
6637c478bd9Sstevel@tonic-gate  * Like make_door_call(), but takes an fd instead of a handle, and expects
6647c478bd9Sstevel@tonic-gate  * a single file descriptor, returned via res_fd.
6657c478bd9Sstevel@tonic-gate  *
6667c478bd9Sstevel@tonic-gate  * If no file descriptor is returned, *res_fd == -1.
6677c478bd9Sstevel@tonic-gate  */
6687c478bd9Sstevel@tonic-gate static int
6697c478bd9Sstevel@tonic-gate make_door_call_retfd(int fd, const void *req, size_t req_sz, void *res,
6707c478bd9Sstevel@tonic-gate     size_t res_sz, int *res_fd)
6717c478bd9Sstevel@tonic-gate {
6727c478bd9Sstevel@tonic-gate 	door_arg_t arg;
6737c478bd9Sstevel@tonic-gate 	int r;
6747c478bd9Sstevel@tonic-gate 	char rbuf[256];
6757c478bd9Sstevel@tonic-gate 
6767c478bd9Sstevel@tonic-gate 	*res_fd = -1;
6777c478bd9Sstevel@tonic-gate 
6787c478bd9Sstevel@tonic-gate 	if (fd == -1)
6797c478bd9Sstevel@tonic-gate 		return (NOT_BOUND);
6807c478bd9Sstevel@tonic-gate 
6817c478bd9Sstevel@tonic-gate 	arg.data_ptr = (void *)req;
6827c478bd9Sstevel@tonic-gate 	arg.data_size = req_sz;
6837c478bd9Sstevel@tonic-gate 	arg.desc_ptr = NULL;
6847c478bd9Sstevel@tonic-gate 	arg.desc_num = 0;
6857c478bd9Sstevel@tonic-gate 	arg.rbuf = rbuf;
6867c478bd9Sstevel@tonic-gate 	arg.rsize = sizeof (rbuf);
6877c478bd9Sstevel@tonic-gate 
6887c478bd9Sstevel@tonic-gate 	while ((r = door_call(fd, &arg)) < 0) {
6897c478bd9Sstevel@tonic-gate 		if (errno != EINTR)
6907c478bd9Sstevel@tonic-gate 			break;
6917c478bd9Sstevel@tonic-gate 	}
6927c478bd9Sstevel@tonic-gate 
6937c478bd9Sstevel@tonic-gate 	if (r < 0)
6947c478bd9Sstevel@tonic-gate 		return (CALL_FAILED);
6957c478bd9Sstevel@tonic-gate 
6967c478bd9Sstevel@tonic-gate 	if (arg.desc_num > 1) {
6977c478bd9Sstevel@tonic-gate 		while (arg.desc_num > 0) {
6987c478bd9Sstevel@tonic-gate 			if (arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR) {
6997c478bd9Sstevel@tonic-gate 				int cfd =
7007c478bd9Sstevel@tonic-gate 				    arg.desc_ptr->d_data.d_desc.d_descriptor;
7017c478bd9Sstevel@tonic-gate 				(void) close(cfd);
7027c478bd9Sstevel@tonic-gate 			}
7037c478bd9Sstevel@tonic-gate 			arg.desc_ptr++;
7047c478bd9Sstevel@tonic-gate 			arg.desc_num--;
7057c478bd9Sstevel@tonic-gate 		}
7067c478bd9Sstevel@tonic-gate 	}
7077c478bd9Sstevel@tonic-gate 	if (arg.desc_num == 1 && arg.desc_ptr->d_attributes & DOOR_DESCRIPTOR)
7087c478bd9Sstevel@tonic-gate 		*res_fd = arg.desc_ptr->d_data.d_desc.d_descriptor;
7097c478bd9Sstevel@tonic-gate 
7107c478bd9Sstevel@tonic-gate 	if (arg.data_size > 0)
7117c478bd9Sstevel@tonic-gate 		(void) memmove(res, arg.data_ptr, MIN(arg.data_size, res_sz));
7127c478bd9Sstevel@tonic-gate 
7137c478bd9Sstevel@tonic-gate 	if (arg.rbuf != rbuf)
7147c478bd9Sstevel@tonic-gate 		(void) munmap(arg.rbuf, arg.rsize);
7157c478bd9Sstevel@tonic-gate 
7167c478bd9Sstevel@tonic-gate 	if (arg.data_size > res_sz)
7177c478bd9Sstevel@tonic-gate 		return (RESULT_TOO_BIG);
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 	if (arg.data_size < sizeof (uint32_t))
7207c478bd9Sstevel@tonic-gate 		return (CALL_FAILED);
7217c478bd9Sstevel@tonic-gate 
7227c478bd9Sstevel@tonic-gate 	return (arg.data_size);
7237c478bd9Sstevel@tonic-gate }
7247c478bd9Sstevel@tonic-gate 
7257c478bd9Sstevel@tonic-gate /*
7267c478bd9Sstevel@tonic-gate  * Fails with
7277c478bd9Sstevel@tonic-gate  *   _VERSION_MISMATCH
7287c478bd9Sstevel@tonic-gate  *   _NO_MEMORY
7297c478bd9Sstevel@tonic-gate  */
7307c478bd9Sstevel@tonic-gate scf_handle_t *
7317c478bd9Sstevel@tonic-gate scf_handle_create(scf_version_t v)
7327c478bd9Sstevel@tonic-gate {
7337c478bd9Sstevel@tonic-gate 	scf_handle_t *ret;
7347c478bd9Sstevel@tonic-gate 	int failed;
7357c478bd9Sstevel@tonic-gate 
7367c478bd9Sstevel@tonic-gate 	/*
7377c478bd9Sstevel@tonic-gate 	 * This will need to be revisited when we bump SCF_VERSION
7387c478bd9Sstevel@tonic-gate 	 */
7397c478bd9Sstevel@tonic-gate 	if (v != SCF_VERSION) {
7407c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_VERSION_MISMATCH);
7417c478bd9Sstevel@tonic-gate 		return (NULL);
7427c478bd9Sstevel@tonic-gate 	}
7437c478bd9Sstevel@tonic-gate 
7447c478bd9Sstevel@tonic-gate 	if (!lowlevel_init()) {
7457c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
7467c478bd9Sstevel@tonic-gate 		return (NULL);
7477c478bd9Sstevel@tonic-gate 	}
7487c478bd9Sstevel@tonic-gate 
7497c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
7507c478bd9Sstevel@tonic-gate 	if (ret == NULL) {
7517c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
7527c478bd9Sstevel@tonic-gate 		return (NULL);
7537c478bd9Sstevel@tonic-gate 	}
7547c478bd9Sstevel@tonic-gate 
7557c478bd9Sstevel@tonic-gate 	ret->rh_dataels = uu_list_create(datael_pool, ret, 0);
7567c478bd9Sstevel@tonic-gate 	ret->rh_iters = uu_list_create(iter_pool, ret, 0);
7577c478bd9Sstevel@tonic-gate 	if (ret->rh_dataels == NULL || ret->rh_iters == NULL) {
7587c478bd9Sstevel@tonic-gate 		if (ret->rh_dataels != NULL)
7597c478bd9Sstevel@tonic-gate 			uu_list_destroy(ret->rh_dataels);
7607c478bd9Sstevel@tonic-gate 		if (ret->rh_iters != NULL)
7617c478bd9Sstevel@tonic-gate 			uu_list_destroy(ret->rh_iters);
7627c478bd9Sstevel@tonic-gate 		uu_free(ret);
7637c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
7647c478bd9Sstevel@tonic-gate 		return (NULL);
7657c478bd9Sstevel@tonic-gate 	}
7667c478bd9Sstevel@tonic-gate 
7677c478bd9Sstevel@tonic-gate 	ret->rh_doorfd = -1;
7687c478bd9Sstevel@tonic-gate 	ret->rh_doorfd_old = -1;
7697c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_init(&ret->rh_lock, NULL);
7707c478bd9Sstevel@tonic-gate 
7717c478bd9Sstevel@tonic-gate 	handle_hold_subhandles(ret, RH_HOLD_ALL);
7727c478bd9Sstevel@tonic-gate 
7737c478bd9Sstevel@tonic-gate 	failed = ((ret->rh_iter = scf_iter_create(ret)) == NULL ||
7747c478bd9Sstevel@tonic-gate 	    (ret->rh_scope = scf_scope_create(ret)) == NULL ||
7757c478bd9Sstevel@tonic-gate 	    (ret->rh_service = scf_service_create(ret)) == NULL ||
7767c478bd9Sstevel@tonic-gate 	    (ret->rh_instance = scf_instance_create(ret)) == NULL ||
7777c478bd9Sstevel@tonic-gate 	    (ret->rh_snapshot = scf_snapshot_create(ret)) == NULL ||
7787c478bd9Sstevel@tonic-gate 	    (ret->rh_snaplvl = scf_snaplevel_create(ret)) == NULL ||
7797c478bd9Sstevel@tonic-gate 	    (ret->rh_pg = scf_pg_create(ret)) == NULL ||
7807c478bd9Sstevel@tonic-gate 	    (ret->rh_property = scf_property_create(ret)) == NULL ||
7817c478bd9Sstevel@tonic-gate 	    (ret->rh_value = scf_value_create(ret)) == NULL);
7827c478bd9Sstevel@tonic-gate 
7837c478bd9Sstevel@tonic-gate 	/*
7847c478bd9Sstevel@tonic-gate 	 * these subhandles count as internal references, not external ones.
7857c478bd9Sstevel@tonic-gate 	 */
7867c478bd9Sstevel@tonic-gate 	ret->rh_intrefs = ret->rh_extrefs;
7877c478bd9Sstevel@tonic-gate 	ret->rh_extrefs = 0;
7887c478bd9Sstevel@tonic-gate 	handle_rele_subhandles(ret, RH_HOLD_ALL);
7897c478bd9Sstevel@tonic-gate 
7907c478bd9Sstevel@tonic-gate 	if (failed) {
7917c478bd9Sstevel@tonic-gate 		scf_handle_destroy(ret);
7927c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
7937c478bd9Sstevel@tonic-gate 		return (NULL);
7947c478bd9Sstevel@tonic-gate 	}
7957c478bd9Sstevel@tonic-gate 
7967c478bd9Sstevel@tonic-gate 	scf_value_set_count(ret->rh_value, default_debug);
7977c478bd9Sstevel@tonic-gate 	(void) scf_handle_decorate(ret, "debug", ret->rh_value);
7987c478bd9Sstevel@tonic-gate 
7997c478bd9Sstevel@tonic-gate 	return (ret);
8007c478bd9Sstevel@tonic-gate }
8017c478bd9Sstevel@tonic-gate 
8027c478bd9Sstevel@tonic-gate int
8037c478bd9Sstevel@tonic-gate scf_handle_decorate(scf_handle_t *handle, const char *name, scf_value_t *v)
8047c478bd9Sstevel@tonic-gate {
8057c478bd9Sstevel@tonic-gate 	if (v != SCF_DECORATE_CLEAR && handle != v->value_handle)
8067c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
8077c478bd9Sstevel@tonic-gate 
8087c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
8097c478bd9Sstevel@tonic-gate 	if (handle_is_bound(handle)) {
8107c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
8117c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_IN_USE));
8127c478bd9Sstevel@tonic-gate 	}
8137c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
8147c478bd9Sstevel@tonic-gate 
8157c478bd9Sstevel@tonic-gate 	if (strcmp(name, "debug") == 0) {
8167c478bd9Sstevel@tonic-gate 		if (v == SCF_DECORATE_CLEAR) {
8177c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_lock(&handle->rh_lock);
8187c478bd9Sstevel@tonic-gate 			handle->rh_debug = 0;
8197c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&handle->rh_lock);
8207c478bd9Sstevel@tonic-gate 		} else {
8217c478bd9Sstevel@tonic-gate 			uint64_t val;
8227c478bd9Sstevel@tonic-gate 			if (scf_value_get_count(v, &val) < 0)
8237c478bd9Sstevel@tonic-gate 				return (-1);		/* error already set */
8247c478bd9Sstevel@tonic-gate 
8257c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_lock(&handle->rh_lock);
8267c478bd9Sstevel@tonic-gate 			handle->rh_debug = (uid_t)val;
8277c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&handle->rh_lock);
8287c478bd9Sstevel@tonic-gate 		}
8297c478bd9Sstevel@tonic-gate 		return (0);
8307c478bd9Sstevel@tonic-gate 	}
8317c478bd9Sstevel@tonic-gate 	if (strcmp(name, "door_path") == 0) {
8327c478bd9Sstevel@tonic-gate 		char name[sizeof (handle->rh_doorpath)];
8337c478bd9Sstevel@tonic-gate 
8347c478bd9Sstevel@tonic-gate 		if (v == SCF_DECORATE_CLEAR) {
8357c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_lock(&handle->rh_lock);
8367c478bd9Sstevel@tonic-gate 			handle->rh_doorpath[0] = 0;
8377c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&handle->rh_lock);
8387c478bd9Sstevel@tonic-gate 		} else {
8397c478bd9Sstevel@tonic-gate 			ssize_t len;
8407c478bd9Sstevel@tonic-gate 
8417c478bd9Sstevel@tonic-gate 			if ((len = scf_value_get_astring(v, name,
8427c478bd9Sstevel@tonic-gate 			    sizeof (name))) < 0) {
8437c478bd9Sstevel@tonic-gate 				return (-1);		/* error already set */
8447c478bd9Sstevel@tonic-gate 			}
8457c478bd9Sstevel@tonic-gate 			if (len == 0 || len >= sizeof (name)) {
8467c478bd9Sstevel@tonic-gate 				return (scf_set_error(
8477c478bd9Sstevel@tonic-gate 				    SCF_ERROR_INVALID_ARGUMENT));
8487c478bd9Sstevel@tonic-gate 			}
8497c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_lock(&handle->rh_lock);
8507c478bd9Sstevel@tonic-gate 			(void) strlcpy(handle->rh_doorpath, name,
8517c478bd9Sstevel@tonic-gate 			    sizeof (handle->rh_doorpath));
8527c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&handle->rh_lock);
8537c478bd9Sstevel@tonic-gate 		}
8547c478bd9Sstevel@tonic-gate 		return (0);
8557c478bd9Sstevel@tonic-gate 	}
8567c478bd9Sstevel@tonic-gate 	return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
8577c478bd9Sstevel@tonic-gate }
8587c478bd9Sstevel@tonic-gate 
8597c478bd9Sstevel@tonic-gate /*
8607c478bd9Sstevel@tonic-gate  * fails with INVALID_ARGUMENT and HANDLE_MISMATCH.
8617c478bd9Sstevel@tonic-gate  */
8627c478bd9Sstevel@tonic-gate int
8637c478bd9Sstevel@tonic-gate _scf_handle_decorations(scf_handle_t *handle, scf_decoration_func *f,
8647c478bd9Sstevel@tonic-gate     scf_value_t *v, void *data)
8657c478bd9Sstevel@tonic-gate {
8667c478bd9Sstevel@tonic-gate 	scf_decoration_info_t i;
8677c478bd9Sstevel@tonic-gate 	char name[sizeof (handle->rh_doorpath)];
8687c478bd9Sstevel@tonic-gate 	uint64_t debug;
8697c478bd9Sstevel@tonic-gate 
8707c478bd9Sstevel@tonic-gate 	if (f == NULL || v == NULL)
8717c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
8727c478bd9Sstevel@tonic-gate 
8737c478bd9Sstevel@tonic-gate 	if (v->value_handle != handle)
8747c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
8757c478bd9Sstevel@tonic-gate 
8767c478bd9Sstevel@tonic-gate 	i.sdi_name = (const char *)"debug";
8777c478bd9Sstevel@tonic-gate 	i.sdi_type = SCF_TYPE_COUNT;
8787c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
8797c478bd9Sstevel@tonic-gate 	debug = handle->rh_debug;
8807c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
8817c478bd9Sstevel@tonic-gate 	if (debug != 0) {
8827c478bd9Sstevel@tonic-gate 		scf_value_set_count(v, debug);
8837c478bd9Sstevel@tonic-gate 		i.sdi_value = v;
8847c478bd9Sstevel@tonic-gate 	} else {
8857c478bd9Sstevel@tonic-gate 		i.sdi_value = SCF_DECORATE_CLEAR;
8867c478bd9Sstevel@tonic-gate 	}
8877c478bd9Sstevel@tonic-gate 
8887c478bd9Sstevel@tonic-gate 	if ((*f)(&i, data) == 0)
8897c478bd9Sstevel@tonic-gate 		return (0);
8907c478bd9Sstevel@tonic-gate 
8917c478bd9Sstevel@tonic-gate 	i.sdi_name = (const char *)"door_path";
8927c478bd9Sstevel@tonic-gate 	i.sdi_type = SCF_TYPE_ASTRING;
8937c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
8947c478bd9Sstevel@tonic-gate 	(void) strlcpy(name, handle->rh_doorpath, sizeof (name));
8957c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
8967c478bd9Sstevel@tonic-gate 	if (name[0] != 0) {
8977c478bd9Sstevel@tonic-gate 		(void) scf_value_set_astring(v, name);
8987c478bd9Sstevel@tonic-gate 		i.sdi_value = v;
8997c478bd9Sstevel@tonic-gate 	} else {
9007c478bd9Sstevel@tonic-gate 		i.sdi_value = SCF_DECORATE_CLEAR;
9017c478bd9Sstevel@tonic-gate 	}
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate 	if ((*f)(&i, data) == 0)
9047c478bd9Sstevel@tonic-gate 		return (0);
9057c478bd9Sstevel@tonic-gate 
9067c478bd9Sstevel@tonic-gate 	return (1);
9077c478bd9Sstevel@tonic-gate }
9087c478bd9Sstevel@tonic-gate 
9097c478bd9Sstevel@tonic-gate /*
9107c478bd9Sstevel@tonic-gate  * Fails if handle is not bound.
9117c478bd9Sstevel@tonic-gate  */
9127c478bd9Sstevel@tonic-gate static int
9137c478bd9Sstevel@tonic-gate handle_unbind_unlocked(scf_handle_t *handle)
9147c478bd9Sstevel@tonic-gate {
9157c478bd9Sstevel@tonic-gate 	rep_protocol_request_t request;
9167c478bd9Sstevel@tonic-gate 	rep_protocol_response_t response;
9177c478bd9Sstevel@tonic-gate 
9187c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(handle))
9197c478bd9Sstevel@tonic-gate 		return (-1);
9207c478bd9Sstevel@tonic-gate 
9217c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_CLOSE;
9227c478bd9Sstevel@tonic-gate 
9237c478bd9Sstevel@tonic-gate 	(void) make_door_call(handle, &request, sizeof (request),
9247c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
9257c478bd9Sstevel@tonic-gate 
9267c478bd9Sstevel@tonic-gate 	handle_do_close(handle);
9277c478bd9Sstevel@tonic-gate 
9287c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
9297c478bd9Sstevel@tonic-gate }
9307c478bd9Sstevel@tonic-gate 
9317c478bd9Sstevel@tonic-gate /*
9327c478bd9Sstevel@tonic-gate  * Fails with
9337c478bd9Sstevel@tonic-gate  *   _HANDLE_DESTROYED - dp's handle has been destroyed
9347c478bd9Sstevel@tonic-gate  *   _INTERNAL - server response too big
9357c478bd9Sstevel@tonic-gate  *		 entity already set up with different type
9367c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES - server out of memory
9377c478bd9Sstevel@tonic-gate  */
9387c478bd9Sstevel@tonic-gate static int
9397c478bd9Sstevel@tonic-gate datael_attach(scf_datael_t *dp)
9407c478bd9Sstevel@tonic-gate {
9417c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
9427c478bd9Sstevel@tonic-gate 
9437c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_setup request;
9447c478bd9Sstevel@tonic-gate 	rep_protocol_response_t response;
9457c478bd9Sstevel@tonic-gate 	ssize_t r;
9467c478bd9Sstevel@tonic-gate 
9477c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
9487c478bd9Sstevel@tonic-gate 
9497c478bd9Sstevel@tonic-gate 	dp->rd_reset = 0;		/* setup implicitly resets */
9507c478bd9Sstevel@tonic-gate 
9517c478bd9Sstevel@tonic-gate 	if (h->rh_flags & HANDLE_DEAD)
9527c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED));
9537c478bd9Sstevel@tonic-gate 
9547c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(h))
9557c478bd9Sstevel@tonic-gate 		return (SCF_SUCCESS);		/* nothing to do */
9567c478bd9Sstevel@tonic-gate 
9577c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_SETUP;
9587c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
9597c478bd9Sstevel@tonic-gate 	request.rpr_entitytype = dp->rd_type;
9607c478bd9Sstevel@tonic-gate 
9617c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
9627c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
9637c478bd9Sstevel@tonic-gate 
9647c478bd9Sstevel@tonic-gate 	if (r == NOT_BOUND || r == CALL_FAILED)
9657c478bd9Sstevel@tonic-gate 		return (SCF_SUCCESS);
9667c478bd9Sstevel@tonic-gate 	if (r == RESULT_TOO_BIG)
9677c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INTERNAL));
9687c478bd9Sstevel@tonic-gate 
9697c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
9707c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
9717c478bd9Sstevel@tonic-gate 
9727c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
9737c478bd9Sstevel@tonic-gate }
9747c478bd9Sstevel@tonic-gate 
9757c478bd9Sstevel@tonic-gate /*
9767c478bd9Sstevel@tonic-gate  * Fails with
9777c478bd9Sstevel@tonic-gate  *   _HANDLE_DESTROYED - iter's handle has been destroyed
9787c478bd9Sstevel@tonic-gate  *   _INTERNAL - server response too big
9797c478bd9Sstevel@tonic-gate  *		 iter already existed
9807c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES
9817c478bd9Sstevel@tonic-gate  */
9827c478bd9Sstevel@tonic-gate static int
9837c478bd9Sstevel@tonic-gate iter_attach(scf_iter_t *iter)
9847c478bd9Sstevel@tonic-gate {
9857c478bd9Sstevel@tonic-gate 	scf_handle_t *h = iter->iter_handle;
9867c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_request request;
9877c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
9887c478bd9Sstevel@tonic-gate 	int r;
9897c478bd9Sstevel@tonic-gate 
9907c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
9917c478bd9Sstevel@tonic-gate 
9927c478bd9Sstevel@tonic-gate 	if (h->rh_flags & HANDLE_DEAD)
9937c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED));
9947c478bd9Sstevel@tonic-gate 
9957c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(h))
9967c478bd9Sstevel@tonic-gate 		return (SCF_SUCCESS);		/* nothing to do */
9977c478bd9Sstevel@tonic-gate 
9987c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_SETUP;
9997c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
10007c478bd9Sstevel@tonic-gate 
10017c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
10027c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
10037c478bd9Sstevel@tonic-gate 
10047c478bd9Sstevel@tonic-gate 	if (r == NOT_BOUND || r == CALL_FAILED)
10057c478bd9Sstevel@tonic-gate 		return (SCF_SUCCESS);
10067c478bd9Sstevel@tonic-gate 	if (r == RESULT_TOO_BIG)
10077c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INTERNAL));
10087c478bd9Sstevel@tonic-gate 
10097c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
10107c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
10117c478bd9Sstevel@tonic-gate 
10127c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
10137c478bd9Sstevel@tonic-gate }
10147c478bd9Sstevel@tonic-gate 
10157c478bd9Sstevel@tonic-gate /*
10167c478bd9Sstevel@tonic-gate  * Fails with
10177c478bd9Sstevel@tonic-gate  *   _IN_USE - handle already bound
10187c478bd9Sstevel@tonic-gate  *   _NO_SERVER - server door could not be open()ed
10197c478bd9Sstevel@tonic-gate  *		  door call failed
10207c478bd9Sstevel@tonic-gate  *		  door_info() failed
10217c478bd9Sstevel@tonic-gate  *   _VERSION_MISMATCH - server returned bad file descriptor
10227c478bd9Sstevel@tonic-gate  *			 server claimed bad request
10237c478bd9Sstevel@tonic-gate  *			 server reported version mismatch
10247c478bd9Sstevel@tonic-gate  *			 server refused with unknown reason
10257c478bd9Sstevel@tonic-gate  *   _INVALID_ARGUMENT
10267c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES - server is out of memory
10277c478bd9Sstevel@tonic-gate  *   _PERMISSION_DENIED
10287c478bd9Sstevel@tonic-gate  *   _INTERNAL - could not set up entities or iters
10297c478bd9Sstevel@tonic-gate  *		 server response too big
10307c478bd9Sstevel@tonic-gate  *
10317c478bd9Sstevel@tonic-gate  * perhaps this should try multiple times.
10327c478bd9Sstevel@tonic-gate  */
10337c478bd9Sstevel@tonic-gate int
10347c478bd9Sstevel@tonic-gate scf_handle_bind(scf_handle_t *handle)
10357c478bd9Sstevel@tonic-gate {
10367c478bd9Sstevel@tonic-gate 	scf_datael_t *el;
10377c478bd9Sstevel@tonic-gate 	scf_iter_t *iter;
10387c478bd9Sstevel@tonic-gate 
10397c478bd9Sstevel@tonic-gate 	pid_t pid;
10407c478bd9Sstevel@tonic-gate 	int fd;
10417c478bd9Sstevel@tonic-gate 	int res;
10427c478bd9Sstevel@tonic-gate 	door_info_t info;
10437c478bd9Sstevel@tonic-gate 	repository_door_request_t request;
10447c478bd9Sstevel@tonic-gate 	repository_door_response_t response;
10457c478bd9Sstevel@tonic-gate 	const char *door_name = default_door_path;
10467c478bd9Sstevel@tonic-gate 
10477c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
10487c478bd9Sstevel@tonic-gate 	if (handle_is_bound(handle)) {
10497c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
10507c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_IN_USE));
10517c478bd9Sstevel@tonic-gate 	}
10527c478bd9Sstevel@tonic-gate 
10537c478bd9Sstevel@tonic-gate 	/* wait until any active fd users have cleared out */
1054a574db85Sraf 	while (handle->rh_fd_users > 0) {
1055a574db85Sraf 		int cancel_state;
1056a574db85Sraf 
1057a574db85Sraf 		(void) pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,
1058a574db85Sraf 		    &cancel_state);
1059a574db85Sraf 		(void) pthread_cond_wait(&handle->rh_cv, &handle->rh_lock);
1060a574db85Sraf 		(void) pthread_setcancelstate(cancel_state, NULL);
1061a574db85Sraf 	}
10627c478bd9Sstevel@tonic-gate 
10637c478bd9Sstevel@tonic-gate 	/* check again, since we had to drop the lock */
10647c478bd9Sstevel@tonic-gate 	if (handle_is_bound(handle)) {
10657c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
10667c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_IN_USE));
10677c478bd9Sstevel@tonic-gate 	}
10687c478bd9Sstevel@tonic-gate 
10697c478bd9Sstevel@tonic-gate 	assert(handle->rh_doorfd == -1 && handle->rh_doorfd_old == -1);
10707c478bd9Sstevel@tonic-gate 
10717c478bd9Sstevel@tonic-gate 	if (handle->rh_doorpath[0] != 0)
10727c478bd9Sstevel@tonic-gate 		door_name = handle->rh_doorpath;
10737c478bd9Sstevel@tonic-gate 
10747c478bd9Sstevel@tonic-gate 	fd = open(door_name, O_RDONLY, 0);
10757c478bd9Sstevel@tonic-gate 	if (fd == -1) {
10767c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
10777c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NO_SERVER));
10787c478bd9Sstevel@tonic-gate 	}
10797c478bd9Sstevel@tonic-gate 
10807c478bd9Sstevel@tonic-gate 	request.rdr_version = REPOSITORY_DOOR_VERSION;
10817c478bd9Sstevel@tonic-gate 	request.rdr_request = REPOSITORY_DOOR_REQUEST_CONNECT;
10827c478bd9Sstevel@tonic-gate 	request.rdr_flags = handle->rh_flags;
10837c478bd9Sstevel@tonic-gate 	request.rdr_debug = handle->rh_debug;
10847c478bd9Sstevel@tonic-gate 
10857c478bd9Sstevel@tonic-gate 	pid = getpid();
10867c478bd9Sstevel@tonic-gate 
10877c478bd9Sstevel@tonic-gate 	res = make_door_call_retfd(fd, &request, sizeof (request),
10887c478bd9Sstevel@tonic-gate 	    &response, sizeof (response), &handle->rh_doorfd);
10897c478bd9Sstevel@tonic-gate 
10907c478bd9Sstevel@tonic-gate 	(void) close(fd);
10917c478bd9Sstevel@tonic-gate 
10927c478bd9Sstevel@tonic-gate 	if (res < 0) {
10937c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
10947c478bd9Sstevel@tonic-gate 
10957c478bd9Sstevel@tonic-gate 		assert(res != NOT_BOUND);
10967c478bd9Sstevel@tonic-gate 		if (res == CALL_FAILED)
10977c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_NO_SERVER));
10987c478bd9Sstevel@tonic-gate 		assert(res == RESULT_TOO_BIG);
10997c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INTERNAL));
11007c478bd9Sstevel@tonic-gate 	}
11017c478bd9Sstevel@tonic-gate 
11027c478bd9Sstevel@tonic-gate 	if (handle->rh_doorfd < 0) {
11037c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
11047c478bd9Sstevel@tonic-gate 
11057c478bd9Sstevel@tonic-gate 		switch (response.rdr_status) {
11067c478bd9Sstevel@tonic-gate 		case REPOSITORY_DOOR_SUCCESS:
11077c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));
11087c478bd9Sstevel@tonic-gate 
11097c478bd9Sstevel@tonic-gate 		case REPOSITORY_DOOR_FAIL_BAD_REQUEST:
11107c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));
11117c478bd9Sstevel@tonic-gate 
11127c478bd9Sstevel@tonic-gate 		case REPOSITORY_DOOR_FAIL_VERSION_MISMATCH:
11137c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));
11147c478bd9Sstevel@tonic-gate 
11157c478bd9Sstevel@tonic-gate 		case REPOSITORY_DOOR_FAIL_BAD_FLAG:
11167c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
11177c478bd9Sstevel@tonic-gate 
11187c478bd9Sstevel@tonic-gate 		case REPOSITORY_DOOR_FAIL_NO_RESOURCES:
11197c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_NO_RESOURCES));
11207c478bd9Sstevel@tonic-gate 
11217c478bd9Sstevel@tonic-gate 		case REPOSITORY_DOOR_FAIL_PERMISSION_DENIED:
11227c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_PERMISSION_DENIED));
11237c478bd9Sstevel@tonic-gate 
11247c478bd9Sstevel@tonic-gate 		default:
11257c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_VERSION_MISMATCH));
11267c478bd9Sstevel@tonic-gate 		}
11277c478bd9Sstevel@tonic-gate 	}
11287c478bd9Sstevel@tonic-gate 
11297c478bd9Sstevel@tonic-gate 	(void) fcntl(handle->rh_doorfd, F_SETFD, FD_CLOEXEC);
11307c478bd9Sstevel@tonic-gate 
11317c478bd9Sstevel@tonic-gate 	if (door_info(handle->rh_doorfd, &info) < 0) {
11327c478bd9Sstevel@tonic-gate 		(void) close(handle->rh_doorfd);
11337c478bd9Sstevel@tonic-gate 		handle->rh_doorfd = -1;
11347c478bd9Sstevel@tonic-gate 
11357c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
11367c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NO_SERVER));
11377c478bd9Sstevel@tonic-gate 	}
11387c478bd9Sstevel@tonic-gate 
11397c478bd9Sstevel@tonic-gate 	handle->rh_doorpid = pid;
11407c478bd9Sstevel@tonic-gate 	handle->rh_doorid = info.di_uniquifier;
11417c478bd9Sstevel@tonic-gate 
11427c478bd9Sstevel@tonic-gate 	/*
11437c478bd9Sstevel@tonic-gate 	 * Now, re-attach everything
11447c478bd9Sstevel@tonic-gate 	 */
11457c478bd9Sstevel@tonic-gate 	for (el = uu_list_first(handle->rh_dataels); el != NULL;
11467c478bd9Sstevel@tonic-gate 	    el = uu_list_next(handle->rh_dataels, el)) {
11477c478bd9Sstevel@tonic-gate 		if (datael_attach(el) == -1) {
11487c478bd9Sstevel@tonic-gate 			assert(scf_error() != SCF_ERROR_HANDLE_DESTROYED);
11497c478bd9Sstevel@tonic-gate 			(void) handle_unbind_unlocked(handle);
11507c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&handle->rh_lock);
11517c478bd9Sstevel@tonic-gate 			return (-1);
11527c478bd9Sstevel@tonic-gate 		}
11537c478bd9Sstevel@tonic-gate 	}
11547c478bd9Sstevel@tonic-gate 
11557c478bd9Sstevel@tonic-gate 	for (iter = uu_list_first(handle->rh_iters); iter != NULL;
11567c478bd9Sstevel@tonic-gate 	    iter = uu_list_next(handle->rh_iters, iter)) {
11577c478bd9Sstevel@tonic-gate 		if (iter_attach(iter) == -1) {
11587c478bd9Sstevel@tonic-gate 			assert(scf_error() != SCF_ERROR_HANDLE_DESTROYED);
11597c478bd9Sstevel@tonic-gate 			(void) handle_unbind_unlocked(handle);
11607c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&handle->rh_lock);
11617c478bd9Sstevel@tonic-gate 			return (-1);
11627c478bd9Sstevel@tonic-gate 		}
11637c478bd9Sstevel@tonic-gate 	}
11647c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
11657c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
11667c478bd9Sstevel@tonic-gate }
11677c478bd9Sstevel@tonic-gate 
11687c478bd9Sstevel@tonic-gate int
11697c478bd9Sstevel@tonic-gate scf_handle_unbind(scf_handle_t *handle)
11707c478bd9Sstevel@tonic-gate {
11717c478bd9Sstevel@tonic-gate 	int ret;
11727c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
11737c478bd9Sstevel@tonic-gate 	ret = handle_unbind_unlocked(handle);
11747c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
11757c478bd9Sstevel@tonic-gate 	return (ret == SCF_SUCCESS ? ret : scf_set_error(SCF_ERROR_NOT_BOUND));
11767c478bd9Sstevel@tonic-gate }
11777c478bd9Sstevel@tonic-gate 
11787c478bd9Sstevel@tonic-gate static scf_handle_t *
11797c478bd9Sstevel@tonic-gate handle_get(scf_handle_t *h)
11807c478bd9Sstevel@tonic-gate {
11817c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
11827c478bd9Sstevel@tonic-gate 	if (h->rh_flags & HANDLE_DEAD) {
11837c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
11847c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED);
11857c478bd9Sstevel@tonic-gate 		return (NULL);
11867c478bd9Sstevel@tonic-gate 	}
11877c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
11887c478bd9Sstevel@tonic-gate 	return (h);
11897c478bd9Sstevel@tonic-gate }
11907c478bd9Sstevel@tonic-gate 
11917c478bd9Sstevel@tonic-gate /*
11927c478bd9Sstevel@tonic-gate  * Called when an object is removed from the handle.  On the last remove,
11937c478bd9Sstevel@tonic-gate  * cleans up and frees the handle.
11947c478bd9Sstevel@tonic-gate  */
11957c478bd9Sstevel@tonic-gate static void
11967c478bd9Sstevel@tonic-gate handle_unrefed(scf_handle_t *handle)
11977c478bd9Sstevel@tonic-gate {
11987c478bd9Sstevel@tonic-gate 	scf_iter_t *iter;
11997c478bd9Sstevel@tonic-gate 	scf_value_t *v;
12007c478bd9Sstevel@tonic-gate 	scf_scope_t *sc;
12017c478bd9Sstevel@tonic-gate 	scf_service_t *svc;
12027c478bd9Sstevel@tonic-gate 	scf_instance_t *inst;
12037c478bd9Sstevel@tonic-gate 	scf_snapshot_t *snap;
12047c478bd9Sstevel@tonic-gate 	scf_snaplevel_t *snaplvl;
12057c478bd9Sstevel@tonic-gate 	scf_propertygroup_t *pg;
12067c478bd9Sstevel@tonic-gate 	scf_property_t *prop;
12077c478bd9Sstevel@tonic-gate 
12087c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&handle->rh_lock));
12097c478bd9Sstevel@tonic-gate 
12107c478bd9Sstevel@tonic-gate 	/*
12117c478bd9Sstevel@tonic-gate 	 * Don't do anything if the handle has not yet been destroyed, there
12127c478bd9Sstevel@tonic-gate 	 * are still external references, or we're already doing unrefed
12137c478bd9Sstevel@tonic-gate 	 * handling.
12147c478bd9Sstevel@tonic-gate 	 */
12157c478bd9Sstevel@tonic-gate 	if (!(handle->rh_flags & HANDLE_DEAD) ||
12167c478bd9Sstevel@tonic-gate 	    handle->rh_extrefs > 0 ||
12177c478bd9Sstevel@tonic-gate 	    handle->rh_fd_users > 0 ||
12187c478bd9Sstevel@tonic-gate 	    (handle->rh_flags & HANDLE_UNREFED)) {
12197c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
12207c478bd9Sstevel@tonic-gate 		return;
12217c478bd9Sstevel@tonic-gate 	}
12227c478bd9Sstevel@tonic-gate 
12237c478bd9Sstevel@tonic-gate 	handle->rh_flags |= HANDLE_UNREFED;
12247c478bd9Sstevel@tonic-gate 
12257c478bd9Sstevel@tonic-gate 	/*
12267c478bd9Sstevel@tonic-gate 	 * Now that we know that there are no external references, and the
12277c478bd9Sstevel@tonic-gate 	 * HANDLE_DEAD flag keeps new ones from appearing, we can clean up
12287c478bd9Sstevel@tonic-gate 	 * our subhandles and destroy the handle completely.
12297c478bd9Sstevel@tonic-gate 	 */
12307c478bd9Sstevel@tonic-gate 	assert(handle->rh_intrefs >= 0);
12317c478bd9Sstevel@tonic-gate 	handle->rh_extrefs = handle->rh_intrefs;
12327c478bd9Sstevel@tonic-gate 	handle->rh_intrefs = 0;
12337c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
12347c478bd9Sstevel@tonic-gate 
12357c478bd9Sstevel@tonic-gate 	handle_hold_subhandles(handle, RH_HOLD_ALL);
12367c478bd9Sstevel@tonic-gate 
12377c478bd9Sstevel@tonic-gate 	iter = handle->rh_iter;
12387c478bd9Sstevel@tonic-gate 	sc = handle->rh_scope;
12397c478bd9Sstevel@tonic-gate 	svc = handle->rh_service;
12407c478bd9Sstevel@tonic-gate 	inst = handle->rh_instance;
12417c478bd9Sstevel@tonic-gate 	snap = handle->rh_snapshot;
12427c478bd9Sstevel@tonic-gate 	snaplvl = handle->rh_snaplvl;
12437c478bd9Sstevel@tonic-gate 	pg = handle->rh_pg;
12447c478bd9Sstevel@tonic-gate 	prop = handle->rh_property;
12457c478bd9Sstevel@tonic-gate 	v = handle->rh_value;
12467c478bd9Sstevel@tonic-gate 
12477c478bd9Sstevel@tonic-gate 	handle->rh_iter = NULL;
12487c478bd9Sstevel@tonic-gate 	handle->rh_scope = NULL;
12497c478bd9Sstevel@tonic-gate 	handle->rh_service = NULL;
12507c478bd9Sstevel@tonic-gate 	handle->rh_instance = NULL;
12517c478bd9Sstevel@tonic-gate 	handle->rh_snapshot = NULL;
12527c478bd9Sstevel@tonic-gate 	handle->rh_snaplvl = NULL;
12537c478bd9Sstevel@tonic-gate 	handle->rh_pg = NULL;
12547c478bd9Sstevel@tonic-gate 	handle->rh_property = NULL;
12557c478bd9Sstevel@tonic-gate 	handle->rh_value = NULL;
12567c478bd9Sstevel@tonic-gate 
12577c478bd9Sstevel@tonic-gate 	if (iter != NULL)
12587c478bd9Sstevel@tonic-gate 		scf_iter_destroy(iter);
12597c478bd9Sstevel@tonic-gate 	if (sc != NULL)
12607c478bd9Sstevel@tonic-gate 		scf_scope_destroy(sc);
12617c478bd9Sstevel@tonic-gate 	if (svc != NULL)
12627c478bd9Sstevel@tonic-gate 		scf_service_destroy(svc);
12637c478bd9Sstevel@tonic-gate 	if (inst != NULL)
12647c478bd9Sstevel@tonic-gate 		scf_instance_destroy(inst);
12657c478bd9Sstevel@tonic-gate 	if (snap != NULL)
12667c478bd9Sstevel@tonic-gate 		scf_snapshot_destroy(snap);
12677c478bd9Sstevel@tonic-gate 	if (snaplvl != NULL)
12687c478bd9Sstevel@tonic-gate 		scf_snaplevel_destroy(snaplvl);
12697c478bd9Sstevel@tonic-gate 	if (pg != NULL)
12707c478bd9Sstevel@tonic-gate 		scf_pg_destroy(pg);
12717c478bd9Sstevel@tonic-gate 	if (prop != NULL)
12727c478bd9Sstevel@tonic-gate 		scf_property_destroy(prop);
12737c478bd9Sstevel@tonic-gate 	if (v != NULL)
12747c478bd9Sstevel@tonic-gate 		scf_value_destroy(v);
12757c478bd9Sstevel@tonic-gate 
12767c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
12777c478bd9Sstevel@tonic-gate 
12787c478bd9Sstevel@tonic-gate 	/* there should be no outstanding children at this point */
12797c478bd9Sstevel@tonic-gate 	assert(handle->rh_extrefs == 0);
12807c478bd9Sstevel@tonic-gate 	assert(handle->rh_intrefs == 0);
12817c478bd9Sstevel@tonic-gate 	assert(handle->rh_values == 0);
12827c478bd9Sstevel@tonic-gate 	assert(handle->rh_entries == 0);
12837c478bd9Sstevel@tonic-gate 	assert(uu_list_numnodes(handle->rh_dataels) == 0);
12847c478bd9Sstevel@tonic-gate 	assert(uu_list_numnodes(handle->rh_iters) == 0);
12857c478bd9Sstevel@tonic-gate 
12867c478bd9Sstevel@tonic-gate 	uu_list_destroy(handle->rh_dataels);
12877c478bd9Sstevel@tonic-gate 	uu_list_destroy(handle->rh_iters);
12887c478bd9Sstevel@tonic-gate 	handle->rh_dataels = NULL;
12897c478bd9Sstevel@tonic-gate 	handle->rh_iters = NULL;
12907c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&handle->rh_lock);
12917c478bd9Sstevel@tonic-gate 
12927c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_destroy(&handle->rh_lock);
12937c478bd9Sstevel@tonic-gate 
12947c478bd9Sstevel@tonic-gate 	uu_free(handle);
12957c478bd9Sstevel@tonic-gate }
12967c478bd9Sstevel@tonic-gate 
12977c478bd9Sstevel@tonic-gate void
12987c478bd9Sstevel@tonic-gate scf_handle_destroy(scf_handle_t *handle)
12997c478bd9Sstevel@tonic-gate {
13007c478bd9Sstevel@tonic-gate 	if (handle == NULL)
13017c478bd9Sstevel@tonic-gate 		return;
13027c478bd9Sstevel@tonic-gate 
13037c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
13047c478bd9Sstevel@tonic-gate 	if (handle->rh_flags & HANDLE_DEAD) {
13057c478bd9Sstevel@tonic-gate 		/*
13067c478bd9Sstevel@tonic-gate 		 * This is an error (you are not allowed to reference the
13077c478bd9Sstevel@tonic-gate 		 * handle after it is destroyed), but we can't report it.
13087c478bd9Sstevel@tonic-gate 		 */
13097c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&handle->rh_lock);
13107c478bd9Sstevel@tonic-gate 		return;
13117c478bd9Sstevel@tonic-gate 	}
13127c478bd9Sstevel@tonic-gate 	handle->rh_flags |= HANDLE_DEAD;
13137c478bd9Sstevel@tonic-gate 	(void) handle_unbind_unlocked(handle);
13147c478bd9Sstevel@tonic-gate 	handle_unrefed(handle);
13157c478bd9Sstevel@tonic-gate }
13167c478bd9Sstevel@tonic-gate 
13177c478bd9Sstevel@tonic-gate ssize_t
13187c478bd9Sstevel@tonic-gate scf_myname(scf_handle_t *h, char *out, size_t len)
13197c478bd9Sstevel@tonic-gate {
13207c478bd9Sstevel@tonic-gate 	char *cp;
13217c478bd9Sstevel@tonic-gate 
13227c478bd9Sstevel@tonic-gate 	if (!handle_has_server(h))
13237c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
13247c478bd9Sstevel@tonic-gate 
13257c478bd9Sstevel@tonic-gate 	cp = getenv("SMF_FMRI");
13267c478bd9Sstevel@tonic-gate 	if (cp == NULL)
13277c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
13287c478bd9Sstevel@tonic-gate 
13297c478bd9Sstevel@tonic-gate 	return (strlcpy(out, cp, len));
13307c478bd9Sstevel@tonic-gate }
13317c478bd9Sstevel@tonic-gate 
13327c478bd9Sstevel@tonic-gate static uint32_t
13338918dff3Sjwadams handle_alloc_entityid(scf_handle_t *h)
13347c478bd9Sstevel@tonic-gate {
13358918dff3Sjwadams 	uint32_t nextid;
13368918dff3Sjwadams 
13378918dff3Sjwadams 	assert(MUTEX_HELD(&h->rh_lock));
13388918dff3Sjwadams 
13398918dff3Sjwadams 	if (uu_list_numnodes(h->rh_dataels) == UINT32_MAX)
13408918dff3Sjwadams 		return (0);		/* no ids available */
13418918dff3Sjwadams 
13428918dff3Sjwadams 	/*
13438918dff3Sjwadams 	 * The following loop assumes that there are not a huge number of
13448918dff3Sjwadams 	 * outstanding entities when we've wrapped.  If that ends up not
13458918dff3Sjwadams 	 * being the case, the O(N^2) nature of this search will hurt a lot,
13468918dff3Sjwadams 	 * and the data structure should be switched to an AVL tree.
13478918dff3Sjwadams 	 */
13488918dff3Sjwadams 	nextid = h->rh_nextentity + 1;
13498918dff3Sjwadams 	for (;;) {
13508918dff3Sjwadams 		scf_datael_t *cur;
13518918dff3Sjwadams 
13528918dff3Sjwadams 		if (nextid == 0) {
13538918dff3Sjwadams 			nextid++;
13548918dff3Sjwadams 			h->rh_flags |= HANDLE_WRAPPED_ENTITY;
13558918dff3Sjwadams 		}
13568918dff3Sjwadams 		if (!(h->rh_flags & HANDLE_WRAPPED_ENTITY))
13578918dff3Sjwadams 			break;
13588918dff3Sjwadams 
13598918dff3Sjwadams 		cur = uu_list_find(h->rh_dataels, NULL, &nextid, NULL);
13608918dff3Sjwadams 		if (cur == NULL)
13618918dff3Sjwadams 			break;		/* not in use */
13628918dff3Sjwadams 
13638918dff3Sjwadams 		if (nextid == h->rh_nextentity)
13648918dff3Sjwadams 			return (0);	/* wrapped around; no ids available */
13658918dff3Sjwadams 		nextid++;
13668918dff3Sjwadams 	}
13678918dff3Sjwadams 
13688918dff3Sjwadams 	h->rh_nextentity = nextid;
13698918dff3Sjwadams 	return (nextid);
13707c478bd9Sstevel@tonic-gate }
13717c478bd9Sstevel@tonic-gate 
13727c478bd9Sstevel@tonic-gate static uint32_t
13738918dff3Sjwadams handle_alloc_iterid(scf_handle_t *h)
13747c478bd9Sstevel@tonic-gate {
13758918dff3Sjwadams 	uint32_t nextid;
13768918dff3Sjwadams 
13778918dff3Sjwadams 	assert(MUTEX_HELD(&h->rh_lock));
13788918dff3Sjwadams 
13798918dff3Sjwadams 	if (uu_list_numnodes(h->rh_iters) == UINT32_MAX)
13808918dff3Sjwadams 		return (0);		/* no ids available */
13818918dff3Sjwadams 
13828918dff3Sjwadams 	/* see the comment in handle_alloc_entityid */
13838918dff3Sjwadams 	nextid = h->rh_nextiter + 1;
13848918dff3Sjwadams 	for (;;) {
13858918dff3Sjwadams 		scf_iter_t *cur;
13868918dff3Sjwadams 
13878918dff3Sjwadams 		if (nextid == 0) {
13888918dff3Sjwadams 			nextid++;
13898918dff3Sjwadams 			h->rh_flags |= HANDLE_WRAPPED_ITER;
13908918dff3Sjwadams 		}
13918918dff3Sjwadams 		if (!(h->rh_flags & HANDLE_WRAPPED_ITER))
13928918dff3Sjwadams 			break;			/* not yet wrapped */
13938918dff3Sjwadams 
13948918dff3Sjwadams 		cur = uu_list_find(h->rh_iters, NULL, &nextid, NULL);
13958918dff3Sjwadams 		if (cur == NULL)
13968918dff3Sjwadams 			break;		/* not in use */
13978918dff3Sjwadams 
13988918dff3Sjwadams 		if (nextid == h->rh_nextiter)
13998918dff3Sjwadams 			return (0);	/* wrapped around; no ids available */
14008918dff3Sjwadams 		nextid++;
14018918dff3Sjwadams 	}
14028918dff3Sjwadams 
14038918dff3Sjwadams 	h->rh_nextiter = nextid;
14048918dff3Sjwadams 	return (nextid);
14057c478bd9Sstevel@tonic-gate }
14067c478bd9Sstevel@tonic-gate 
14077c478bd9Sstevel@tonic-gate static uint32_t
14088918dff3Sjwadams handle_next_changeid(scf_handle_t *handle)
14097c478bd9Sstevel@tonic-gate {
14108918dff3Sjwadams 	uint32_t nextid;
14118918dff3Sjwadams 
14127c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&handle->rh_lock));
14138918dff3Sjwadams 
14148918dff3Sjwadams 	nextid = ++handle->rh_nextchangeid;
14158918dff3Sjwadams 	if (nextid == 0)
14168918dff3Sjwadams 		nextid = ++handle->rh_nextchangeid;
14178918dff3Sjwadams 	return (nextid);
14187c478bd9Sstevel@tonic-gate }
14197c478bd9Sstevel@tonic-gate 
14207c478bd9Sstevel@tonic-gate /*
14217c478bd9Sstevel@tonic-gate  * Fails with
14227c478bd9Sstevel@tonic-gate  *   _INVALID_ARGUMENT - h is NULL
14237c478bd9Sstevel@tonic-gate  *   _HANDLE_DESTROYED
14247c478bd9Sstevel@tonic-gate  *   _INTERNAL - server response too big
14257c478bd9Sstevel@tonic-gate  *		 entity already set up with different type
14267c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES
14277c478bd9Sstevel@tonic-gate  */
14287c478bd9Sstevel@tonic-gate static int
14297c478bd9Sstevel@tonic-gate datael_init(scf_datael_t *dp, scf_handle_t *h, uint32_t type)
14307c478bd9Sstevel@tonic-gate {
14317c478bd9Sstevel@tonic-gate 	int ret;
14327c478bd9Sstevel@tonic-gate 
14337c478bd9Sstevel@tonic-gate 	if (h == NULL)
14347c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
14357c478bd9Sstevel@tonic-gate 
14367c478bd9Sstevel@tonic-gate 	uu_list_node_init(dp, &dp->rd_node, datael_pool);
14377c478bd9Sstevel@tonic-gate 
14387c478bd9Sstevel@tonic-gate 	dp->rd_handle = h;
14397c478bd9Sstevel@tonic-gate 	dp->rd_type = type;
14407c478bd9Sstevel@tonic-gate 	dp->rd_reset = 0;
14417c478bd9Sstevel@tonic-gate 
14427c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
14437c478bd9Sstevel@tonic-gate 	if (h->rh_flags & HANDLE_DEAD) {
14447c478bd9Sstevel@tonic-gate 		/*
14457c478bd9Sstevel@tonic-gate 		 * we're in undefined territory (the user cannot use a handle
14467c478bd9Sstevel@tonic-gate 		 * directly after it has been destroyed), but we don't want
14477c478bd9Sstevel@tonic-gate 		 * to allow any new references to happen, so we fail here.
14487c478bd9Sstevel@tonic-gate 		 */
14497c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
14507c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_DESTROYED));
14517c478bd9Sstevel@tonic-gate 	}
14527c478bd9Sstevel@tonic-gate 	dp->rd_entity = handle_alloc_entityid(h);
14538918dff3Sjwadams 	if (dp->rd_entity == 0) {
14548918dff3Sjwadams 		(void) pthread_mutex_unlock(&h->rh_lock);
14558918dff3Sjwadams 		uu_list_node_fini(dp, &dp->rd_node, datael_pool);
14568918dff3Sjwadams 		return (scf_set_error(SCF_ERROR_NO_MEMORY));
14578918dff3Sjwadams 	}
14587c478bd9Sstevel@tonic-gate 
14597c478bd9Sstevel@tonic-gate 	ret = datael_attach(dp);
14607c478bd9Sstevel@tonic-gate 	if (ret == 0) {
14617c478bd9Sstevel@tonic-gate 		(void) uu_list_insert_before(h->rh_dataels, NULL, dp);
14627c478bd9Sstevel@tonic-gate 		h->rh_extrefs++;
14637c478bd9Sstevel@tonic-gate 	} else {
14647c478bd9Sstevel@tonic-gate 		uu_list_node_fini(dp, &dp->rd_node, datael_pool);
14657c478bd9Sstevel@tonic-gate 	}
14667c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
14677c478bd9Sstevel@tonic-gate 
14687c478bd9Sstevel@tonic-gate 	return (ret);
14697c478bd9Sstevel@tonic-gate }
14707c478bd9Sstevel@tonic-gate 
14717c478bd9Sstevel@tonic-gate static void
14727c478bd9Sstevel@tonic-gate datael_destroy(scf_datael_t *dp)
14737c478bd9Sstevel@tonic-gate {
14747c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
14757c478bd9Sstevel@tonic-gate 
14767c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_teardown request;
14777c478bd9Sstevel@tonic-gate 	rep_protocol_response_t response;
14787c478bd9Sstevel@tonic-gate 
14797c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
14807c478bd9Sstevel@tonic-gate 	uu_list_remove(h->rh_dataels, dp);
14817c478bd9Sstevel@tonic-gate 	--h->rh_extrefs;
14827c478bd9Sstevel@tonic-gate 
14837c478bd9Sstevel@tonic-gate 	if (handle_is_bound(h)) {
14847c478bd9Sstevel@tonic-gate 		request.rpr_request = REP_PROTOCOL_ENTITY_TEARDOWN;
14857c478bd9Sstevel@tonic-gate 		request.rpr_entityid = dp->rd_entity;
14867c478bd9Sstevel@tonic-gate 
14877c478bd9Sstevel@tonic-gate 		(void) make_door_call(h, &request, sizeof (request),
14887c478bd9Sstevel@tonic-gate 		    &response, sizeof (response));
14897c478bd9Sstevel@tonic-gate 	}
14907c478bd9Sstevel@tonic-gate 	handle_unrefed(h);			/* drops h->rh_lock */
14917c478bd9Sstevel@tonic-gate 
14927c478bd9Sstevel@tonic-gate 	dp->rd_handle = NULL;
14937c478bd9Sstevel@tonic-gate }
14947c478bd9Sstevel@tonic-gate 
14957c478bd9Sstevel@tonic-gate static scf_handle_t *
14967c478bd9Sstevel@tonic-gate datael_handle(const scf_datael_t *dp)
14977c478bd9Sstevel@tonic-gate {
14987c478bd9Sstevel@tonic-gate 	return (handle_get(dp->rd_handle));
14997c478bd9Sstevel@tonic-gate }
15007c478bd9Sstevel@tonic-gate 
15017c478bd9Sstevel@tonic-gate /*
15027c478bd9Sstevel@tonic-gate  * We delay ENTITY_RESETs until right before the entity is used.  By doing
15037c478bd9Sstevel@tonic-gate  * them lazily, we remove quite a few unnecessary calls.
15047c478bd9Sstevel@tonic-gate  */
15057c478bd9Sstevel@tonic-gate static void
15067c478bd9Sstevel@tonic-gate datael_do_reset_locked(scf_datael_t *dp)
15077c478bd9Sstevel@tonic-gate {
15087c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
15097c478bd9Sstevel@tonic-gate 
15107c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_reset request;
15117c478bd9Sstevel@tonic-gate 	rep_protocol_response_t response;
15127c478bd9Sstevel@tonic-gate 
15137c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
15147c478bd9Sstevel@tonic-gate 
15157c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_RESET;
15167c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
15177c478bd9Sstevel@tonic-gate 
15187c478bd9Sstevel@tonic-gate 	(void) make_door_call(h, &request, sizeof (request),
15197c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
15207c478bd9Sstevel@tonic-gate 
15217c478bd9Sstevel@tonic-gate 	dp->rd_reset = 0;
15227c478bd9Sstevel@tonic-gate }
15237c478bd9Sstevel@tonic-gate 
15247c478bd9Sstevel@tonic-gate static void
15257c478bd9Sstevel@tonic-gate datael_reset_locked(scf_datael_t *dp)
15267c478bd9Sstevel@tonic-gate {
15277c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&dp->rd_handle->rh_lock));
15287c478bd9Sstevel@tonic-gate 	dp->rd_reset = 1;
15297c478bd9Sstevel@tonic-gate }
15307c478bd9Sstevel@tonic-gate 
15317c478bd9Sstevel@tonic-gate static void
15327c478bd9Sstevel@tonic-gate datael_reset(scf_datael_t *dp)
15337c478bd9Sstevel@tonic-gate {
15347c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
15357c478bd9Sstevel@tonic-gate 
15367c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
15377c478bd9Sstevel@tonic-gate 	dp->rd_reset = 1;
15387c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
15397c478bd9Sstevel@tonic-gate }
15407c478bd9Sstevel@tonic-gate 
15417c478bd9Sstevel@tonic-gate static void
15427c478bd9Sstevel@tonic-gate datael_finish_reset(const scf_datael_t *dp_arg)
15437c478bd9Sstevel@tonic-gate {
15447c478bd9Sstevel@tonic-gate 	scf_datael_t *dp = (scf_datael_t *)dp_arg;
15457c478bd9Sstevel@tonic-gate 
15467c478bd9Sstevel@tonic-gate 	if (dp->rd_reset)
15477c478bd9Sstevel@tonic-gate 		datael_do_reset_locked(dp);
15487c478bd9Sstevel@tonic-gate }
15497c478bd9Sstevel@tonic-gate 
15507c478bd9Sstevel@tonic-gate /*
15517c478bd9Sstevel@tonic-gate  * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
15527c478bd9Sstevel@tonic-gate  * big, bad entity id, request not applicable to entity, name too long for
15537c478bd9Sstevel@tonic-gate  * buffer), _NOT_SET, _DELETED, or _CONSTRAINT_VIOLATED (snaplevel is not of an
15547c478bd9Sstevel@tonic-gate  * instance).
15557c478bd9Sstevel@tonic-gate  */
15567c478bd9Sstevel@tonic-gate static ssize_t
15577c478bd9Sstevel@tonic-gate datael_get_name(const scf_datael_t *dp, char *buf, size_t size, uint32_t type)
15587c478bd9Sstevel@tonic-gate {
15597c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
15607c478bd9Sstevel@tonic-gate 
15617c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_name request;
15627c478bd9Sstevel@tonic-gate 	struct rep_protocol_name_response response;
15637c478bd9Sstevel@tonic-gate 	ssize_t r;
15647c478bd9Sstevel@tonic-gate 
15657c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
15667c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_NAME;
15677c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
15687c478bd9Sstevel@tonic-gate 	request.rpr_answertype = type;
15697c478bd9Sstevel@tonic-gate 
15707c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
15717c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
15727c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
15737c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
15747c478bd9Sstevel@tonic-gate 
15757c478bd9Sstevel@tonic-gate 	if (r < 0)
15767c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
15777c478bd9Sstevel@tonic-gate 
15787c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
15797c478bd9Sstevel@tonic-gate 		assert(response.rpr_response != REP_PROTOCOL_FAIL_BAD_REQUEST);
15807c478bd9Sstevel@tonic-gate 		if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_FOUND)
15817c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
15827c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
15837c478bd9Sstevel@tonic-gate 	}
15847c478bd9Sstevel@tonic-gate 	return (strlcpy(buf, response.rpr_name, size));
15857c478bd9Sstevel@tonic-gate }
15867c478bd9Sstevel@tonic-gate 
15877c478bd9Sstevel@tonic-gate /*
15887c478bd9Sstevel@tonic-gate  * Fails with _HANDLE_MISMATCH, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL
15897c478bd9Sstevel@tonic-gate  * (server response too big, bad element id), _EXISTS (elements have same id),
15907c478bd9Sstevel@tonic-gate  * _NOT_SET, _DELETED, _CONSTRAINT_VIOLATED, _NOT_FOUND (scope has no parent),
15917c478bd9Sstevel@tonic-gate  * or _SUCCESS.
15927c478bd9Sstevel@tonic-gate  */
15937c478bd9Sstevel@tonic-gate static int
15947c478bd9Sstevel@tonic-gate datael_get_parent(const scf_datael_t *dp, scf_datael_t *pp)
15957c478bd9Sstevel@tonic-gate {
15967c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
15977c478bd9Sstevel@tonic-gate 
15987c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_parent request;
15997c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
16007c478bd9Sstevel@tonic-gate 
16017c478bd9Sstevel@tonic-gate 	ssize_t r;
16027c478bd9Sstevel@tonic-gate 
16037c478bd9Sstevel@tonic-gate 	if (h != pp->rd_handle)
16047c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
16057c478bd9Sstevel@tonic-gate 
16067c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
16077c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_GET_PARENT;
16087c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
16097c478bd9Sstevel@tonic-gate 	request.rpr_outid = pp->rd_entity;
16107c478bd9Sstevel@tonic-gate 
16117c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
16127c478bd9Sstevel@tonic-gate 	datael_finish_reset(pp);
16137c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
16147c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
16157c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
16167c478bd9Sstevel@tonic-gate 
16177c478bd9Sstevel@tonic-gate 	if (r < 0)
16187c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
16197c478bd9Sstevel@tonic-gate 
16207c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
16217c478bd9Sstevel@tonic-gate 		if (response.rpr_response == REP_PROTOCOL_FAIL_TYPE_MISMATCH)
16227c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
16237c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
16247c478bd9Sstevel@tonic-gate 	}
16257c478bd9Sstevel@tonic-gate 
16267c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
16277c478bd9Sstevel@tonic-gate }
16287c478bd9Sstevel@tonic-gate 
16297c478bd9Sstevel@tonic-gate /*
16307c478bd9Sstevel@tonic-gate  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type,
16317c478bd9Sstevel@tonic-gate  * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
16327c478bd9Sstevel@tonic-gate  * too big, bad id, iter already exists, element cannot have children of type,
16337c478bd9Sstevel@tonic-gate  * type is invalid, iter was reset, sequence was bad, iter walks values, iter
16347c478bd9Sstevel@tonic-gate  * does not walk type entities), _NOT_SET, _DELETED, _NO_RESOURCES,
163576cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
16367c478bd9Sstevel@tonic-gate  */
16377c478bd9Sstevel@tonic-gate static int
16387c478bd9Sstevel@tonic-gate datael_get_child_composed_locked(const scf_datael_t *dp, const char *name,
16397c478bd9Sstevel@tonic-gate     uint32_t type, scf_datael_t *out, scf_iter_t *iter)
16407c478bd9Sstevel@tonic-gate {
16417c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_start request;
16427c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_read read_request;
16437c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
16447c478bd9Sstevel@tonic-gate 
16457c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
16467c478bd9Sstevel@tonic-gate 	ssize_t r;
16477c478bd9Sstevel@tonic-gate 
16487c478bd9Sstevel@tonic-gate 	if (h != out->rd_handle)
16497c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
16507c478bd9Sstevel@tonic-gate 
16517c478bd9Sstevel@tonic-gate 	if (out->rd_type != type)
16527c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
16537c478bd9Sstevel@tonic-gate 
16547c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
16557c478bd9Sstevel@tonic-gate 	assert(iter != NULL);
16567c478bd9Sstevel@tonic-gate 
16577c478bd9Sstevel@tonic-gate 	scf_iter_reset_locked(iter);
16587c478bd9Sstevel@tonic-gate 	iter->iter_type = type;
16597c478bd9Sstevel@tonic-gate 
16607c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_START;
16617c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
16627c478bd9Sstevel@tonic-gate 	request.rpr_entity = dp->rd_entity;
16637c478bd9Sstevel@tonic-gate 	request.rpr_itertype = type;
16647c478bd9Sstevel@tonic-gate 	request.rpr_flags = RP_ITER_START_EXACT | RP_ITER_START_COMPOSED;
16657c478bd9Sstevel@tonic-gate 
16667c478bd9Sstevel@tonic-gate 	if (name == NULL || strlcpy(request.rpr_pattern, name,
16677c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_pattern)) >= sizeof (request.rpr_pattern)) {
16687c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
16697c478bd9Sstevel@tonic-gate 	}
16707c478bd9Sstevel@tonic-gate 
16717c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
16727c478bd9Sstevel@tonic-gate 	datael_finish_reset(out);
16737c478bd9Sstevel@tonic-gate 
16747c478bd9Sstevel@tonic-gate 	/*
16757c478bd9Sstevel@tonic-gate 	 * We hold the handle lock across both door calls, so that they
16767c478bd9Sstevel@tonic-gate 	 * appear atomic.
16777c478bd9Sstevel@tonic-gate 	 */
16787c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
16797c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
16807c478bd9Sstevel@tonic-gate 
16817c478bd9Sstevel@tonic-gate 	if (r < 0)
16827c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
16837c478bd9Sstevel@tonic-gate 
16847c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
16857c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
16867c478bd9Sstevel@tonic-gate 
16877c478bd9Sstevel@tonic-gate 	iter->iter_sequence++;
16887c478bd9Sstevel@tonic-gate 
16897c478bd9Sstevel@tonic-gate 	read_request.rpr_request = REP_PROTOCOL_ITER_READ;
16907c478bd9Sstevel@tonic-gate 	read_request.rpr_iterid = iter->iter_id;
16917c478bd9Sstevel@tonic-gate 	read_request.rpr_sequence = iter->iter_sequence;
16927c478bd9Sstevel@tonic-gate 	read_request.rpr_entityid = out->rd_entity;
16937c478bd9Sstevel@tonic-gate 
16947c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &read_request, sizeof (read_request),
16957c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
16967c478bd9Sstevel@tonic-gate 
16977c478bd9Sstevel@tonic-gate 	scf_iter_reset_locked(iter);
16987c478bd9Sstevel@tonic-gate 
16997c478bd9Sstevel@tonic-gate 	if (r < 0)
17007c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
17017c478bd9Sstevel@tonic-gate 
17027c478bd9Sstevel@tonic-gate 	if (response.rpr_response == REP_PROTOCOL_DONE) {
17037c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_FOUND));
17047c478bd9Sstevel@tonic-gate 	}
17057c478bd9Sstevel@tonic-gate 
17067c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
17077c478bd9Sstevel@tonic-gate 		if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_SET ||
17087c478bd9Sstevel@tonic-gate 		    response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
17097c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INTERNAL));
17107c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
17117c478bd9Sstevel@tonic-gate 	}
17127c478bd9Sstevel@tonic-gate 
17137c478bd9Sstevel@tonic-gate 	return (0);
17147c478bd9Sstevel@tonic-gate }
17157c478bd9Sstevel@tonic-gate 
17167c478bd9Sstevel@tonic-gate /*
17177c478bd9Sstevel@tonic-gate  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type,
17187c478bd9Sstevel@tonic-gate  * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
17197c478bd9Sstevel@tonic-gate  * too big, bad id, element cannot have children of type, type is invalid),
17207c478bd9Sstevel@tonic-gate  * _NOT_SET, _DELETED, _NO_RESOURCES, _BACKEND_ACCESS.
17217c478bd9Sstevel@tonic-gate  */
17227c478bd9Sstevel@tonic-gate static int
17237c478bd9Sstevel@tonic-gate datael_get_child_locked(const scf_datael_t *dp, const char *name,
17247c478bd9Sstevel@tonic-gate     uint32_t type, scf_datael_t *out)
17257c478bd9Sstevel@tonic-gate {
17267c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_get_child request;
17277c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
17287c478bd9Sstevel@tonic-gate 
17297c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
17307c478bd9Sstevel@tonic-gate 	ssize_t r;
17317c478bd9Sstevel@tonic-gate 
17327c478bd9Sstevel@tonic-gate 	if (h != out->rd_handle)
17337c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
17347c478bd9Sstevel@tonic-gate 
17357c478bd9Sstevel@tonic-gate 	if (out->rd_type != type)
17367c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
17377c478bd9Sstevel@tonic-gate 
17387c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
17397c478bd9Sstevel@tonic-gate 
17407c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_GET_CHILD;
17417c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
17427c478bd9Sstevel@tonic-gate 	request.rpr_childid = out->rd_entity;
17437c478bd9Sstevel@tonic-gate 
17447c478bd9Sstevel@tonic-gate 	if (name == NULL || strlcpy(request.rpr_name, name,
17457c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_name)) >= sizeof (request.rpr_name)) {
17467c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
17477c478bd9Sstevel@tonic-gate 	}
17487c478bd9Sstevel@tonic-gate 
17497c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
17507c478bd9Sstevel@tonic-gate 	datael_finish_reset(out);
17517c478bd9Sstevel@tonic-gate 
17527c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
17537c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
17547c478bd9Sstevel@tonic-gate 
17557c478bd9Sstevel@tonic-gate 	if (r < 0)
17567c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
17577c478bd9Sstevel@tonic-gate 
17587c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
17597c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
17607c478bd9Sstevel@tonic-gate 	return (0);
17617c478bd9Sstevel@tonic-gate }
17627c478bd9Sstevel@tonic-gate 
176376cf44abSjeanm /*
176476cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT (out does not have type type,
176576cf44abSjeanm  * name is invalid), _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response
176676cf44abSjeanm  * too big, bad id, iter already exists, element cannot have children of type,
176776cf44abSjeanm  * type is invalid, iter was reset, sequence was bad, iter walks values, iter
176876cf44abSjeanm  * does not walk type entities), _NOT_SET, _DELETED, _NO_RESOURCES,
176976cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
177076cf44abSjeanm  */
17717c478bd9Sstevel@tonic-gate static int
17727c478bd9Sstevel@tonic-gate datael_get_child(const scf_datael_t *dp, const char *name, uint32_t type,
17737c478bd9Sstevel@tonic-gate     scf_datael_t *out, boolean_t composed)
17747c478bd9Sstevel@tonic-gate {
17757c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
17767c478bd9Sstevel@tonic-gate 	uint32_t held = 0;
17777c478bd9Sstevel@tonic-gate 	int ret;
17787c478bd9Sstevel@tonic-gate 
17797c478bd9Sstevel@tonic-gate 	scf_iter_t *iter = NULL;
17807c478bd9Sstevel@tonic-gate 
17817c478bd9Sstevel@tonic-gate 	if (composed)
17827c478bd9Sstevel@tonic-gate 		iter = HANDLE_HOLD_ITER(h);
17837c478bd9Sstevel@tonic-gate 
17847c478bd9Sstevel@tonic-gate 	if (out == NULL) {
17857c478bd9Sstevel@tonic-gate 		switch (type) {
17867c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_SERVICE:
17877c478bd9Sstevel@tonic-gate 			out = &HANDLE_HOLD_SERVICE(h)->rd_d;
17887c478bd9Sstevel@tonic-gate 			held = RH_HOLD_SERVICE;
17897c478bd9Sstevel@tonic-gate 			break;
17907c478bd9Sstevel@tonic-gate 
17917c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_INSTANCE:
17927c478bd9Sstevel@tonic-gate 			out = &HANDLE_HOLD_INSTANCE(h)->rd_d;
17937c478bd9Sstevel@tonic-gate 			held = RH_HOLD_INSTANCE;
17947c478bd9Sstevel@tonic-gate 			break;
17957c478bd9Sstevel@tonic-gate 
17967c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_SNAPSHOT:
17977c478bd9Sstevel@tonic-gate 			out = &HANDLE_HOLD_SNAPSHOT(h)->rd_d;
17987c478bd9Sstevel@tonic-gate 			held = RH_HOLD_SNAPSHOT;
17997c478bd9Sstevel@tonic-gate 			break;
18007c478bd9Sstevel@tonic-gate 
18017c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_SNAPLEVEL:
18027c478bd9Sstevel@tonic-gate 			out = &HANDLE_HOLD_SNAPLVL(h)->rd_d;
18037c478bd9Sstevel@tonic-gate 			held = RH_HOLD_SNAPLVL;
18047c478bd9Sstevel@tonic-gate 			break;
18057c478bd9Sstevel@tonic-gate 
18067c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_PROPERTYGRP:
18077c478bd9Sstevel@tonic-gate 			out = &HANDLE_HOLD_PG(h)->rd_d;
18087c478bd9Sstevel@tonic-gate 			held = RH_HOLD_PG;
18097c478bd9Sstevel@tonic-gate 			break;
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_PROPERTY:
18127c478bd9Sstevel@tonic-gate 			out = &HANDLE_HOLD_PROPERTY(h)->rd_d;
18137c478bd9Sstevel@tonic-gate 			held = RH_HOLD_PROPERTY;
18147c478bd9Sstevel@tonic-gate 			break;
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate 		default:
18177c478bd9Sstevel@tonic-gate 			assert(0);
18187c478bd9Sstevel@tonic-gate 			abort();
18197c478bd9Sstevel@tonic-gate 		}
18207c478bd9Sstevel@tonic-gate 	}
18217c478bd9Sstevel@tonic-gate 
18227c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
18237c478bd9Sstevel@tonic-gate 	if (composed)
18247c478bd9Sstevel@tonic-gate 		ret = datael_get_child_composed_locked(dp, name, type, out,
18257c478bd9Sstevel@tonic-gate 		    iter);
18267c478bd9Sstevel@tonic-gate 	else
18277c478bd9Sstevel@tonic-gate 		ret = datael_get_child_locked(dp, name, type, out);
18287c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
18297c478bd9Sstevel@tonic-gate 
18307c478bd9Sstevel@tonic-gate 	if (composed)
18317c478bd9Sstevel@tonic-gate 		HANDLE_RELE_ITER(h);
18327c478bd9Sstevel@tonic-gate 
18337c478bd9Sstevel@tonic-gate 	if (held)
18347c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, held);
18357c478bd9Sstevel@tonic-gate 
18367c478bd9Sstevel@tonic-gate 	return (ret);
18377c478bd9Sstevel@tonic-gate }
18387c478bd9Sstevel@tonic-gate 
18397c478bd9Sstevel@tonic-gate /*
18407c478bd9Sstevel@tonic-gate  * Fails with
18417c478bd9Sstevel@tonic-gate  *   _HANDLE_MISMATCH
18427c478bd9Sstevel@tonic-gate  *   _INVALID_ARGUMENT - name is too long
18437c478bd9Sstevel@tonic-gate  *			 invalid changeid
18447c478bd9Sstevel@tonic-gate  *			 name is invalid
18457c478bd9Sstevel@tonic-gate  *			 cannot create children for dp's type of node
18467c478bd9Sstevel@tonic-gate  *   _NOT_BOUND - handle is not bound
18477c478bd9Sstevel@tonic-gate  *   _CONNECTION_BROKEN - server is not reachable
18487c478bd9Sstevel@tonic-gate  *   _INTERNAL - server response too big
18497c478bd9Sstevel@tonic-gate  *		 dp or cp has unknown id
18507c478bd9Sstevel@tonic-gate  *		 type is _PROPERTYGRP
18517c478bd9Sstevel@tonic-gate  *		 type is invalid
18527c478bd9Sstevel@tonic-gate  *		 dp cannot have children of type type
18537c478bd9Sstevel@tonic-gate  *		 database is corrupt
18547c478bd9Sstevel@tonic-gate  *   _EXISTS - dp & cp have the same id
18557c478bd9Sstevel@tonic-gate  *   _EXISTS - child already exists
18567c478bd9Sstevel@tonic-gate  *   _DELETED - dp has been deleted
18577c478bd9Sstevel@tonic-gate  *   _NOT_SET - dp is reset
18587c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES
18597c478bd9Sstevel@tonic-gate  *   _PERMISSION_DENIED
18607c478bd9Sstevel@tonic-gate  *   _BACKEND_ACCESS
18617c478bd9Sstevel@tonic-gate  *   _BACKEND_READONLY
18627c478bd9Sstevel@tonic-gate  */
18637c478bd9Sstevel@tonic-gate static int
18647c478bd9Sstevel@tonic-gate datael_add_child(const scf_datael_t *dp, const char *name, uint32_t type,
18657c478bd9Sstevel@tonic-gate     scf_datael_t *cp)
18667c478bd9Sstevel@tonic-gate {
18677c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
18687c478bd9Sstevel@tonic-gate 
18697c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_create_child request;
18707c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
18717c478bd9Sstevel@tonic-gate 	ssize_t r;
18727c478bd9Sstevel@tonic-gate 	uint32_t held = 0;
18737c478bd9Sstevel@tonic-gate 
18747c478bd9Sstevel@tonic-gate 	if (cp == NULL) {
18757c478bd9Sstevel@tonic-gate 		switch (type) {
18767c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_SCOPE:
18777c478bd9Sstevel@tonic-gate 			cp = &HANDLE_HOLD_SCOPE(h)->rd_d;
18787c478bd9Sstevel@tonic-gate 			held = RH_HOLD_SCOPE;
18797c478bd9Sstevel@tonic-gate 			break;
18807c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_SERVICE:
18817c478bd9Sstevel@tonic-gate 			cp = &HANDLE_HOLD_SERVICE(h)->rd_d;
18827c478bd9Sstevel@tonic-gate 			held = RH_HOLD_SERVICE;
18837c478bd9Sstevel@tonic-gate 			break;
18847c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_INSTANCE:
18857c478bd9Sstevel@tonic-gate 			cp = &HANDLE_HOLD_INSTANCE(h)->rd_d;
18867c478bd9Sstevel@tonic-gate 			held = RH_HOLD_INSTANCE;
18877c478bd9Sstevel@tonic-gate 			break;
18887c478bd9Sstevel@tonic-gate 		case REP_PROTOCOL_ENTITY_SNAPSHOT:
18897c478bd9Sstevel@tonic-gate 		default:
18907c478bd9Sstevel@tonic-gate 			assert(0);
18917c478bd9Sstevel@tonic-gate 			abort();
18927c478bd9Sstevel@tonic-gate 		}
18937c478bd9Sstevel@tonic-gate 		assert(h == cp->rd_handle);
18947c478bd9Sstevel@tonic-gate 
18957c478bd9Sstevel@tonic-gate 	} else if (h != cp->rd_handle) {
18967c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
18977c478bd9Sstevel@tonic-gate 	}
18987c478bd9Sstevel@tonic-gate 
18997c478bd9Sstevel@tonic-gate 	if (strlcpy(request.rpr_name, name, sizeof (request.rpr_name)) >=
19007c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_name)) {
19017c478bd9Sstevel@tonic-gate 		r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
19027c478bd9Sstevel@tonic-gate 		goto err;
19037c478bd9Sstevel@tonic-gate 	}
19047c478bd9Sstevel@tonic-gate 
19057c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
19067c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_CREATE_CHILD;
19077c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
19087c478bd9Sstevel@tonic-gate 	request.rpr_childtype = type;
19097c478bd9Sstevel@tonic-gate 	request.rpr_childid = cp->rd_entity;
19107c478bd9Sstevel@tonic-gate 
19117c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
19128918dff3Sjwadams 	request.rpr_changeid = handle_next_changeid(h);
19137c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
19147c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
19157c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
19167c478bd9Sstevel@tonic-gate 
19177c478bd9Sstevel@tonic-gate 	if (held)
19187c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, held);
19197c478bd9Sstevel@tonic-gate 
19207c478bd9Sstevel@tonic-gate 	if (r < 0)
19217c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
19227c478bd9Sstevel@tonic-gate 
19237c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
19247c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
19257c478bd9Sstevel@tonic-gate 
19267c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
19277c478bd9Sstevel@tonic-gate 
19287c478bd9Sstevel@tonic-gate err:
19297c478bd9Sstevel@tonic-gate 	if (held)
19307c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, held);
19317c478bd9Sstevel@tonic-gate 	return (r);
19327c478bd9Sstevel@tonic-gate }
19337c478bd9Sstevel@tonic-gate 
19347c478bd9Sstevel@tonic-gate static int
19357c478bd9Sstevel@tonic-gate datael_add_pg(const scf_datael_t *dp, const char *name, const char *type,
19367c478bd9Sstevel@tonic-gate     uint32_t flags, scf_datael_t *cp)
19377c478bd9Sstevel@tonic-gate {
19387c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
19397c478bd9Sstevel@tonic-gate 
19407c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_create_pg request;
19417c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
19427c478bd9Sstevel@tonic-gate 	ssize_t r;
19437c478bd9Sstevel@tonic-gate 
19447c478bd9Sstevel@tonic-gate 	int holding_els = 0;
19457c478bd9Sstevel@tonic-gate 
19467c478bd9Sstevel@tonic-gate 	if (cp == NULL) {
19477c478bd9Sstevel@tonic-gate 		holding_els = 1;
19487c478bd9Sstevel@tonic-gate 		cp = &HANDLE_HOLD_PG(h)->rd_d;
19497c478bd9Sstevel@tonic-gate 		assert(h == cp->rd_handle);
19507c478bd9Sstevel@tonic-gate 
19517c478bd9Sstevel@tonic-gate 	} else if (h != cp->rd_handle) {
19527c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
19537c478bd9Sstevel@tonic-gate 	}
19547c478bd9Sstevel@tonic-gate 
19557c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_CREATE_PG;
19567c478bd9Sstevel@tonic-gate 
19577c478bd9Sstevel@tonic-gate 	if (name == NULL || strlcpy(request.rpr_name, name,
19587c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_name)) > sizeof (request.rpr_name)) {
19597c478bd9Sstevel@tonic-gate 		r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
19607c478bd9Sstevel@tonic-gate 		goto err;
19617c478bd9Sstevel@tonic-gate 	}
19627c478bd9Sstevel@tonic-gate 
19637c478bd9Sstevel@tonic-gate 	if (type == NULL || strlcpy(request.rpr_type, type,
19647c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_type)) > sizeof (request.rpr_type)) {
19657c478bd9Sstevel@tonic-gate 		r = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
19667c478bd9Sstevel@tonic-gate 		goto err;
19677c478bd9Sstevel@tonic-gate 	}
19687c478bd9Sstevel@tonic-gate 
19697c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
19707c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
19717c478bd9Sstevel@tonic-gate 	request.rpr_childid = cp->rd_entity;
19727c478bd9Sstevel@tonic-gate 	request.rpr_flags = flags;
19737c478bd9Sstevel@tonic-gate 
19747c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
19757c478bd9Sstevel@tonic-gate 	datael_finish_reset(cp);
19768918dff3Sjwadams 	request.rpr_changeid = handle_next_changeid(h);
19777c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
19787c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
19797c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
19807c478bd9Sstevel@tonic-gate 
19817c478bd9Sstevel@tonic-gate 	if (holding_els)
19827c478bd9Sstevel@tonic-gate 		HANDLE_RELE_PG(h);
19837c478bd9Sstevel@tonic-gate 
19847c478bd9Sstevel@tonic-gate 	if (r < 0)
19857c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
19867c478bd9Sstevel@tonic-gate 
19877c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
19887c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
19897c478bd9Sstevel@tonic-gate 
19907c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
19917c478bd9Sstevel@tonic-gate 
19927c478bd9Sstevel@tonic-gate err:
19937c478bd9Sstevel@tonic-gate 	if (holding_els)
19947c478bd9Sstevel@tonic-gate 		HANDLE_RELE_PG(h);
19957c478bd9Sstevel@tonic-gate 	return (r);
19967c478bd9Sstevel@tonic-gate }
19977c478bd9Sstevel@tonic-gate 
19987c478bd9Sstevel@tonic-gate static int
19997c478bd9Sstevel@tonic-gate datael_delete(const scf_datael_t *dp)
20007c478bd9Sstevel@tonic-gate {
20017c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
20027c478bd9Sstevel@tonic-gate 
20037c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_delete request;
20047c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
20057c478bd9Sstevel@tonic-gate 	ssize_t r;
20067c478bd9Sstevel@tonic-gate 
20077c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
20087c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_DELETE;
20097c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
20107c478bd9Sstevel@tonic-gate 
20117c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
20128918dff3Sjwadams 	request.rpr_changeid = handle_next_changeid(h);
20137c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
20147c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
20157c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
20167c478bd9Sstevel@tonic-gate 
20177c478bd9Sstevel@tonic-gate 	if (r < 0)
20187c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
20197c478bd9Sstevel@tonic-gate 
20207c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
20217c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
20227c478bd9Sstevel@tonic-gate 
20237c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
20247c478bd9Sstevel@tonic-gate }
20257c478bd9Sstevel@tonic-gate 
20267c478bd9Sstevel@tonic-gate /*
20277c478bd9Sstevel@tonic-gate  * Fails with
20287c478bd9Sstevel@tonic-gate  *   _INVALID_ARGUMENT - h is NULL
20297c478bd9Sstevel@tonic-gate  *   _NO_MEMORY
20307c478bd9Sstevel@tonic-gate  *   _HANDLE_DESTROYED - h has been destroyed
20317c478bd9Sstevel@tonic-gate  *   _INTERNAL - server response too big
20327c478bd9Sstevel@tonic-gate  *		 iter already exists
20337c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES
20347c478bd9Sstevel@tonic-gate  */
20357c478bd9Sstevel@tonic-gate scf_iter_t *
20367c478bd9Sstevel@tonic-gate scf_iter_create(scf_handle_t *h)
20377c478bd9Sstevel@tonic-gate {
20387c478bd9Sstevel@tonic-gate 	scf_iter_t *iter;
20397c478bd9Sstevel@tonic-gate 
20407c478bd9Sstevel@tonic-gate 	if (h == NULL) {
20417c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
20427c478bd9Sstevel@tonic-gate 		return (NULL);
20437c478bd9Sstevel@tonic-gate 	}
20447c478bd9Sstevel@tonic-gate 
20457c478bd9Sstevel@tonic-gate 	iter = uu_zalloc(sizeof (*iter));
20467c478bd9Sstevel@tonic-gate 	if (iter == NULL) {
20477c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
20487c478bd9Sstevel@tonic-gate 		return (NULL);
20497c478bd9Sstevel@tonic-gate 	}
20507c478bd9Sstevel@tonic-gate 
20517c478bd9Sstevel@tonic-gate 	uu_list_node_init(iter, &iter->iter_node, iter_pool);
20527c478bd9Sstevel@tonic-gate 	iter->iter_handle = h;
20537c478bd9Sstevel@tonic-gate 	iter->iter_sequence = 1;
20547c478bd9Sstevel@tonic-gate 	iter->iter_type = REP_PROTOCOL_ENTITY_NONE;
20557c478bd9Sstevel@tonic-gate 
20567c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
20577c478bd9Sstevel@tonic-gate 	iter->iter_id = handle_alloc_iterid(h);
20588918dff3Sjwadams 	if (iter->iter_id == 0) {
20598918dff3Sjwadams 		(void) pthread_mutex_unlock(&h->rh_lock);
20608918dff3Sjwadams 		uu_list_node_fini(iter, &iter->iter_node, iter_pool);
20618918dff3Sjwadams 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
2062*1f6eb021SLiane Praza 		uu_free(iter);
20638918dff3Sjwadams 		return (NULL);
20648918dff3Sjwadams 	}
20657c478bd9Sstevel@tonic-gate 	if (iter_attach(iter) == -1) {
20667c478bd9Sstevel@tonic-gate 		uu_list_node_fini(iter, &iter->iter_node, iter_pool);
20677c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
20687c478bd9Sstevel@tonic-gate 		uu_free(iter);
20697c478bd9Sstevel@tonic-gate 		return (NULL);
20707c478bd9Sstevel@tonic-gate 	}
20717c478bd9Sstevel@tonic-gate 	(void) uu_list_insert_before(h->rh_iters, NULL, iter);
20727c478bd9Sstevel@tonic-gate 	h->rh_extrefs++;
20737c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
20747c478bd9Sstevel@tonic-gate 	return (iter);
20757c478bd9Sstevel@tonic-gate }
20767c478bd9Sstevel@tonic-gate 
20777c478bd9Sstevel@tonic-gate scf_handle_t *
20787c478bd9Sstevel@tonic-gate scf_iter_handle(const scf_iter_t *iter)
20797c478bd9Sstevel@tonic-gate {
20807c478bd9Sstevel@tonic-gate 	return (handle_get(iter->iter_handle));
20817c478bd9Sstevel@tonic-gate }
20827c478bd9Sstevel@tonic-gate 
20837c478bd9Sstevel@tonic-gate static void
20847c478bd9Sstevel@tonic-gate scf_iter_reset_locked(scf_iter_t *iter)
20857c478bd9Sstevel@tonic-gate {
20867c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_request request;
20877c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
20887c478bd9Sstevel@tonic-gate 
20897c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_RESET;
20907c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
20917c478bd9Sstevel@tonic-gate 
20927c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&iter->iter_handle->rh_lock));
20937c478bd9Sstevel@tonic-gate 
20947c478bd9Sstevel@tonic-gate 	(void) make_door_call(iter->iter_handle,
20957c478bd9Sstevel@tonic-gate 	    &request, sizeof (request), &response, sizeof (response));
20967c478bd9Sstevel@tonic-gate 
20977c478bd9Sstevel@tonic-gate 	iter->iter_type = REP_PROTOCOL_ENTITY_NONE;
20987c478bd9Sstevel@tonic-gate 	iter->iter_sequence = 1;
20997c478bd9Sstevel@tonic-gate }
21007c478bd9Sstevel@tonic-gate 
21017c478bd9Sstevel@tonic-gate void
21027c478bd9Sstevel@tonic-gate scf_iter_reset(scf_iter_t *iter)
21037c478bd9Sstevel@tonic-gate {
21047c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&iter->iter_handle->rh_lock);
21057c478bd9Sstevel@tonic-gate 	scf_iter_reset_locked(iter);
21067c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&iter->iter_handle->rh_lock);
21077c478bd9Sstevel@tonic-gate }
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate void
21107c478bd9Sstevel@tonic-gate scf_iter_destroy(scf_iter_t *iter)
21117c478bd9Sstevel@tonic-gate {
21127c478bd9Sstevel@tonic-gate 	scf_handle_t *handle;
21137c478bd9Sstevel@tonic-gate 
21147c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_request request;
21157c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
21167c478bd9Sstevel@tonic-gate 
21177c478bd9Sstevel@tonic-gate 	if (iter == NULL)
21187c478bd9Sstevel@tonic-gate 		return;
21197c478bd9Sstevel@tonic-gate 
21207c478bd9Sstevel@tonic-gate 	handle = iter->iter_handle;
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&handle->rh_lock);
21237c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_TEARDOWN;
21247c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
21257c478bd9Sstevel@tonic-gate 
21267c478bd9Sstevel@tonic-gate 	(void) make_door_call(handle, &request, sizeof (request),
21277c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
21287c478bd9Sstevel@tonic-gate 
21297c478bd9Sstevel@tonic-gate 	uu_list_remove(handle->rh_iters, iter);
21307c478bd9Sstevel@tonic-gate 	--handle->rh_extrefs;
21317c478bd9Sstevel@tonic-gate 	handle_unrefed(handle);			/* drops h->rh_lock */
21327c478bd9Sstevel@tonic-gate 	iter->iter_handle = NULL;
21337c478bd9Sstevel@tonic-gate 
21347c478bd9Sstevel@tonic-gate 	uu_list_node_fini(iter, &iter->iter_node, iter_pool);
21357c478bd9Sstevel@tonic-gate 	uu_free(iter);
21367c478bd9Sstevel@tonic-gate }
21377c478bd9Sstevel@tonic-gate 
21387c478bd9Sstevel@tonic-gate static int
21397c478bd9Sstevel@tonic-gate handle_get_local_scope_locked(scf_handle_t *handle, scf_scope_t *out)
21407c478bd9Sstevel@tonic-gate {
21417c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_get request;
21427c478bd9Sstevel@tonic-gate 	struct rep_protocol_name_response response;
21437c478bd9Sstevel@tonic-gate 	ssize_t r;
21447c478bd9Sstevel@tonic-gate 
21457c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&handle->rh_lock));
21467c478bd9Sstevel@tonic-gate 
21477c478bd9Sstevel@tonic-gate 	if (handle != out->rd_d.rd_handle)
21487c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
21497c478bd9Sstevel@tonic-gate 
21507c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_GET;
21517c478bd9Sstevel@tonic-gate 	request.rpr_entityid = out->rd_d.rd_entity;
21527c478bd9Sstevel@tonic-gate 	request.rpr_object = RP_ENTITY_GET_MOST_LOCAL_SCOPE;
21537c478bd9Sstevel@tonic-gate 
21547c478bd9Sstevel@tonic-gate 	datael_finish_reset(&out->rd_d);
21557c478bd9Sstevel@tonic-gate 	r = make_door_call(handle, &request, sizeof (request),
21567c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
21577c478bd9Sstevel@tonic-gate 
21587c478bd9Sstevel@tonic-gate 	if (r < 0)
21597c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
21607c478bd9Sstevel@tonic-gate 
21617c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
21627c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
21637c478bd9Sstevel@tonic-gate 
21647c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
21657c478bd9Sstevel@tonic-gate }
21667c478bd9Sstevel@tonic-gate 
21677c478bd9Sstevel@tonic-gate int
21687c478bd9Sstevel@tonic-gate scf_iter_handle_scopes(scf_iter_t *iter, const scf_handle_t *handle)
21697c478bd9Sstevel@tonic-gate {
21707c478bd9Sstevel@tonic-gate 	scf_handle_t *h = iter->iter_handle;
21717c478bd9Sstevel@tonic-gate 	if (h != handle)
21727c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
21737c478bd9Sstevel@tonic-gate 
21747c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
21757c478bd9Sstevel@tonic-gate 	scf_iter_reset_locked(iter);
21767c478bd9Sstevel@tonic-gate 
21777c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(h)) {
21787c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
21797c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_BOUND));
21807c478bd9Sstevel@tonic-gate 	}
21817c478bd9Sstevel@tonic-gate 
21828918dff3Sjwadams 	if (!handle_has_server_locked(h)) {
21837c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
21847c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
21857c478bd9Sstevel@tonic-gate 	}
21867c478bd9Sstevel@tonic-gate 
21877c478bd9Sstevel@tonic-gate 	iter->iter_type = REP_PROTOCOL_ENTITY_SCOPE;
21887c478bd9Sstevel@tonic-gate 	iter->iter_sequence = 1;
21897c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
21907c478bd9Sstevel@tonic-gate 	return (0);
21917c478bd9Sstevel@tonic-gate }
21927c478bd9Sstevel@tonic-gate 
21937c478bd9Sstevel@tonic-gate int
21947c478bd9Sstevel@tonic-gate scf_iter_next_scope(scf_iter_t *iter, scf_scope_t *out)
21957c478bd9Sstevel@tonic-gate {
21967c478bd9Sstevel@tonic-gate 	int ret;
21977c478bd9Sstevel@tonic-gate 	scf_handle_t *h = iter->iter_handle;
21987c478bd9Sstevel@tonic-gate 
21997c478bd9Sstevel@tonic-gate 	if (h != out->rd_d.rd_handle)
22007c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
22017c478bd9Sstevel@tonic-gate 
22027c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
22037c478bd9Sstevel@tonic-gate 	if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE) {
22047c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
22057c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
22067c478bd9Sstevel@tonic-gate 	}
22077c478bd9Sstevel@tonic-gate 	if (iter->iter_type != REP_PROTOCOL_ENTITY_SCOPE) {
22087c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
22097c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
22107c478bd9Sstevel@tonic-gate 	}
22117c478bd9Sstevel@tonic-gate 	if (iter->iter_sequence == 1) {
22127c478bd9Sstevel@tonic-gate 		if ((ret = handle_get_local_scope_locked(h, out)) ==
22137c478bd9Sstevel@tonic-gate 		    SCF_SUCCESS) {
22147c478bd9Sstevel@tonic-gate 			iter->iter_sequence++;
22157c478bd9Sstevel@tonic-gate 			ret = 1;
22167c478bd9Sstevel@tonic-gate 		}
22177c478bd9Sstevel@tonic-gate 	} else {
22187c478bd9Sstevel@tonic-gate 		datael_reset_locked(&out->rd_d);
22197c478bd9Sstevel@tonic-gate 		ret = 0;
22207c478bd9Sstevel@tonic-gate 	}
22217c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
22227c478bd9Sstevel@tonic-gate 	return (ret);
22237c478bd9Sstevel@tonic-gate }
22247c478bd9Sstevel@tonic-gate 
22257c478bd9Sstevel@tonic-gate int
22267c478bd9Sstevel@tonic-gate scf_handle_get_scope(scf_handle_t *h, const char *name, scf_scope_t *out)
22277c478bd9Sstevel@tonic-gate {
22287c478bd9Sstevel@tonic-gate 	int ret;
22297c478bd9Sstevel@tonic-gate 
22307c478bd9Sstevel@tonic-gate 	if (h != out->rd_d.rd_handle)
22317c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
22327c478bd9Sstevel@tonic-gate 
22337c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
22347c478bd9Sstevel@tonic-gate 	if (strcmp(name, SCF_SCOPE_LOCAL) == 0) {
22357c478bd9Sstevel@tonic-gate 		ret = handle_get_local_scope_locked(h, out);
22367c478bd9Sstevel@tonic-gate 	} else {
22377c478bd9Sstevel@tonic-gate 		datael_reset_locked(&out->rd_d);
22387c478bd9Sstevel@tonic-gate 		if (uu_check_name(name, 0) == -1)
22397c478bd9Sstevel@tonic-gate 			ret = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
22407c478bd9Sstevel@tonic-gate 		else
22417c478bd9Sstevel@tonic-gate 			ret = scf_set_error(SCF_ERROR_NOT_FOUND);
22427c478bd9Sstevel@tonic-gate 	}
22437c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
22447c478bd9Sstevel@tonic-gate 	return (ret);
22457c478bd9Sstevel@tonic-gate }
22467c478bd9Sstevel@tonic-gate 
22477c478bd9Sstevel@tonic-gate static int
22487c478bd9Sstevel@tonic-gate datael_setup_iter(scf_iter_t *iter, const scf_datael_t *dp, uint32_t res_type,
22497c478bd9Sstevel@tonic-gate     boolean_t composed)
22507c478bd9Sstevel@tonic-gate {
22517c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
22527c478bd9Sstevel@tonic-gate 
22537c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_start request;
22547c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
22557c478bd9Sstevel@tonic-gate 
22567c478bd9Sstevel@tonic-gate 	ssize_t r;
22577c478bd9Sstevel@tonic-gate 
22587c478bd9Sstevel@tonic-gate 	if (h != iter->iter_handle)
22597c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
22607c478bd9Sstevel@tonic-gate 
22617c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
22627c478bd9Sstevel@tonic-gate 	scf_iter_reset_locked(iter);
22637c478bd9Sstevel@tonic-gate 	iter->iter_type = res_type;
22647c478bd9Sstevel@tonic-gate 
22657c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_START;
22667c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
22677c478bd9Sstevel@tonic-gate 	request.rpr_entity = dp->rd_entity;
22687c478bd9Sstevel@tonic-gate 	request.rpr_itertype = res_type;
22697c478bd9Sstevel@tonic-gate 	request.rpr_flags = RP_ITER_START_ALL |
22707c478bd9Sstevel@tonic-gate 	    (composed ? RP_ITER_START_COMPOSED : 0);
22717c478bd9Sstevel@tonic-gate 	request.rpr_pattern[0] = 0;
22727c478bd9Sstevel@tonic-gate 
22737c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
22747c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
22757c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
22767c478bd9Sstevel@tonic-gate 
22777c478bd9Sstevel@tonic-gate 	if (r < 0) {
22787c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
22797c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
22807c478bd9Sstevel@tonic-gate 	}
22817c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
22827c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
22837c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
22847c478bd9Sstevel@tonic-gate 	}
22857c478bd9Sstevel@tonic-gate 	iter->iter_sequence++;
22867c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
22877c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
22887c478bd9Sstevel@tonic-gate }
22897c478bd9Sstevel@tonic-gate 
22907c478bd9Sstevel@tonic-gate static int
22917c478bd9Sstevel@tonic-gate datael_setup_iter_pgtyped(scf_iter_t *iter, const scf_datael_t *dp,
22927c478bd9Sstevel@tonic-gate     const char *pgtype, boolean_t composed)
22937c478bd9Sstevel@tonic-gate {
22947c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
22957c478bd9Sstevel@tonic-gate 
22967c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_start request;
22977c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
22987c478bd9Sstevel@tonic-gate 
22997c478bd9Sstevel@tonic-gate 	ssize_t r;
23007c478bd9Sstevel@tonic-gate 
23017c478bd9Sstevel@tonic-gate 	if (h != iter->iter_handle)
23027c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
23037c478bd9Sstevel@tonic-gate 
23047c478bd9Sstevel@tonic-gate 	if (pgtype == NULL || strlcpy(request.rpr_pattern, pgtype,
23057c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_pattern)) >= sizeof (request.rpr_pattern)) {
23067c478bd9Sstevel@tonic-gate 		scf_iter_reset(iter);
23077c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
23087c478bd9Sstevel@tonic-gate 	}
23097c478bd9Sstevel@tonic-gate 
23107c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
23117c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_START;
23127c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
23137c478bd9Sstevel@tonic-gate 	request.rpr_entity = dp->rd_entity;
23147c478bd9Sstevel@tonic-gate 	request.rpr_itertype = REP_PROTOCOL_ENTITY_PROPERTYGRP;
23157c478bd9Sstevel@tonic-gate 	request.rpr_flags = RP_ITER_START_PGTYPE |
23167c478bd9Sstevel@tonic-gate 	    (composed ? RP_ITER_START_COMPOSED : 0);
23177c478bd9Sstevel@tonic-gate 
23187c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
23197c478bd9Sstevel@tonic-gate 	scf_iter_reset_locked(iter);
23207c478bd9Sstevel@tonic-gate 	iter->iter_type = REP_PROTOCOL_ENTITY_PROPERTYGRP;
23217c478bd9Sstevel@tonic-gate 
23227c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
23237c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
23247c478bd9Sstevel@tonic-gate 
23257c478bd9Sstevel@tonic-gate 	if (r < 0) {
23267c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23277c478bd9Sstevel@tonic-gate 
23287c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
23297c478bd9Sstevel@tonic-gate 	}
23307c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
23317c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23327c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
23337c478bd9Sstevel@tonic-gate 	}
23347c478bd9Sstevel@tonic-gate 	iter->iter_sequence++;
23357c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
23367c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
23377c478bd9Sstevel@tonic-gate }
23387c478bd9Sstevel@tonic-gate 
23397c478bd9Sstevel@tonic-gate static int
23407c478bd9Sstevel@tonic-gate datael_iter_next(scf_iter_t *iter, scf_datael_t *out)
23417c478bd9Sstevel@tonic-gate {
23427c478bd9Sstevel@tonic-gate 	scf_handle_t *h = iter->iter_handle;
23437c478bd9Sstevel@tonic-gate 
23447c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_read request;
23457c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
23467c478bd9Sstevel@tonic-gate 	ssize_t r;
23477c478bd9Sstevel@tonic-gate 
23487c478bd9Sstevel@tonic-gate 	if (h != out->rd_handle)
23497c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
23507c478bd9Sstevel@tonic-gate 
23517c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
23527c478bd9Sstevel@tonic-gate 	if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE ||
23537c478bd9Sstevel@tonic-gate 	    iter->iter_sequence == 1) {
23547c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23557c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
23567c478bd9Sstevel@tonic-gate 	}
23577c478bd9Sstevel@tonic-gate 
23587c478bd9Sstevel@tonic-gate 	if (out->rd_type != iter->iter_type) {
23597c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23607c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
23617c478bd9Sstevel@tonic-gate 	}
23627c478bd9Sstevel@tonic-gate 
23637c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_READ;
23647c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
23657c478bd9Sstevel@tonic-gate 	request.rpr_sequence = iter->iter_sequence;
23667c478bd9Sstevel@tonic-gate 	request.rpr_entityid = out->rd_entity;
23677c478bd9Sstevel@tonic-gate 
23687c478bd9Sstevel@tonic-gate 	datael_finish_reset(out);
23697c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
23707c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
23717c478bd9Sstevel@tonic-gate 
23727c478bd9Sstevel@tonic-gate 	if (r < 0) {
23737c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23747c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
23757c478bd9Sstevel@tonic-gate 	}
23767c478bd9Sstevel@tonic-gate 
23777c478bd9Sstevel@tonic-gate 	if (response.rpr_response == REP_PROTOCOL_DONE) {
23787c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23797c478bd9Sstevel@tonic-gate 		return (0);
23807c478bd9Sstevel@tonic-gate 	}
23817c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
23827c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
23837c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
23847c478bd9Sstevel@tonic-gate 	}
23857c478bd9Sstevel@tonic-gate 	iter->iter_sequence++;
23867c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
23877c478bd9Sstevel@tonic-gate 
23887c478bd9Sstevel@tonic-gate 	return (1);
23897c478bd9Sstevel@tonic-gate }
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate int
23927c478bd9Sstevel@tonic-gate scf_iter_scope_services(scf_iter_t *iter, const scf_scope_t *s)
23937c478bd9Sstevel@tonic-gate {
23947c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &s->rd_d,
23957c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_SERVICE, 0));
23967c478bd9Sstevel@tonic-gate }
23977c478bd9Sstevel@tonic-gate 
23987c478bd9Sstevel@tonic-gate int
23997c478bd9Sstevel@tonic-gate scf_iter_next_service(scf_iter_t *iter, scf_service_t *out)
24007c478bd9Sstevel@tonic-gate {
24017c478bd9Sstevel@tonic-gate 	return (datael_iter_next(iter, &out->rd_d));
24027c478bd9Sstevel@tonic-gate }
24037c478bd9Sstevel@tonic-gate 
24047c478bd9Sstevel@tonic-gate int
24057c478bd9Sstevel@tonic-gate scf_iter_service_instances(scf_iter_t *iter, const scf_service_t *svc)
24067c478bd9Sstevel@tonic-gate {
24077c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &svc->rd_d,
24087c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_INSTANCE, 0));
24097c478bd9Sstevel@tonic-gate }
24107c478bd9Sstevel@tonic-gate 
24117c478bd9Sstevel@tonic-gate int
24127c478bd9Sstevel@tonic-gate scf_iter_next_instance(scf_iter_t *iter, scf_instance_t *out)
24137c478bd9Sstevel@tonic-gate {
24147c478bd9Sstevel@tonic-gate 	return (datael_iter_next(iter, &out->rd_d));
24157c478bd9Sstevel@tonic-gate }
24167c478bd9Sstevel@tonic-gate 
24177c478bd9Sstevel@tonic-gate int
24187c478bd9Sstevel@tonic-gate scf_iter_service_pgs(scf_iter_t *iter, const scf_service_t *svc)
24197c478bd9Sstevel@tonic-gate {
24207c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &svc->rd_d,
24217c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 0));
24227c478bd9Sstevel@tonic-gate }
24237c478bd9Sstevel@tonic-gate 
24247c478bd9Sstevel@tonic-gate int
24257c478bd9Sstevel@tonic-gate scf_iter_service_pgs_typed(scf_iter_t *iter, const scf_service_t *svc,
24267c478bd9Sstevel@tonic-gate     const char *type)
24277c478bd9Sstevel@tonic-gate {
24287c478bd9Sstevel@tonic-gate 	return (datael_setup_iter_pgtyped(iter, &svc->rd_d, type, 0));
24297c478bd9Sstevel@tonic-gate }
24307c478bd9Sstevel@tonic-gate 
24317c478bd9Sstevel@tonic-gate int
24327c478bd9Sstevel@tonic-gate scf_iter_instance_snapshots(scf_iter_t *iter, const scf_instance_t *inst)
24337c478bd9Sstevel@tonic-gate {
24347c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &inst->rd_d,
24357c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_SNAPSHOT, 0));
24367c478bd9Sstevel@tonic-gate }
24377c478bd9Sstevel@tonic-gate 
24387c478bd9Sstevel@tonic-gate int
24397c478bd9Sstevel@tonic-gate scf_iter_next_snapshot(scf_iter_t *iter, scf_snapshot_t *out)
24407c478bd9Sstevel@tonic-gate {
24417c478bd9Sstevel@tonic-gate 	return (datael_iter_next(iter, &out->rd_d));
24427c478bd9Sstevel@tonic-gate }
24437c478bd9Sstevel@tonic-gate 
24447c478bd9Sstevel@tonic-gate int
24457c478bd9Sstevel@tonic-gate scf_iter_instance_pgs(scf_iter_t *iter, const scf_instance_t *inst)
24467c478bd9Sstevel@tonic-gate {
24477c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &inst->rd_d,
24487c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 0));
24497c478bd9Sstevel@tonic-gate }
24507c478bd9Sstevel@tonic-gate 
24517c478bd9Sstevel@tonic-gate int
24527c478bd9Sstevel@tonic-gate scf_iter_instance_pgs_typed(scf_iter_t *iter, const scf_instance_t *inst,
24537c478bd9Sstevel@tonic-gate     const char *type)
24547c478bd9Sstevel@tonic-gate {
24557c478bd9Sstevel@tonic-gate 	return (datael_setup_iter_pgtyped(iter, &inst->rd_d, type, 0));
24567c478bd9Sstevel@tonic-gate }
24577c478bd9Sstevel@tonic-gate 
24587c478bd9Sstevel@tonic-gate int
24597c478bd9Sstevel@tonic-gate scf_iter_instance_pgs_composed(scf_iter_t *iter, const scf_instance_t *inst,
24607c478bd9Sstevel@tonic-gate     const scf_snapshot_t *snap)
24617c478bd9Sstevel@tonic-gate {
24627c478bd9Sstevel@tonic-gate 	if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle)
24637c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
24647c478bd9Sstevel@tonic-gate 
24657c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, snap ? &snap->rd_d : &inst->rd_d,
24667c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 1));
24677c478bd9Sstevel@tonic-gate }
24687c478bd9Sstevel@tonic-gate 
24697c478bd9Sstevel@tonic-gate int
24707c478bd9Sstevel@tonic-gate scf_iter_instance_pgs_typed_composed(scf_iter_t *iter,
24717c478bd9Sstevel@tonic-gate     const scf_instance_t *inst, const scf_snapshot_t *snap, const char *type)
24727c478bd9Sstevel@tonic-gate {
24737c478bd9Sstevel@tonic-gate 	if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle)
24747c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
24757c478bd9Sstevel@tonic-gate 
24767c478bd9Sstevel@tonic-gate 	return (datael_setup_iter_pgtyped(iter,
24777c478bd9Sstevel@tonic-gate 	    snap ? &snap->rd_d : &inst->rd_d, type, 1));
24787c478bd9Sstevel@tonic-gate }
24797c478bd9Sstevel@tonic-gate 
24807c478bd9Sstevel@tonic-gate int
24817c478bd9Sstevel@tonic-gate scf_iter_snaplevel_pgs(scf_iter_t *iter, const scf_snaplevel_t *inst)
24827c478bd9Sstevel@tonic-gate {
24837c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &inst->rd_d,
24847c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, 0));
24857c478bd9Sstevel@tonic-gate }
24867c478bd9Sstevel@tonic-gate 
24877c478bd9Sstevel@tonic-gate int
24887c478bd9Sstevel@tonic-gate scf_iter_snaplevel_pgs_typed(scf_iter_t *iter, const scf_snaplevel_t *inst,
24897c478bd9Sstevel@tonic-gate     const char *type)
24907c478bd9Sstevel@tonic-gate {
24917c478bd9Sstevel@tonic-gate 	return (datael_setup_iter_pgtyped(iter, &inst->rd_d, type, 0));
24927c478bd9Sstevel@tonic-gate }
24937c478bd9Sstevel@tonic-gate 
24947c478bd9Sstevel@tonic-gate int
24957c478bd9Sstevel@tonic-gate scf_iter_next_pg(scf_iter_t *iter, scf_propertygroup_t *out)
24967c478bd9Sstevel@tonic-gate {
24977c478bd9Sstevel@tonic-gate 	return (datael_iter_next(iter, &out->rd_d));
24987c478bd9Sstevel@tonic-gate }
24997c478bd9Sstevel@tonic-gate 
25007c478bd9Sstevel@tonic-gate int
25017c478bd9Sstevel@tonic-gate scf_iter_pg_properties(scf_iter_t *iter, const scf_propertygroup_t *pg)
25027c478bd9Sstevel@tonic-gate {
25037c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &pg->rd_d,
25047c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTY, 0));
25057c478bd9Sstevel@tonic-gate }
25067c478bd9Sstevel@tonic-gate 
25077c478bd9Sstevel@tonic-gate int
25087c478bd9Sstevel@tonic-gate scf_iter_next_property(scf_iter_t *iter, scf_property_t *out)
25097c478bd9Sstevel@tonic-gate {
25107c478bd9Sstevel@tonic-gate 	return (datael_iter_next(iter, &out->rd_d));
25117c478bd9Sstevel@tonic-gate }
25127c478bd9Sstevel@tonic-gate 
25137c478bd9Sstevel@tonic-gate /*
25147c478bd9Sstevel@tonic-gate  * Fails with
25157c478bd9Sstevel@tonic-gate  *   _INVALID_ARGUMENT - handle is NULL
25167c478bd9Sstevel@tonic-gate  *   _INTERNAL - server response too big
25177c478bd9Sstevel@tonic-gate  *		 entity already set up with different type
25187c478bd9Sstevel@tonic-gate  *   _NO_RESOURCES
25197c478bd9Sstevel@tonic-gate  *   _NO_MEMORY
25207c478bd9Sstevel@tonic-gate  */
25217c478bd9Sstevel@tonic-gate scf_scope_t *
25227c478bd9Sstevel@tonic-gate scf_scope_create(scf_handle_t *handle)
25237c478bd9Sstevel@tonic-gate {
25247c478bd9Sstevel@tonic-gate 	scf_scope_t *ret;
25257c478bd9Sstevel@tonic-gate 
25267c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
25277c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
25287c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
25297c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_SCOPE) == -1) {
25307c478bd9Sstevel@tonic-gate 			uu_free(ret);
25317c478bd9Sstevel@tonic-gate 			return (NULL);
25327c478bd9Sstevel@tonic-gate 		}
25337c478bd9Sstevel@tonic-gate 	} else {
25347c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
25357c478bd9Sstevel@tonic-gate 	}
25367c478bd9Sstevel@tonic-gate 
25377c478bd9Sstevel@tonic-gate 	return (ret);
25387c478bd9Sstevel@tonic-gate }
25397c478bd9Sstevel@tonic-gate 
25407c478bd9Sstevel@tonic-gate scf_handle_t *
25417c478bd9Sstevel@tonic-gate scf_scope_handle(const scf_scope_t *val)
25427c478bd9Sstevel@tonic-gate {
25437c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
25447c478bd9Sstevel@tonic-gate }
25457c478bd9Sstevel@tonic-gate 
25467c478bd9Sstevel@tonic-gate void
25477c478bd9Sstevel@tonic-gate scf_scope_destroy(scf_scope_t *val)
25487c478bd9Sstevel@tonic-gate {
25497c478bd9Sstevel@tonic-gate 	if (val == NULL)
25507c478bd9Sstevel@tonic-gate 		return;
25517c478bd9Sstevel@tonic-gate 
25527c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
25537c478bd9Sstevel@tonic-gate 	uu_free(val);
25547c478bd9Sstevel@tonic-gate }
25557c478bd9Sstevel@tonic-gate 
25567c478bd9Sstevel@tonic-gate ssize_t
25577c478bd9Sstevel@tonic-gate scf_scope_get_name(const scf_scope_t *rep, char *out, size_t len)
25587c478bd9Sstevel@tonic-gate {
25597c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
25607c478bd9Sstevel@tonic-gate }
25617c478bd9Sstevel@tonic-gate 
25627c478bd9Sstevel@tonic-gate /*ARGSUSED*/
25637c478bd9Sstevel@tonic-gate int
25647c478bd9Sstevel@tonic-gate scf_scope_get_parent(const scf_scope_t *child, scf_scope_t *parent)
25657c478bd9Sstevel@tonic-gate {
25667c478bd9Sstevel@tonic-gate 	char name[1];
25677c478bd9Sstevel@tonic-gate 
25687c478bd9Sstevel@tonic-gate 	/* fake up the side-effects */
25697c478bd9Sstevel@tonic-gate 	datael_reset(&parent->rd_d);
25707c478bd9Sstevel@tonic-gate 	if (scf_scope_get_name(child, name, sizeof (name)) < 0)
25717c478bd9Sstevel@tonic-gate 		return (-1);
25727c478bd9Sstevel@tonic-gate 	return (scf_set_error(SCF_ERROR_NOT_FOUND));
25737c478bd9Sstevel@tonic-gate }
25747c478bd9Sstevel@tonic-gate 
25757c478bd9Sstevel@tonic-gate /*
25767c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
25777c478bd9Sstevel@tonic-gate  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
25787c478bd9Sstevel@tonic-gate  */
25797c478bd9Sstevel@tonic-gate scf_service_t *
25807c478bd9Sstevel@tonic-gate scf_service_create(scf_handle_t *handle)
25817c478bd9Sstevel@tonic-gate {
25827c478bd9Sstevel@tonic-gate 	scf_service_t *ret;
25837c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
25847c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
25857c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
25867c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_SERVICE) == -1) {
25877c478bd9Sstevel@tonic-gate 			uu_free(ret);
25887c478bd9Sstevel@tonic-gate 			return (NULL);
25897c478bd9Sstevel@tonic-gate 		}
25907c478bd9Sstevel@tonic-gate 	} else {
25917c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
25927c478bd9Sstevel@tonic-gate 	}
25937c478bd9Sstevel@tonic-gate 
25947c478bd9Sstevel@tonic-gate 	return (ret);
25957c478bd9Sstevel@tonic-gate }
25967c478bd9Sstevel@tonic-gate 
259776cf44abSjeanm 
259876cf44abSjeanm /*
259976cf44abSjeanm  * Fails with
260076cf44abSjeanm  *   _HANDLE_MISMATCH
260176cf44abSjeanm  *   _INVALID_ARGUMENT
260276cf44abSjeanm  *   _NOT_BOUND
260376cf44abSjeanm  *   _CONNECTION_BROKEN
260476cf44abSjeanm  *   _INTERNAL
260576cf44abSjeanm  *   _EXISTS
260676cf44abSjeanm  *   _DELETED
260776cf44abSjeanm  *   _NOT_SET
260876cf44abSjeanm  *   _NO_RESOURCES
260976cf44abSjeanm  *   _PERMISSION_DENIED
261076cf44abSjeanm  *   _BACKEND_ACCESS
261176cf44abSjeanm  *   _BACKEND_READONLY
261276cf44abSjeanm  */
26137c478bd9Sstevel@tonic-gate int
26147c478bd9Sstevel@tonic-gate scf_scope_add_service(const scf_scope_t *scope, const char *name,
26157c478bd9Sstevel@tonic-gate     scf_service_t *svc)
26167c478bd9Sstevel@tonic-gate {
26177c478bd9Sstevel@tonic-gate 	return (datael_add_child(&scope->rd_d, name,
26187c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_SERVICE, (svc != NULL)? &svc->rd_d : NULL));
26197c478bd9Sstevel@tonic-gate }
26207c478bd9Sstevel@tonic-gate 
262176cf44abSjeanm /*
262276cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
262376cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
262476cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
262576cf44abSjeanm  */
26267c478bd9Sstevel@tonic-gate int
26277c478bd9Sstevel@tonic-gate scf_scope_get_service(const scf_scope_t *s, const char *name,
26287c478bd9Sstevel@tonic-gate     scf_service_t *svc)
26297c478bd9Sstevel@tonic-gate {
26307c478bd9Sstevel@tonic-gate 	return (datael_get_child(&s->rd_d, name, REP_PROTOCOL_ENTITY_SERVICE,
26317c478bd9Sstevel@tonic-gate 	    svc ? &svc->rd_d : NULL, 0));
26327c478bd9Sstevel@tonic-gate }
26337c478bd9Sstevel@tonic-gate 
26347c478bd9Sstevel@tonic-gate scf_handle_t *
26357c478bd9Sstevel@tonic-gate scf_service_handle(const scf_service_t *val)
26367c478bd9Sstevel@tonic-gate {
26377c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
26387c478bd9Sstevel@tonic-gate }
26397c478bd9Sstevel@tonic-gate 
26407c478bd9Sstevel@tonic-gate int
26417c478bd9Sstevel@tonic-gate scf_service_delete(scf_service_t *svc)
26427c478bd9Sstevel@tonic-gate {
26437c478bd9Sstevel@tonic-gate 	return (datael_delete(&svc->rd_d));
26447c478bd9Sstevel@tonic-gate }
26457c478bd9Sstevel@tonic-gate 
26467c478bd9Sstevel@tonic-gate int
26477c478bd9Sstevel@tonic-gate scf_instance_delete(scf_instance_t *inst)
26487c478bd9Sstevel@tonic-gate {
26497c478bd9Sstevel@tonic-gate 	return (datael_delete(&inst->rd_d));
26507c478bd9Sstevel@tonic-gate }
26517c478bd9Sstevel@tonic-gate 
26527c478bd9Sstevel@tonic-gate int
26537c478bd9Sstevel@tonic-gate scf_pg_delete(scf_propertygroup_t *pg)
26547c478bd9Sstevel@tonic-gate {
26557c478bd9Sstevel@tonic-gate 	return (datael_delete(&pg->rd_d));
26567c478bd9Sstevel@tonic-gate }
26577c478bd9Sstevel@tonic-gate 
26587c478bd9Sstevel@tonic-gate int
26597c478bd9Sstevel@tonic-gate _scf_snapshot_delete(scf_snapshot_t *snap)
26607c478bd9Sstevel@tonic-gate {
26617c478bd9Sstevel@tonic-gate 	return (datael_delete(&snap->rd_d));
26627c478bd9Sstevel@tonic-gate }
26637c478bd9Sstevel@tonic-gate 
266476cf44abSjeanm /*
266576cf44abSjeanm  * Fails with
266676cf44abSjeanm  *   _HANDLE_MISMATCH
266776cf44abSjeanm  *   _INVALID_ARGUMENT
266876cf44abSjeanm  *   _NOT_BOUND
266976cf44abSjeanm  *   _CONNECTION_BROKEN
267076cf44abSjeanm  *   _INTERNAL
267176cf44abSjeanm  *   _EXISTS
267276cf44abSjeanm  *   _DELETED
267376cf44abSjeanm  *   _NOT_SET
267476cf44abSjeanm  *   _NO_RESOURCES
267576cf44abSjeanm  *   _PERMISSION_DENIED
267676cf44abSjeanm  *   _BACKEND_ACCESS
267776cf44abSjeanm  *   _BACKEND_READONLY
267876cf44abSjeanm  */
26797c478bd9Sstevel@tonic-gate int
26807c478bd9Sstevel@tonic-gate scf_service_add_instance(const scf_service_t *svc, const char *name,
26817c478bd9Sstevel@tonic-gate     scf_instance_t *instance)
26827c478bd9Sstevel@tonic-gate {
26837c478bd9Sstevel@tonic-gate 	return (datael_add_child(&svc->rd_d, name,
26847c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_INSTANCE,
26857c478bd9Sstevel@tonic-gate 	    (instance != NULL)? &instance->rd_d : NULL));
26867c478bd9Sstevel@tonic-gate }
26877c478bd9Sstevel@tonic-gate 
268876cf44abSjeanm 
268976cf44abSjeanm /*
269076cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
269176cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
269276cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
269376cf44abSjeanm  */
26947c478bd9Sstevel@tonic-gate int
26957c478bd9Sstevel@tonic-gate scf_service_get_instance(const scf_service_t *svc, const char *name,
26967c478bd9Sstevel@tonic-gate     scf_instance_t *inst)
26977c478bd9Sstevel@tonic-gate {
26987c478bd9Sstevel@tonic-gate 	return (datael_get_child(&svc->rd_d, name, REP_PROTOCOL_ENTITY_INSTANCE,
26997c478bd9Sstevel@tonic-gate 	    inst ? &inst->rd_d : NULL, 0));
27007c478bd9Sstevel@tonic-gate }
27017c478bd9Sstevel@tonic-gate 
27027c478bd9Sstevel@tonic-gate int
27037c478bd9Sstevel@tonic-gate scf_service_add_pg(const scf_service_t *svc, const char *name,
27047c478bd9Sstevel@tonic-gate     const char *type, uint32_t flags, scf_propertygroup_t *pg)
27057c478bd9Sstevel@tonic-gate {
27067c478bd9Sstevel@tonic-gate 	return (datael_add_pg(&svc->rd_d, name, type, flags,
27077c478bd9Sstevel@tonic-gate 	    (pg != NULL)?&pg->rd_d : NULL));
27087c478bd9Sstevel@tonic-gate }
27097c478bd9Sstevel@tonic-gate 
271076cf44abSjeanm /*
271176cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
271276cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
271376cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
271476cf44abSjeanm  */
27157c478bd9Sstevel@tonic-gate int
27167c478bd9Sstevel@tonic-gate scf_service_get_pg(const scf_service_t *svc, const char *name,
27177c478bd9Sstevel@tonic-gate     scf_propertygroup_t *pg)
27187c478bd9Sstevel@tonic-gate {
27197c478bd9Sstevel@tonic-gate 	return (datael_get_child(&svc->rd_d, name,
27207c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0));
27217c478bd9Sstevel@tonic-gate }
27227c478bd9Sstevel@tonic-gate 
27237c478bd9Sstevel@tonic-gate int
27247c478bd9Sstevel@tonic-gate scf_instance_add_pg(const scf_instance_t *inst, const char *name,
27257c478bd9Sstevel@tonic-gate     const char *type, uint32_t flags, scf_propertygroup_t *pg)
27267c478bd9Sstevel@tonic-gate {
27277c478bd9Sstevel@tonic-gate 	return (datael_add_pg(&inst->rd_d, name, type, flags,
27287c478bd9Sstevel@tonic-gate 	    (pg != NULL)?&pg->rd_d : NULL));
27297c478bd9Sstevel@tonic-gate }
27307c478bd9Sstevel@tonic-gate 
273176cf44abSjeanm /*
273276cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
273376cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
273476cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
273576cf44abSjeanm  */
27367c478bd9Sstevel@tonic-gate int
27377c478bd9Sstevel@tonic-gate scf_instance_get_snapshot(const scf_instance_t *inst, const char *name,
27387c478bd9Sstevel@tonic-gate     scf_snapshot_t *pg)
27397c478bd9Sstevel@tonic-gate {
27407c478bd9Sstevel@tonic-gate 	return (datael_get_child(&inst->rd_d, name,
27417c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_SNAPSHOT, pg ? &pg->rd_d : NULL, 0));
27427c478bd9Sstevel@tonic-gate }
27437c478bd9Sstevel@tonic-gate 
274476cf44abSjeanm /*
274576cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
274676cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
274776cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
274876cf44abSjeanm  */
27497c478bd9Sstevel@tonic-gate int
27507c478bd9Sstevel@tonic-gate scf_instance_get_pg(const scf_instance_t *inst, const char *name,
27517c478bd9Sstevel@tonic-gate     scf_propertygroup_t *pg)
27527c478bd9Sstevel@tonic-gate {
27537c478bd9Sstevel@tonic-gate 	return (datael_get_child(&inst->rd_d, name,
27547c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0));
27557c478bd9Sstevel@tonic-gate }
27567c478bd9Sstevel@tonic-gate 
275776cf44abSjeanm /*
275876cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
275976cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
276076cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
276176cf44abSjeanm  */
27627c478bd9Sstevel@tonic-gate int
27637c478bd9Sstevel@tonic-gate scf_instance_get_pg_composed(const scf_instance_t *inst,
27647c478bd9Sstevel@tonic-gate     const scf_snapshot_t *snap, const char *name, scf_propertygroup_t *pg)
27657c478bd9Sstevel@tonic-gate {
27667c478bd9Sstevel@tonic-gate 	if (snap != NULL && inst->rd_d.rd_handle != snap->rd_d.rd_handle)
27677c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
27687c478bd9Sstevel@tonic-gate 
27697c478bd9Sstevel@tonic-gate 	return (datael_get_child(snap ? &snap->rd_d : &inst->rd_d, name,
27707c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 1));
27717c478bd9Sstevel@tonic-gate }
27727c478bd9Sstevel@tonic-gate 
277376cf44abSjeanm /*
277476cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
277576cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
277676cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
277776cf44abSjeanm  */
27787c478bd9Sstevel@tonic-gate int
27797c478bd9Sstevel@tonic-gate scf_pg_get_property(const scf_propertygroup_t *pg, const char *name,
27807c478bd9Sstevel@tonic-gate     scf_property_t *prop)
27817c478bd9Sstevel@tonic-gate {
27827c478bd9Sstevel@tonic-gate 	return (datael_get_child(&pg->rd_d, name, REP_PROTOCOL_ENTITY_PROPERTY,
27837c478bd9Sstevel@tonic-gate 	    prop ? &prop->rd_d : NULL, 0));
27847c478bd9Sstevel@tonic-gate }
27857c478bd9Sstevel@tonic-gate 
27867c478bd9Sstevel@tonic-gate void
27877c478bd9Sstevel@tonic-gate scf_service_destroy(scf_service_t *val)
27887c478bd9Sstevel@tonic-gate {
27897c478bd9Sstevel@tonic-gate 	if (val == NULL)
27907c478bd9Sstevel@tonic-gate 		return;
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
27937c478bd9Sstevel@tonic-gate 	uu_free(val);
27947c478bd9Sstevel@tonic-gate }
27957c478bd9Sstevel@tonic-gate 
27967c478bd9Sstevel@tonic-gate ssize_t
27977c478bd9Sstevel@tonic-gate scf_service_get_name(const scf_service_t *rep, char *out, size_t len)
27987c478bd9Sstevel@tonic-gate {
27997c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
28007c478bd9Sstevel@tonic-gate }
28017c478bd9Sstevel@tonic-gate 
28027c478bd9Sstevel@tonic-gate /*
28037c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
28047c478bd9Sstevel@tonic-gate  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
28057c478bd9Sstevel@tonic-gate  */
28067c478bd9Sstevel@tonic-gate scf_instance_t *
28077c478bd9Sstevel@tonic-gate scf_instance_create(scf_handle_t *handle)
28087c478bd9Sstevel@tonic-gate {
28097c478bd9Sstevel@tonic-gate 	scf_instance_t *ret;
28107c478bd9Sstevel@tonic-gate 
28117c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
28127c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
28137c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
28147c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_INSTANCE) == -1) {
28157c478bd9Sstevel@tonic-gate 			uu_free(ret);
28167c478bd9Sstevel@tonic-gate 			return (NULL);
28177c478bd9Sstevel@tonic-gate 		}
28187c478bd9Sstevel@tonic-gate 	} else {
28197c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
28207c478bd9Sstevel@tonic-gate 	}
28217c478bd9Sstevel@tonic-gate 
28227c478bd9Sstevel@tonic-gate 	return (ret);
28237c478bd9Sstevel@tonic-gate }
28247c478bd9Sstevel@tonic-gate 
28257c478bd9Sstevel@tonic-gate scf_handle_t *
28267c478bd9Sstevel@tonic-gate scf_instance_handle(const scf_instance_t *val)
28277c478bd9Sstevel@tonic-gate {
28287c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
28297c478bd9Sstevel@tonic-gate }
28307c478bd9Sstevel@tonic-gate 
28317c478bd9Sstevel@tonic-gate void
28327c478bd9Sstevel@tonic-gate scf_instance_destroy(scf_instance_t *val)
28337c478bd9Sstevel@tonic-gate {
28347c478bd9Sstevel@tonic-gate 	if (val == NULL)
28357c478bd9Sstevel@tonic-gate 		return;
28367c478bd9Sstevel@tonic-gate 
28377c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
28387c478bd9Sstevel@tonic-gate 	uu_free(val);
28397c478bd9Sstevel@tonic-gate }
28407c478bd9Sstevel@tonic-gate 
28417c478bd9Sstevel@tonic-gate ssize_t
28427c478bd9Sstevel@tonic-gate scf_instance_get_name(const scf_instance_t *rep, char *out, size_t len)
28437c478bd9Sstevel@tonic-gate {
28447c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
28457c478bd9Sstevel@tonic-gate }
28467c478bd9Sstevel@tonic-gate 
28477c478bd9Sstevel@tonic-gate /*
28487c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
28497c478bd9Sstevel@tonic-gate  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
28507c478bd9Sstevel@tonic-gate  */
28517c478bd9Sstevel@tonic-gate scf_snapshot_t *
28527c478bd9Sstevel@tonic-gate scf_snapshot_create(scf_handle_t *handle)
28537c478bd9Sstevel@tonic-gate {
28547c478bd9Sstevel@tonic-gate 	scf_snapshot_t *ret;
28557c478bd9Sstevel@tonic-gate 
28567c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
28577c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
28587c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
28597c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_SNAPSHOT) == -1) {
28607c478bd9Sstevel@tonic-gate 			uu_free(ret);
28617c478bd9Sstevel@tonic-gate 			return (NULL);
28627c478bd9Sstevel@tonic-gate 		}
28637c478bd9Sstevel@tonic-gate 	} else {
28647c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
28657c478bd9Sstevel@tonic-gate 	}
28667c478bd9Sstevel@tonic-gate 
28677c478bd9Sstevel@tonic-gate 	return (ret);
28687c478bd9Sstevel@tonic-gate }
28697c478bd9Sstevel@tonic-gate 
28707c478bd9Sstevel@tonic-gate scf_handle_t *
28717c478bd9Sstevel@tonic-gate scf_snapshot_handle(const scf_snapshot_t *val)
28727c478bd9Sstevel@tonic-gate {
28737c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
28747c478bd9Sstevel@tonic-gate }
28757c478bd9Sstevel@tonic-gate 
28767c478bd9Sstevel@tonic-gate void
28777c478bd9Sstevel@tonic-gate scf_snapshot_destroy(scf_snapshot_t *val)
28787c478bd9Sstevel@tonic-gate {
28797c478bd9Sstevel@tonic-gate 	if (val == NULL)
28807c478bd9Sstevel@tonic-gate 		return;
28817c478bd9Sstevel@tonic-gate 
28827c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
28837c478bd9Sstevel@tonic-gate 	uu_free(val);
28847c478bd9Sstevel@tonic-gate }
28857c478bd9Sstevel@tonic-gate 
28867c478bd9Sstevel@tonic-gate ssize_t
28877c478bd9Sstevel@tonic-gate scf_snapshot_get_name(const scf_snapshot_t *rep, char *out, size_t len)
28887c478bd9Sstevel@tonic-gate {
28897c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len, RP_ENTITY_NAME_NAME));
28907c478bd9Sstevel@tonic-gate }
28917c478bd9Sstevel@tonic-gate 
28927c478bd9Sstevel@tonic-gate /*
28937c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
28947c478bd9Sstevel@tonic-gate  * (bad server response or id in use), _NO_RESOURCES, _NO_MEMORY.
28957c478bd9Sstevel@tonic-gate  */
28967c478bd9Sstevel@tonic-gate scf_snaplevel_t *
28977c478bd9Sstevel@tonic-gate scf_snaplevel_create(scf_handle_t *handle)
28987c478bd9Sstevel@tonic-gate {
28997c478bd9Sstevel@tonic-gate 	scf_snaplevel_t *ret;
29007c478bd9Sstevel@tonic-gate 
29017c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
29027c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
29037c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
29047c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_SNAPLEVEL) == -1) {
29057c478bd9Sstevel@tonic-gate 			uu_free(ret);
29067c478bd9Sstevel@tonic-gate 			return (NULL);
29077c478bd9Sstevel@tonic-gate 		}
29087c478bd9Sstevel@tonic-gate 	} else {
29097c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
29107c478bd9Sstevel@tonic-gate 	}
29117c478bd9Sstevel@tonic-gate 
29127c478bd9Sstevel@tonic-gate 	return (ret);
29137c478bd9Sstevel@tonic-gate }
29147c478bd9Sstevel@tonic-gate 
29157c478bd9Sstevel@tonic-gate scf_handle_t *
29167c478bd9Sstevel@tonic-gate scf_snaplevel_handle(const scf_snaplevel_t *val)
29177c478bd9Sstevel@tonic-gate {
29187c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
29197c478bd9Sstevel@tonic-gate }
29207c478bd9Sstevel@tonic-gate 
29217c478bd9Sstevel@tonic-gate void
29227c478bd9Sstevel@tonic-gate scf_snaplevel_destroy(scf_snaplevel_t *val)
29237c478bd9Sstevel@tonic-gate {
29247c478bd9Sstevel@tonic-gate 	if (val == NULL)
29257c478bd9Sstevel@tonic-gate 		return;
29267c478bd9Sstevel@tonic-gate 
29277c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
29287c478bd9Sstevel@tonic-gate 	uu_free(val);
29297c478bd9Sstevel@tonic-gate }
29307c478bd9Sstevel@tonic-gate 
29317c478bd9Sstevel@tonic-gate ssize_t
29327c478bd9Sstevel@tonic-gate scf_snaplevel_get_scope_name(const scf_snaplevel_t *rep, char *out, size_t len)
29337c478bd9Sstevel@tonic-gate {
29347c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len,
29357c478bd9Sstevel@tonic-gate 	    RP_ENTITY_NAME_SNAPLEVEL_SCOPE));
29367c478bd9Sstevel@tonic-gate }
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate ssize_t
29397c478bd9Sstevel@tonic-gate scf_snaplevel_get_service_name(const scf_snaplevel_t *rep, char *out,
29407c478bd9Sstevel@tonic-gate     size_t len)
29417c478bd9Sstevel@tonic-gate {
29427c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len,
29437c478bd9Sstevel@tonic-gate 	    RP_ENTITY_NAME_SNAPLEVEL_SERVICE));
29447c478bd9Sstevel@tonic-gate }
29457c478bd9Sstevel@tonic-gate 
29467c478bd9Sstevel@tonic-gate ssize_t
29477c478bd9Sstevel@tonic-gate scf_snaplevel_get_instance_name(const scf_snaplevel_t *rep, char *out,
29487c478bd9Sstevel@tonic-gate     size_t len)
29497c478bd9Sstevel@tonic-gate {
29507c478bd9Sstevel@tonic-gate 	return (datael_get_name(&rep->rd_d, out, len,
29517c478bd9Sstevel@tonic-gate 	    RP_ENTITY_NAME_SNAPLEVEL_INSTANCE));
29527c478bd9Sstevel@tonic-gate }
29537c478bd9Sstevel@tonic-gate 
295476cf44abSjeanm /*
295576cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
295676cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
295776cf44abSjeanm  * _BACKEND_ACCESS, _NOT_FOUND.
295876cf44abSjeanm  */
29597c478bd9Sstevel@tonic-gate int
29607c478bd9Sstevel@tonic-gate scf_snaplevel_get_pg(const scf_snaplevel_t *snap, const char *name,
29617c478bd9Sstevel@tonic-gate     scf_propertygroup_t *pg)
29627c478bd9Sstevel@tonic-gate {
29637c478bd9Sstevel@tonic-gate 	return (datael_get_child(&snap->rd_d, name,
29647c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP, pg ? &pg->rd_d : NULL, 0));
29657c478bd9Sstevel@tonic-gate }
29667c478bd9Sstevel@tonic-gate 
29677c478bd9Sstevel@tonic-gate static int
29687c478bd9Sstevel@tonic-gate snaplevel_next(const scf_datael_t *src, scf_snaplevel_t *dst_arg)
29697c478bd9Sstevel@tonic-gate {
29707c478bd9Sstevel@tonic-gate 	scf_handle_t *h = src->rd_handle;
29717c478bd9Sstevel@tonic-gate 	scf_snaplevel_t *dst = dst_arg;
29727c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_pair request;
29737c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
29747c478bd9Sstevel@tonic-gate 	int r;
29757c478bd9Sstevel@tonic-gate 	int dups = 0;
29767c478bd9Sstevel@tonic-gate 
29777c478bd9Sstevel@tonic-gate 	if (h != dst->rd_d.rd_handle)
29787c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
29797c478bd9Sstevel@tonic-gate 
29807c478bd9Sstevel@tonic-gate 	if (src == &dst->rd_d) {
29817c478bd9Sstevel@tonic-gate 		dups = 1;
29827c478bd9Sstevel@tonic-gate 		dst = HANDLE_HOLD_SNAPLVL(h);
29837c478bd9Sstevel@tonic-gate 	}
29847c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
29857c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_NEXT_SNAPLEVEL;
29867c478bd9Sstevel@tonic-gate 	request.rpr_entity_src = src->rd_entity;
29877c478bd9Sstevel@tonic-gate 	request.rpr_entity_dst = dst->rd_d.rd_entity;
29887c478bd9Sstevel@tonic-gate 
29897c478bd9Sstevel@tonic-gate 	datael_finish_reset(src);
29907c478bd9Sstevel@tonic-gate 	datael_finish_reset(&dst->rd_d);
29917c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
29927c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
29937c478bd9Sstevel@tonic-gate 	/*
29947c478bd9Sstevel@tonic-gate 	 * if we succeeded, we need to swap dst and dst_arg's identity.  We
29957c478bd9Sstevel@tonic-gate 	 * take advantage of the fact that the only in-library knowledge is
29967c478bd9Sstevel@tonic-gate 	 * their entity ids.
29977c478bd9Sstevel@tonic-gate 	 */
29987c478bd9Sstevel@tonic-gate 	if (dups && r >= 0 &&
29997c478bd9Sstevel@tonic-gate 	    (response.rpr_response == REP_PROTOCOL_SUCCESS ||
30007c478bd9Sstevel@tonic-gate 	    response.rpr_response == REP_PROTOCOL_DONE)) {
30017c478bd9Sstevel@tonic-gate 		int entity = dst->rd_d.rd_entity;
30027c478bd9Sstevel@tonic-gate 
30037c478bd9Sstevel@tonic-gate 		dst->rd_d.rd_entity = dst_arg->rd_d.rd_entity;
30047c478bd9Sstevel@tonic-gate 		dst_arg->rd_d.rd_entity = entity;
30057c478bd9Sstevel@tonic-gate 	}
30067c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
30077c478bd9Sstevel@tonic-gate 
30087c478bd9Sstevel@tonic-gate 	if (dups)
30097c478bd9Sstevel@tonic-gate 		HANDLE_RELE_SNAPLVL(h);
30107c478bd9Sstevel@tonic-gate 
30117c478bd9Sstevel@tonic-gate 	if (r < 0)
30127c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
30137c478bd9Sstevel@tonic-gate 
30147c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
30157c478bd9Sstevel@tonic-gate 	    response.rpr_response != REP_PROTOCOL_DONE) {
30167c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
30177c478bd9Sstevel@tonic-gate 	}
30187c478bd9Sstevel@tonic-gate 
30197c478bd9Sstevel@tonic-gate 	return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
30207c478bd9Sstevel@tonic-gate 	    SCF_SUCCESS : SCF_COMPLETE;
30217c478bd9Sstevel@tonic-gate }
30227c478bd9Sstevel@tonic-gate 
30237c478bd9Sstevel@tonic-gate int scf_snapshot_get_base_snaplevel(const scf_snapshot_t *base,
30247c478bd9Sstevel@tonic-gate     scf_snaplevel_t *out)
30257c478bd9Sstevel@tonic-gate {
30267c478bd9Sstevel@tonic-gate 	return (snaplevel_next(&base->rd_d, out));
30277c478bd9Sstevel@tonic-gate }
30287c478bd9Sstevel@tonic-gate 
30297c478bd9Sstevel@tonic-gate int scf_snaplevel_get_next_snaplevel(const scf_snaplevel_t *base,
30307c478bd9Sstevel@tonic-gate     scf_snaplevel_t *out)
30317c478bd9Sstevel@tonic-gate {
30327c478bd9Sstevel@tonic-gate 	return (snaplevel_next(&base->rd_d, out));
30337c478bd9Sstevel@tonic-gate }
30347c478bd9Sstevel@tonic-gate 
30357c478bd9Sstevel@tonic-gate /*
30367c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
30377c478bd9Sstevel@tonic-gate  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
30387c478bd9Sstevel@tonic-gate  */
30397c478bd9Sstevel@tonic-gate scf_propertygroup_t *
30407c478bd9Sstevel@tonic-gate scf_pg_create(scf_handle_t *handle)
30417c478bd9Sstevel@tonic-gate {
30427c478bd9Sstevel@tonic-gate 	scf_propertygroup_t *ret;
30437c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
30447c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
30457c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
30467c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_PROPERTYGRP) == -1) {
30477c478bd9Sstevel@tonic-gate 			uu_free(ret);
30487c478bd9Sstevel@tonic-gate 			return (NULL);
30497c478bd9Sstevel@tonic-gate 		}
30507c478bd9Sstevel@tonic-gate 	} else {
30517c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
30527c478bd9Sstevel@tonic-gate 	}
30537c478bd9Sstevel@tonic-gate 
30547c478bd9Sstevel@tonic-gate 	return (ret);
30557c478bd9Sstevel@tonic-gate }
30567c478bd9Sstevel@tonic-gate 
30577c478bd9Sstevel@tonic-gate scf_handle_t *
30587c478bd9Sstevel@tonic-gate scf_pg_handle(const scf_propertygroup_t *val)
30597c478bd9Sstevel@tonic-gate {
30607c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
30617c478bd9Sstevel@tonic-gate }
30627c478bd9Sstevel@tonic-gate 
30637c478bd9Sstevel@tonic-gate void
30647c478bd9Sstevel@tonic-gate scf_pg_destroy(scf_propertygroup_t *val)
30657c478bd9Sstevel@tonic-gate {
30667c478bd9Sstevel@tonic-gate 	if (val == NULL)
30677c478bd9Sstevel@tonic-gate 		return;
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
30707c478bd9Sstevel@tonic-gate 	uu_free(val);
30717c478bd9Sstevel@tonic-gate }
30727c478bd9Sstevel@tonic-gate 
30737c478bd9Sstevel@tonic-gate ssize_t
30747c478bd9Sstevel@tonic-gate scf_pg_get_name(const scf_propertygroup_t *pg,  char *out, size_t len)
30757c478bd9Sstevel@tonic-gate {
30767c478bd9Sstevel@tonic-gate 	return (datael_get_name(&pg->rd_d, out, len, RP_ENTITY_NAME_NAME));
30777c478bd9Sstevel@tonic-gate }
30787c478bd9Sstevel@tonic-gate 
30797c478bd9Sstevel@tonic-gate ssize_t
30807c478bd9Sstevel@tonic-gate scf_pg_get_type(const scf_propertygroup_t *pg,  char *out, size_t len)
30817c478bd9Sstevel@tonic-gate {
30827c478bd9Sstevel@tonic-gate 	return (datael_get_name(&pg->rd_d, out, len, RP_ENTITY_NAME_PGTYPE));
30837c478bd9Sstevel@tonic-gate }
30847c478bd9Sstevel@tonic-gate 
30857c478bd9Sstevel@tonic-gate int
30867c478bd9Sstevel@tonic-gate scf_pg_get_flags(const scf_propertygroup_t *pg, uint32_t *out)
30877c478bd9Sstevel@tonic-gate {
30887c478bd9Sstevel@tonic-gate 	char buf[REP_PROTOCOL_NAME_LEN];
30897c478bd9Sstevel@tonic-gate 	ssize_t res;
30907c478bd9Sstevel@tonic-gate 
30917c478bd9Sstevel@tonic-gate 	res = datael_get_name(&pg->rd_d, buf, sizeof (buf),
30927c478bd9Sstevel@tonic-gate 	    RP_ENTITY_NAME_PGFLAGS);
30937c478bd9Sstevel@tonic-gate 
30947c478bd9Sstevel@tonic-gate 	if (res == -1)
30957c478bd9Sstevel@tonic-gate 		return (-1);
30967c478bd9Sstevel@tonic-gate 
30977c478bd9Sstevel@tonic-gate 	if (uu_strtouint(buf, out, sizeof (*out), 0, 0, UINT32_MAX) == -1)
30987c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INTERNAL));
30997c478bd9Sstevel@tonic-gate 
31007c478bd9Sstevel@tonic-gate 	return (0);
31017c478bd9Sstevel@tonic-gate }
31027c478bd9Sstevel@tonic-gate 
31037c478bd9Sstevel@tonic-gate static int
31047c478bd9Sstevel@tonic-gate datael_update(scf_datael_t *dp)
31057c478bd9Sstevel@tonic-gate {
31067c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dp->rd_handle;
31077c478bd9Sstevel@tonic-gate 
31087c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_update request;
31097c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
31107c478bd9Sstevel@tonic-gate 
31117c478bd9Sstevel@tonic-gate 	int r;
31127c478bd9Sstevel@tonic-gate 
31137c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
31147c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_UPDATE;
31157c478bd9Sstevel@tonic-gate 	request.rpr_entityid = dp->rd_entity;
31167c478bd9Sstevel@tonic-gate 
31177c478bd9Sstevel@tonic-gate 	datael_finish_reset(dp);
31188918dff3Sjwadams 	request.rpr_changeid = handle_next_changeid(h);
31197c478bd9Sstevel@tonic-gate 
31207c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
31217c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
31227c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
31237c478bd9Sstevel@tonic-gate 
31247c478bd9Sstevel@tonic-gate 	if (r < 0)
31257c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
31267c478bd9Sstevel@tonic-gate 
312776cf44abSjeanm 	/*
312876cf44abSjeanm 	 * This should never happen but if it does something has
312976cf44abSjeanm 	 * gone terribly wrong and we should abort.
313076cf44abSjeanm 	 */
313176cf44abSjeanm 	if (response.rpr_response == REP_PROTOCOL_FAIL_BAD_REQUEST)
313276cf44abSjeanm 		abort();
313376cf44abSjeanm 
31347c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
31357c478bd9Sstevel@tonic-gate 	    response.rpr_response != REP_PROTOCOL_DONE) {
31367c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
31377c478bd9Sstevel@tonic-gate 	}
31387c478bd9Sstevel@tonic-gate 
31397c478bd9Sstevel@tonic-gate 	return (response.rpr_response == REP_PROTOCOL_SUCCESS) ?
31407c478bd9Sstevel@tonic-gate 	    SCF_SUCCESS : SCF_COMPLETE;
31417c478bd9Sstevel@tonic-gate }
31427c478bd9Sstevel@tonic-gate 
31437c478bd9Sstevel@tonic-gate int
31447c478bd9Sstevel@tonic-gate scf_pg_update(scf_propertygroup_t *pg)
31457c478bd9Sstevel@tonic-gate {
31467c478bd9Sstevel@tonic-gate 	return (datael_update(&pg->rd_d));
31477c478bd9Sstevel@tonic-gate }
31487c478bd9Sstevel@tonic-gate 
31497c478bd9Sstevel@tonic-gate int
31507c478bd9Sstevel@tonic-gate scf_snapshot_update(scf_snapshot_t *snap)
31517c478bd9Sstevel@tonic-gate {
31527c478bd9Sstevel@tonic-gate 	return (datael_update(&snap->rd_d));
31537c478bd9Sstevel@tonic-gate }
31547c478bd9Sstevel@tonic-gate 
31557c478bd9Sstevel@tonic-gate int
31567c478bd9Sstevel@tonic-gate _scf_pg_wait(scf_propertygroup_t *pg, int timeout)
31577c478bd9Sstevel@tonic-gate {
31587c478bd9Sstevel@tonic-gate 	scf_handle_t *h = pg->rd_d.rd_handle;
31597c478bd9Sstevel@tonic-gate 
31607c478bd9Sstevel@tonic-gate 	struct rep_protocol_propertygrp_request request;
31617c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
31627c478bd9Sstevel@tonic-gate 
31637c478bd9Sstevel@tonic-gate 	struct pollfd pollfd;
31647c478bd9Sstevel@tonic-gate 
31657c478bd9Sstevel@tonic-gate 	int r;
31667c478bd9Sstevel@tonic-gate 
31677c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
31687c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_PROPERTYGRP_SETUP_WAIT;
31697c478bd9Sstevel@tonic-gate 	request.rpr_entityid = pg->rd_d.rd_entity;
31707c478bd9Sstevel@tonic-gate 
31717c478bd9Sstevel@tonic-gate 	datael_finish_reset(&pg->rd_d);
31727c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(h)) {
31737c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
31747c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
31757c478bd9Sstevel@tonic-gate 	}
31767c478bd9Sstevel@tonic-gate 	r = make_door_call_retfd(h->rh_doorfd, &request, sizeof (request),
31777c478bd9Sstevel@tonic-gate 	    &response, sizeof (response), &pollfd.fd);
31787c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
31797c478bd9Sstevel@tonic-gate 
31807c478bd9Sstevel@tonic-gate 	if (r < 0)
31817c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
31827c478bd9Sstevel@tonic-gate 
31837c478bd9Sstevel@tonic-gate 	assert((response.rpr_response == REP_PROTOCOL_SUCCESS) ==
31847c478bd9Sstevel@tonic-gate 	    (pollfd.fd != -1));
31857c478bd9Sstevel@tonic-gate 
31867c478bd9Sstevel@tonic-gate 	if (response.rpr_response == REP_PROTOCOL_FAIL_NOT_LATEST)
31877c478bd9Sstevel@tonic-gate 		return (SCF_SUCCESS);
31887c478bd9Sstevel@tonic-gate 
31897c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
31907c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
31917c478bd9Sstevel@tonic-gate 
31927c478bd9Sstevel@tonic-gate 	pollfd.events = 0;
31937c478bd9Sstevel@tonic-gate 	pollfd.revents = 0;
31947c478bd9Sstevel@tonic-gate 
31957c478bd9Sstevel@tonic-gate 	r = poll(&pollfd, 1, timeout * MILLISEC);
31967c478bd9Sstevel@tonic-gate 
31977c478bd9Sstevel@tonic-gate 	(void) close(pollfd.fd);
31987c478bd9Sstevel@tonic-gate 	return (pollfd.revents ? SCF_SUCCESS : SCF_COMPLETE);
31997c478bd9Sstevel@tonic-gate }
32007c478bd9Sstevel@tonic-gate 
32017c478bd9Sstevel@tonic-gate static int
32027c478bd9Sstevel@tonic-gate scf_notify_add_pattern(scf_handle_t *h, int type, const char *name)
32037c478bd9Sstevel@tonic-gate {
32047c478bd9Sstevel@tonic-gate 	struct rep_protocol_notify_request request;
32057c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
32067c478bd9Sstevel@tonic-gate 	int r;
32077c478bd9Sstevel@tonic-gate 
32087c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
32097c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_CLIENT_ADD_NOTIFY;
32107c478bd9Sstevel@tonic-gate 	request.rpr_type = type;
32117c478bd9Sstevel@tonic-gate 	(void) strlcpy(request.rpr_pattern, name, sizeof (request.rpr_pattern));
32127c478bd9Sstevel@tonic-gate 
32137c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
32147c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
32157c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
32167c478bd9Sstevel@tonic-gate 
32177c478bd9Sstevel@tonic-gate 	if (r < 0)
32187c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
32197c478bd9Sstevel@tonic-gate 
32207c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
32217c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
32227c478bd9Sstevel@tonic-gate 
32237c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
32247c478bd9Sstevel@tonic-gate }
32257c478bd9Sstevel@tonic-gate 
32267c478bd9Sstevel@tonic-gate int
32277c478bd9Sstevel@tonic-gate _scf_notify_add_pgname(scf_handle_t *h, const char *name)
32287c478bd9Sstevel@tonic-gate {
32297c478bd9Sstevel@tonic-gate 	return (scf_notify_add_pattern(h, REP_PROTOCOL_NOTIFY_PGNAME, name));
32307c478bd9Sstevel@tonic-gate }
32317c478bd9Sstevel@tonic-gate 
32327c478bd9Sstevel@tonic-gate int
32337c478bd9Sstevel@tonic-gate _scf_notify_add_pgtype(scf_handle_t *h, const char *type)
32347c478bd9Sstevel@tonic-gate {
32357c478bd9Sstevel@tonic-gate 	return (scf_notify_add_pattern(h, REP_PROTOCOL_NOTIFY_PGTYPE, type));
32367c478bd9Sstevel@tonic-gate }
32377c478bd9Sstevel@tonic-gate 
32387c478bd9Sstevel@tonic-gate int
32397c478bd9Sstevel@tonic-gate _scf_notify_wait(scf_propertygroup_t *pg, char *out, size_t sz)
32407c478bd9Sstevel@tonic-gate {
32417c478bd9Sstevel@tonic-gate 	struct rep_protocol_wait_request request;
32427c478bd9Sstevel@tonic-gate 	struct rep_protocol_fmri_response response;
32437c478bd9Sstevel@tonic-gate 
32447c478bd9Sstevel@tonic-gate 	scf_handle_t *h = pg->rd_d.rd_handle;
32457c478bd9Sstevel@tonic-gate 	int dummy;
32467c478bd9Sstevel@tonic-gate 	int fd;
32477c478bd9Sstevel@tonic-gate 	int r;
32487c478bd9Sstevel@tonic-gate 
32497c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
32507c478bd9Sstevel@tonic-gate 	datael_finish_reset(&pg->rd_d);
32517c478bd9Sstevel@tonic-gate 	if (!handle_is_bound(h)) {
32527c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
32537c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_CONNECTION_BROKEN));
32547c478bd9Sstevel@tonic-gate 	}
32557c478bd9Sstevel@tonic-gate 	fd = h->rh_doorfd;
32567c478bd9Sstevel@tonic-gate 	++h->rh_fd_users;
32577c478bd9Sstevel@tonic-gate 	assert(h->rh_fd_users > 0);
32587c478bd9Sstevel@tonic-gate 
32597c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_CLIENT_WAIT;
32607c478bd9Sstevel@tonic-gate 	request.rpr_entityid = pg->rd_d.rd_entity;
32617c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
32627c478bd9Sstevel@tonic-gate 
32637c478bd9Sstevel@tonic-gate 	r = make_door_call_retfd(fd, &request, sizeof (request),
32647c478bd9Sstevel@tonic-gate 	    &response, sizeof (response), &dummy);
32657c478bd9Sstevel@tonic-gate 
32667c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
32677c478bd9Sstevel@tonic-gate 	assert(h->rh_fd_users > 0);
32687c478bd9Sstevel@tonic-gate 	if (--h->rh_fd_users == 0) {
32697c478bd9Sstevel@tonic-gate 		(void) pthread_cond_broadcast(&h->rh_cv);
32707c478bd9Sstevel@tonic-gate 		/*
32717c478bd9Sstevel@tonic-gate 		 * check for a delayed close, now that there are no other
32727c478bd9Sstevel@tonic-gate 		 * users.
32737c478bd9Sstevel@tonic-gate 		 */
32747c478bd9Sstevel@tonic-gate 		if (h->rh_doorfd_old != -1) {
32757c478bd9Sstevel@tonic-gate 			assert(h->rh_doorfd == -1);
32767c478bd9Sstevel@tonic-gate 			assert(fd == h->rh_doorfd_old);
32777c478bd9Sstevel@tonic-gate 			(void) close(h->rh_doorfd_old);
32787c478bd9Sstevel@tonic-gate 			h->rh_doorfd_old = -1;
32797c478bd9Sstevel@tonic-gate 		}
32807c478bd9Sstevel@tonic-gate 	}
32817c478bd9Sstevel@tonic-gate 	handle_unrefed(h);			/* drops h->rh_lock */
32827c478bd9Sstevel@tonic-gate 
32837c478bd9Sstevel@tonic-gate 	if (r < 0)
32847c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
32857c478bd9Sstevel@tonic-gate 
32867c478bd9Sstevel@tonic-gate 	if (response.rpr_response == REP_PROTOCOL_DONE)
32877c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
32887c478bd9Sstevel@tonic-gate 
32897c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
32907c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
32917c478bd9Sstevel@tonic-gate 
32927c478bd9Sstevel@tonic-gate 	/* the following will be non-zero for delete notifications */
32937c478bd9Sstevel@tonic-gate 	return (strlcpy(out, response.rpr_fmri, sz));
32947c478bd9Sstevel@tonic-gate }
32957c478bd9Sstevel@tonic-gate 
32967c478bd9Sstevel@tonic-gate static int
32977c478bd9Sstevel@tonic-gate _scf_snapshot_take(scf_instance_t *inst, const char *name,
32987c478bd9Sstevel@tonic-gate     scf_snapshot_t *snap, int flags)
32997c478bd9Sstevel@tonic-gate {
33007c478bd9Sstevel@tonic-gate 	scf_handle_t *h = inst->rd_d.rd_handle;
33017c478bd9Sstevel@tonic-gate 
33027c478bd9Sstevel@tonic-gate 	struct rep_protocol_snapshot_take request;
33037c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
33047c478bd9Sstevel@tonic-gate 
33057c478bd9Sstevel@tonic-gate 	int r;
33067c478bd9Sstevel@tonic-gate 
33077c478bd9Sstevel@tonic-gate 	if (h != snap->rd_d.rd_handle)
33087c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
33097c478bd9Sstevel@tonic-gate 
33107c478bd9Sstevel@tonic-gate 	if (strlcpy(request.rpr_name, (name != NULL)? name : "",
33117c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_name)) >= sizeof (request.rpr_name))
33127c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
33137c478bd9Sstevel@tonic-gate 
33147c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
33157c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_SNAPSHOT_TAKE;
33167c478bd9Sstevel@tonic-gate 	request.rpr_entityid_src = inst->rd_d.rd_entity;
33177c478bd9Sstevel@tonic-gate 	request.rpr_entityid_dest = snap->rd_d.rd_entity;
33187c478bd9Sstevel@tonic-gate 	request.rpr_flags = flags;
33197c478bd9Sstevel@tonic-gate 
33207c478bd9Sstevel@tonic-gate 	datael_finish_reset(&inst->rd_d);
33217c478bd9Sstevel@tonic-gate 	datael_finish_reset(&snap->rd_d);
33227c478bd9Sstevel@tonic-gate 
33237c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
33247c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
33257c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
33267c478bd9Sstevel@tonic-gate 
33277c478bd9Sstevel@tonic-gate 	if (r < 0)
33287c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
33297c478bd9Sstevel@tonic-gate 
33307c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
33317c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
33327c478bd9Sstevel@tonic-gate 
33337c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
33347c478bd9Sstevel@tonic-gate }
33357c478bd9Sstevel@tonic-gate 
33367c478bd9Sstevel@tonic-gate int
33377c478bd9Sstevel@tonic-gate _scf_snapshot_take_new_named(scf_instance_t *inst,
33387c478bd9Sstevel@tonic-gate     const char *svcname, const char *instname, const char *snapname,
33397c478bd9Sstevel@tonic-gate     scf_snapshot_t *snap)
33407c478bd9Sstevel@tonic-gate {
33417c478bd9Sstevel@tonic-gate 	scf_handle_t *h = inst->rd_d.rd_handle;
33427c478bd9Sstevel@tonic-gate 
33437c478bd9Sstevel@tonic-gate 	struct rep_protocol_snapshot_take_named request;
33447c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
33457c478bd9Sstevel@tonic-gate 
33467c478bd9Sstevel@tonic-gate 	int r;
33477c478bd9Sstevel@tonic-gate 
33487c478bd9Sstevel@tonic-gate 	if (h != snap->rd_d.rd_handle)
33497c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
33507c478bd9Sstevel@tonic-gate 
33517c478bd9Sstevel@tonic-gate 	if (strlcpy(request.rpr_svcname, svcname,
33527c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_svcname)) >= sizeof (request.rpr_svcname))
33537c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
33547c478bd9Sstevel@tonic-gate 
33557c478bd9Sstevel@tonic-gate 	if (strlcpy(request.rpr_instname, instname,
33567c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_instname)) >= sizeof (request.rpr_instname))
33577c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
33587c478bd9Sstevel@tonic-gate 
33597c478bd9Sstevel@tonic-gate 	if (strlcpy(request.rpr_name, snapname,
33607c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_name)) >= sizeof (request.rpr_name))
33617c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
33627c478bd9Sstevel@tonic-gate 
33637c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
33647c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_SNAPSHOT_TAKE_NAMED;
33657c478bd9Sstevel@tonic-gate 	request.rpr_entityid_src = inst->rd_d.rd_entity;
33667c478bd9Sstevel@tonic-gate 	request.rpr_entityid_dest = snap->rd_d.rd_entity;
33677c478bd9Sstevel@tonic-gate 
33687c478bd9Sstevel@tonic-gate 	datael_finish_reset(&inst->rd_d);
33697c478bd9Sstevel@tonic-gate 	datael_finish_reset(&snap->rd_d);
33707c478bd9Sstevel@tonic-gate 
33717c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
33727c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
33737c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
33747c478bd9Sstevel@tonic-gate 
33757c478bd9Sstevel@tonic-gate 	if (r < 0)
33767c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
33777c478bd9Sstevel@tonic-gate 
33787c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
33797c478bd9Sstevel@tonic-gate 		assert(response.rpr_response !=
33807c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_FAIL_TYPE_MISMATCH);
33817c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
33827c478bd9Sstevel@tonic-gate 	}
33837c478bd9Sstevel@tonic-gate 
33847c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
33857c478bd9Sstevel@tonic-gate }
33867c478bd9Sstevel@tonic-gate 
33877c478bd9Sstevel@tonic-gate int
33887c478bd9Sstevel@tonic-gate _scf_snapshot_take_new(scf_instance_t *inst, const char *name,
33897c478bd9Sstevel@tonic-gate     scf_snapshot_t *snap)
33907c478bd9Sstevel@tonic-gate {
33917c478bd9Sstevel@tonic-gate 	return (_scf_snapshot_take(inst, name, snap, REP_SNAPSHOT_NEW));
33927c478bd9Sstevel@tonic-gate }
33937c478bd9Sstevel@tonic-gate 
33947c478bd9Sstevel@tonic-gate int
33957c478bd9Sstevel@tonic-gate _scf_snapshot_take_attach(scf_instance_t *inst, scf_snapshot_t *snap)
33967c478bd9Sstevel@tonic-gate {
33977c478bd9Sstevel@tonic-gate 	return (_scf_snapshot_take(inst, NULL, snap, REP_SNAPSHOT_ATTACH));
33987c478bd9Sstevel@tonic-gate }
33997c478bd9Sstevel@tonic-gate 
34007c478bd9Sstevel@tonic-gate int
34017c478bd9Sstevel@tonic-gate _scf_snapshot_attach(scf_snapshot_t *src, scf_snapshot_t *dest)
34027c478bd9Sstevel@tonic-gate {
34037c478bd9Sstevel@tonic-gate 	scf_handle_t *h = dest->rd_d.rd_handle;
34047c478bd9Sstevel@tonic-gate 
34057c478bd9Sstevel@tonic-gate 	struct rep_protocol_snapshot_attach request;
34067c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
34077c478bd9Sstevel@tonic-gate 
34087c478bd9Sstevel@tonic-gate 	int r;
34097c478bd9Sstevel@tonic-gate 
34107c478bd9Sstevel@tonic-gate 	if (h != src->rd_d.rd_handle)
34117c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
34127c478bd9Sstevel@tonic-gate 
34137c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
34147c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_SNAPSHOT_ATTACH;
34157c478bd9Sstevel@tonic-gate 	request.rpr_entityid_src = src->rd_d.rd_entity;
34167c478bd9Sstevel@tonic-gate 	request.rpr_entityid_dest = dest->rd_d.rd_entity;
34177c478bd9Sstevel@tonic-gate 
34187c478bd9Sstevel@tonic-gate 	datael_finish_reset(&src->rd_d);
34197c478bd9Sstevel@tonic-gate 	datael_finish_reset(&dest->rd_d);
34207c478bd9Sstevel@tonic-gate 
34217c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
34227c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
34237c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
34247c478bd9Sstevel@tonic-gate 
34257c478bd9Sstevel@tonic-gate 	if (r < 0)
34267c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
34277c478bd9Sstevel@tonic-gate 
34287c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
34297c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
34307c478bd9Sstevel@tonic-gate 
34317c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
34327c478bd9Sstevel@tonic-gate }
34337c478bd9Sstevel@tonic-gate 
34347c478bd9Sstevel@tonic-gate /*
34357c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED, _INTERNAL
34367c478bd9Sstevel@tonic-gate  * (bad server response or id in use), _NO_RESOURCES, or _NO_MEMORY.
34377c478bd9Sstevel@tonic-gate  */
34387c478bd9Sstevel@tonic-gate scf_property_t *
34397c478bd9Sstevel@tonic-gate scf_property_create(scf_handle_t *handle)
34407c478bd9Sstevel@tonic-gate {
34417c478bd9Sstevel@tonic-gate 	scf_property_t *ret;
34427c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
34437c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
34447c478bd9Sstevel@tonic-gate 		if (datael_init(&ret->rd_d, handle,
34457c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_ENTITY_PROPERTY) == -1) {
34467c478bd9Sstevel@tonic-gate 			uu_free(ret);
34477c478bd9Sstevel@tonic-gate 			return (NULL);
34487c478bd9Sstevel@tonic-gate 		}
34497c478bd9Sstevel@tonic-gate 	} else {
34507c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
34517c478bd9Sstevel@tonic-gate 	}
34527c478bd9Sstevel@tonic-gate 
34537c478bd9Sstevel@tonic-gate 	return (ret);
34547c478bd9Sstevel@tonic-gate }
34557c478bd9Sstevel@tonic-gate 
34567c478bd9Sstevel@tonic-gate scf_handle_t *
34577c478bd9Sstevel@tonic-gate scf_property_handle(const scf_property_t *val)
34587c478bd9Sstevel@tonic-gate {
34597c478bd9Sstevel@tonic-gate 	return (datael_handle(&val->rd_d));
34607c478bd9Sstevel@tonic-gate }
34617c478bd9Sstevel@tonic-gate 
34627c478bd9Sstevel@tonic-gate void
34637c478bd9Sstevel@tonic-gate scf_property_destroy(scf_property_t *val)
34647c478bd9Sstevel@tonic-gate {
34657c478bd9Sstevel@tonic-gate 	if (val == NULL)
34667c478bd9Sstevel@tonic-gate 		return;
34677c478bd9Sstevel@tonic-gate 
34687c478bd9Sstevel@tonic-gate 	datael_destroy(&val->rd_d);
34697c478bd9Sstevel@tonic-gate 	uu_free(val);
34707c478bd9Sstevel@tonic-gate }
34717c478bd9Sstevel@tonic-gate 
34727c478bd9Sstevel@tonic-gate static int
34737c478bd9Sstevel@tonic-gate property_type_locked(const scf_property_t *prop,
34747c478bd9Sstevel@tonic-gate     rep_protocol_value_type_t *out)
34757c478bd9Sstevel@tonic-gate {
34767c478bd9Sstevel@tonic-gate 	scf_handle_t *h = prop->rd_d.rd_handle;
34777c478bd9Sstevel@tonic-gate 
34787c478bd9Sstevel@tonic-gate 	struct rep_protocol_property_request request;
34797c478bd9Sstevel@tonic-gate 	struct rep_protocol_integer_response response;
34807c478bd9Sstevel@tonic-gate 
34817c478bd9Sstevel@tonic-gate 	int r;
34827c478bd9Sstevel@tonic-gate 
34837c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
34847c478bd9Sstevel@tonic-gate 
34857c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_PROPERTY_GET_TYPE;
34867c478bd9Sstevel@tonic-gate 	request.rpr_entityid = prop->rd_d.rd_entity;
34877c478bd9Sstevel@tonic-gate 
34887c478bd9Sstevel@tonic-gate 	datael_finish_reset(&prop->rd_d);
34897c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
34907c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
34917c478bd9Sstevel@tonic-gate 
34927c478bd9Sstevel@tonic-gate 	if (r < 0)
34937c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
34947c478bd9Sstevel@tonic-gate 
34957c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
34967c478bd9Sstevel@tonic-gate 	    r < sizeof (response)) {
34977c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
34987c478bd9Sstevel@tonic-gate 	}
34997c478bd9Sstevel@tonic-gate 	*out = response.rpr_value;
35007c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
35017c478bd9Sstevel@tonic-gate }
35027c478bd9Sstevel@tonic-gate 
35037c478bd9Sstevel@tonic-gate int
35047c478bd9Sstevel@tonic-gate scf_property_type(const scf_property_t *prop, scf_type_t *out)
35057c478bd9Sstevel@tonic-gate {
35067c478bd9Sstevel@tonic-gate 	scf_handle_t *h = prop->rd_d.rd_handle;
35077c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t out_raw;
35087c478bd9Sstevel@tonic-gate 	int ret;
35097c478bd9Sstevel@tonic-gate 
35107c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
35117c478bd9Sstevel@tonic-gate 	ret = property_type_locked(prop, &out_raw);
35127c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
35137c478bd9Sstevel@tonic-gate 
35147c478bd9Sstevel@tonic-gate 	if (ret == SCF_SUCCESS)
35157c478bd9Sstevel@tonic-gate 		*out = scf_protocol_type_to_type(out_raw);
35167c478bd9Sstevel@tonic-gate 
35177c478bd9Sstevel@tonic-gate 	return (ret);
35187c478bd9Sstevel@tonic-gate }
35197c478bd9Sstevel@tonic-gate 
35207c478bd9Sstevel@tonic-gate int
35217c478bd9Sstevel@tonic-gate scf_property_is_type(const scf_property_t *prop, scf_type_t base_arg)
35227c478bd9Sstevel@tonic-gate {
35237c478bd9Sstevel@tonic-gate 	scf_handle_t *h = prop->rd_d.rd_handle;
35247c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg);
35257c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t type;
35267c478bd9Sstevel@tonic-gate 	int ret;
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate 	if (base == REP_PROTOCOL_TYPE_INVALID)
35297c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
35307c478bd9Sstevel@tonic-gate 
35317c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
35327c478bd9Sstevel@tonic-gate 	ret = property_type_locked(prop, &type);
35337c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
35347c478bd9Sstevel@tonic-gate 
35357c478bd9Sstevel@tonic-gate 	if (ret == SCF_SUCCESS) {
35367c478bd9Sstevel@tonic-gate 		if (!scf_is_compatible_type(base, type))
35377c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_TYPE_MISMATCH));
35387c478bd9Sstevel@tonic-gate 	}
35397c478bd9Sstevel@tonic-gate 	return (ret);
35407c478bd9Sstevel@tonic-gate }
35417c478bd9Sstevel@tonic-gate 
35427c478bd9Sstevel@tonic-gate ssize_t
35437c478bd9Sstevel@tonic-gate scf_property_get_name(const scf_property_t *prop, char *out, size_t len)
35447c478bd9Sstevel@tonic-gate {
35457c478bd9Sstevel@tonic-gate 	return (datael_get_name(&prop->rd_d, out, len, RP_ENTITY_NAME_NAME));
35467c478bd9Sstevel@tonic-gate }
35477c478bd9Sstevel@tonic-gate 
35487c478bd9Sstevel@tonic-gate /*
35497c478bd9Sstevel@tonic-gate  * transaction functions
35507c478bd9Sstevel@tonic-gate  */
35517c478bd9Sstevel@tonic-gate 
35527c478bd9Sstevel@tonic-gate /*
35537c478bd9Sstevel@tonic-gate  * Fails with _NO_MEMORY, _INVALID_ARGUMENT (handle is NULL), _HANDLE_DESTROYED,
35547c478bd9Sstevel@tonic-gate  * _INTERNAL (bad server response or id in use), or _NO_RESOURCES.
35557c478bd9Sstevel@tonic-gate  */
35567c478bd9Sstevel@tonic-gate scf_transaction_t *
35577c478bd9Sstevel@tonic-gate scf_transaction_create(scf_handle_t *handle)
35587c478bd9Sstevel@tonic-gate {
35597c478bd9Sstevel@tonic-gate 	scf_transaction_t *ret;
35607c478bd9Sstevel@tonic-gate 
35617c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (scf_transaction_t));
35627c478bd9Sstevel@tonic-gate 	if (ret == NULL) {
35637c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
35647c478bd9Sstevel@tonic-gate 		return (NULL);
35657c478bd9Sstevel@tonic-gate 	}
35667c478bd9Sstevel@tonic-gate 	if (datael_init(&ret->tran_pg.rd_d, handle,
35677c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTYGRP) == -1) {
35687c478bd9Sstevel@tonic-gate 		uu_free(ret);
35697c478bd9Sstevel@tonic-gate 		return (NULL);			/* error already set */
35707c478bd9Sstevel@tonic-gate 	}
35717c478bd9Sstevel@tonic-gate 	ret->tran_state = TRAN_STATE_NEW;
35727c478bd9Sstevel@tonic-gate 	ret->tran_props = uu_list_create(tran_entry_pool, ret, UU_LIST_SORTED);
35737c478bd9Sstevel@tonic-gate 	if (ret->tran_props == NULL) {
35747c478bd9Sstevel@tonic-gate 		datael_destroy(&ret->tran_pg.rd_d);
35757c478bd9Sstevel@tonic-gate 		uu_free(ret);
35767c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
35777c478bd9Sstevel@tonic-gate 		return (NULL);
35787c478bd9Sstevel@tonic-gate 	}
35797c478bd9Sstevel@tonic-gate 
35807c478bd9Sstevel@tonic-gate 	return (ret);
35817c478bd9Sstevel@tonic-gate }
35827c478bd9Sstevel@tonic-gate 
35837c478bd9Sstevel@tonic-gate scf_handle_t *
35847c478bd9Sstevel@tonic-gate scf_transaction_handle(const scf_transaction_t *val)
35857c478bd9Sstevel@tonic-gate {
35867c478bd9Sstevel@tonic-gate 	return (handle_get(val->tran_pg.rd_d.rd_handle));
35877c478bd9Sstevel@tonic-gate }
35887c478bd9Sstevel@tonic-gate 
35897c478bd9Sstevel@tonic-gate int
35907c478bd9Sstevel@tonic-gate scf_transaction_start(scf_transaction_t *tran, scf_propertygroup_t *pg)
35917c478bd9Sstevel@tonic-gate {
35927c478bd9Sstevel@tonic-gate 	scf_handle_t *h = tran->tran_pg.rd_d.rd_handle;
35937c478bd9Sstevel@tonic-gate 
35947c478bd9Sstevel@tonic-gate 	struct rep_protocol_transaction_start request;
35957c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
35967c478bd9Sstevel@tonic-gate 	int r;
35977c478bd9Sstevel@tonic-gate 
35987c478bd9Sstevel@tonic-gate 	if (h != pg->rd_d.rd_handle)
35997c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
36007c478bd9Sstevel@tonic-gate 
36017c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
36027c478bd9Sstevel@tonic-gate 	if (tran->tran_state != TRAN_STATE_NEW) {
36037c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
36047c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_IN_USE));
36057c478bd9Sstevel@tonic-gate 	}
36067c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_PROPERTYGRP_TX_START;
36077c478bd9Sstevel@tonic-gate 	request.rpr_entityid_tx = tran->tran_pg.rd_d.rd_entity;
36087c478bd9Sstevel@tonic-gate 	request.rpr_entityid = pg->rd_d.rd_entity;
36097c478bd9Sstevel@tonic-gate 
36107c478bd9Sstevel@tonic-gate 	datael_finish_reset(&tran->tran_pg.rd_d);
36117c478bd9Sstevel@tonic-gate 	datael_finish_reset(&pg->rd_d);
36127c478bd9Sstevel@tonic-gate 
36137c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
36147c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
36157c478bd9Sstevel@tonic-gate 
36167c478bd9Sstevel@tonic-gate 	if (r < 0) {
36177c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
36187c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
36197c478bd9Sstevel@tonic-gate 	}
36207c478bd9Sstevel@tonic-gate 
36217c478bd9Sstevel@tonic-gate 	/* r < sizeof (response) cannot happen because sizeof (response) == 4 */
36227c478bd9Sstevel@tonic-gate 
36237c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
36247c478bd9Sstevel@tonic-gate 	    r < sizeof (response)) {
36257c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
36267c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
36277c478bd9Sstevel@tonic-gate 	}
36287c478bd9Sstevel@tonic-gate 
36297c478bd9Sstevel@tonic-gate 	tran->tran_state = TRAN_STATE_SETUP;
36307c478bd9Sstevel@tonic-gate 	tran->tran_invalid = 0;
36317c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
36327c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
36337c478bd9Sstevel@tonic-gate }
36347c478bd9Sstevel@tonic-gate 
36357c478bd9Sstevel@tonic-gate static void
36367c478bd9Sstevel@tonic-gate entry_invalidate(scf_transaction_entry_t *cur, int and_destroy,
36377c478bd9Sstevel@tonic-gate     int and_reset_value)
36387c478bd9Sstevel@tonic-gate {
36397c478bd9Sstevel@tonic-gate 	scf_value_t *v, *next;
36407c478bd9Sstevel@tonic-gate 	scf_transaction_t *tx;
36417c478bd9Sstevel@tonic-gate 	scf_handle_t *h = cur->entry_handle;
36427c478bd9Sstevel@tonic-gate 
36437c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
36447c478bd9Sstevel@tonic-gate 
36457c478bd9Sstevel@tonic-gate 	if ((tx = cur->entry_tx) != NULL) {
36467c478bd9Sstevel@tonic-gate 		tx->tran_invalid = 1;
36477c478bd9Sstevel@tonic-gate 		uu_list_remove(tx->tran_props, cur);
36487c478bd9Sstevel@tonic-gate 		cur->entry_tx = NULL;
36497c478bd9Sstevel@tonic-gate 	}
36507c478bd9Sstevel@tonic-gate 
36517c478bd9Sstevel@tonic-gate 	cur->entry_property = NULL;
36527c478bd9Sstevel@tonic-gate 	cur->entry_state = ENTRY_STATE_INVALID;
36537c478bd9Sstevel@tonic-gate 	cur->entry_action = REP_PROTOCOL_TX_ENTRY_INVALID;
36547c478bd9Sstevel@tonic-gate 	cur->entry_type = REP_PROTOCOL_TYPE_INVALID;
36557c478bd9Sstevel@tonic-gate 
36567c478bd9Sstevel@tonic-gate 	for (v = cur->entry_head; v != NULL; v = next) {
36577c478bd9Sstevel@tonic-gate 		next = v->value_next;
36587c478bd9Sstevel@tonic-gate 		v->value_tx = NULL;
36597c478bd9Sstevel@tonic-gate 		v->value_next = NULL;
36607c478bd9Sstevel@tonic-gate 		if (and_destroy || and_reset_value)
36617c478bd9Sstevel@tonic-gate 			scf_value_reset_locked(v, and_destroy);
36627c478bd9Sstevel@tonic-gate 	}
36637c478bd9Sstevel@tonic-gate 	cur->entry_head = NULL;
36646e1d2b42Samaguire 	cur->entry_tail = NULL;
36657c478bd9Sstevel@tonic-gate }
36667c478bd9Sstevel@tonic-gate 
36677c478bd9Sstevel@tonic-gate static void
36687c478bd9Sstevel@tonic-gate entry_destroy_locked(scf_transaction_entry_t *entry)
36697c478bd9Sstevel@tonic-gate {
36707c478bd9Sstevel@tonic-gate 	scf_handle_t *h = entry->entry_handle;
36717c478bd9Sstevel@tonic-gate 
36727c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
36737c478bd9Sstevel@tonic-gate 
36747c478bd9Sstevel@tonic-gate 	entry_invalidate(entry, 0, 0);
36757c478bd9Sstevel@tonic-gate 
36767c478bd9Sstevel@tonic-gate 	entry->entry_handle = NULL;
36777c478bd9Sstevel@tonic-gate 	assert(h->rh_entries > 0);
36787c478bd9Sstevel@tonic-gate 	--h->rh_entries;
36797c478bd9Sstevel@tonic-gate 	--h->rh_extrefs;
36807c478bd9Sstevel@tonic-gate 	uu_list_node_fini(entry, &entry->entry_link, tran_entry_pool);
36817c478bd9Sstevel@tonic-gate 	uu_free(entry);
36827c478bd9Sstevel@tonic-gate }
36837c478bd9Sstevel@tonic-gate 
368476cf44abSjeanm /*
368576cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
368676cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
368776cf44abSjeanm  * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
368876cf44abSjeanm  */
36897c478bd9Sstevel@tonic-gate static int
36907c478bd9Sstevel@tonic-gate transaction_add(scf_transaction_t *tran, scf_transaction_entry_t *entry,
36917c478bd9Sstevel@tonic-gate     enum rep_protocol_transaction_action action,
36927c478bd9Sstevel@tonic-gate     const char *prop, rep_protocol_value_type_t type)
36937c478bd9Sstevel@tonic-gate {
36947c478bd9Sstevel@tonic-gate 	scf_handle_t *h = tran->tran_pg.rd_d.rd_handle;
36957c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *old;
36967c478bd9Sstevel@tonic-gate 	scf_property_t *prop_p;
36977c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t oldtype;
36987c478bd9Sstevel@tonic-gate 	scf_error_t error = SCF_ERROR_NONE;
36997c478bd9Sstevel@tonic-gate 	int ret;
37007c478bd9Sstevel@tonic-gate 	uu_list_index_t idx;
37017c478bd9Sstevel@tonic-gate 
37027c478bd9Sstevel@tonic-gate 	if (h != entry->entry_handle)
37037c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
37047c478bd9Sstevel@tonic-gate 
37057c478bd9Sstevel@tonic-gate 	if (action == REP_PROTOCOL_TX_ENTRY_DELETE)
37067c478bd9Sstevel@tonic-gate 		assert(type == REP_PROTOCOL_TYPE_INVALID);
37077c478bd9Sstevel@tonic-gate 	else if (type == REP_PROTOCOL_TYPE_INVALID)
37087c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
37097c478bd9Sstevel@tonic-gate 
37107c478bd9Sstevel@tonic-gate 	prop_p = HANDLE_HOLD_PROPERTY(h);
37117c478bd9Sstevel@tonic-gate 
37127c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
37137c478bd9Sstevel@tonic-gate 	if (tran->tran_state != TRAN_STATE_SETUP) {
37147c478bd9Sstevel@tonic-gate 		error = SCF_ERROR_NOT_SET;
37157c478bd9Sstevel@tonic-gate 		goto error;
37167c478bd9Sstevel@tonic-gate 	}
37177c478bd9Sstevel@tonic-gate 	if (tran->tran_invalid) {
37187c478bd9Sstevel@tonic-gate 		error = SCF_ERROR_NOT_SET;
37197c478bd9Sstevel@tonic-gate 		goto error;
37207c478bd9Sstevel@tonic-gate 	}
37217c478bd9Sstevel@tonic-gate 
37227c478bd9Sstevel@tonic-gate 	if (entry->entry_state != ENTRY_STATE_INVALID)
37237c478bd9Sstevel@tonic-gate 		entry_invalidate(entry, 0, 0);
37247c478bd9Sstevel@tonic-gate 
37257c478bd9Sstevel@tonic-gate 	old = uu_list_find(tran->tran_props, &prop, NULL, &idx);
37267c478bd9Sstevel@tonic-gate 	if (old != NULL) {
37277c478bd9Sstevel@tonic-gate 		error = SCF_ERROR_IN_USE;
37287c478bd9Sstevel@tonic-gate 		goto error;
37297c478bd9Sstevel@tonic-gate 	}
37307c478bd9Sstevel@tonic-gate 
37317c478bd9Sstevel@tonic-gate 	ret = datael_get_child_locked(&tran->tran_pg.rd_d, prop,
37327c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_PROPERTY, &prop_p->rd_d);
37337c478bd9Sstevel@tonic-gate 	if (ret == -1 && (error = scf_error()) != SCF_ERROR_NOT_FOUND) {
37347c478bd9Sstevel@tonic-gate 		goto error;
37357c478bd9Sstevel@tonic-gate 	}
37367c478bd9Sstevel@tonic-gate 
37377c478bd9Sstevel@tonic-gate 	switch (action) {
37387c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TX_ENTRY_DELETE:
37397c478bd9Sstevel@tonic-gate 		if (ret == -1) {
37407c478bd9Sstevel@tonic-gate 			error = SCF_ERROR_NOT_FOUND;
37417c478bd9Sstevel@tonic-gate 			goto error;
37427c478bd9Sstevel@tonic-gate 		}
37437c478bd9Sstevel@tonic-gate 		break;
37447c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TX_ENTRY_NEW:
37457c478bd9Sstevel@tonic-gate 		if (ret != -1) {
37467c478bd9Sstevel@tonic-gate 			error = SCF_ERROR_EXISTS;
37477c478bd9Sstevel@tonic-gate 			goto error;
37487c478bd9Sstevel@tonic-gate 		}
37497c478bd9Sstevel@tonic-gate 		break;
37507c478bd9Sstevel@tonic-gate 
37517c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TX_ENTRY_CLEAR:
37527c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TX_ENTRY_REPLACE:
37537c478bd9Sstevel@tonic-gate 		if (ret == -1) {
37547c478bd9Sstevel@tonic-gate 			error = SCF_ERROR_NOT_FOUND;
37557c478bd9Sstevel@tonic-gate 			goto error;
37567c478bd9Sstevel@tonic-gate 		}
37577c478bd9Sstevel@tonic-gate 		if (action == REP_PROTOCOL_TX_ENTRY_CLEAR) {
37587c478bd9Sstevel@tonic-gate 			if (property_type_locked(prop_p, &oldtype) == -1) {
37597c478bd9Sstevel@tonic-gate 				error = scf_error();
37607c478bd9Sstevel@tonic-gate 				goto error;
37617c478bd9Sstevel@tonic-gate 			}
37627c478bd9Sstevel@tonic-gate 			if (oldtype != type) {
37637c478bd9Sstevel@tonic-gate 				error = SCF_ERROR_TYPE_MISMATCH;
37647c478bd9Sstevel@tonic-gate 				goto error;
37657c478bd9Sstevel@tonic-gate 			}
37667c478bd9Sstevel@tonic-gate 		}
37677c478bd9Sstevel@tonic-gate 		break;
37687c478bd9Sstevel@tonic-gate 	default:
37697c478bd9Sstevel@tonic-gate 		assert(0);
37707c478bd9Sstevel@tonic-gate 		abort();
37717c478bd9Sstevel@tonic-gate 	}
37727c478bd9Sstevel@tonic-gate 
37737c478bd9Sstevel@tonic-gate 	(void) strlcpy(entry->entry_namebuf, prop,
37747c478bd9Sstevel@tonic-gate 	    sizeof (entry->entry_namebuf));
37757c478bd9Sstevel@tonic-gate 	entry->entry_property = entry->entry_namebuf;
37767c478bd9Sstevel@tonic-gate 	entry->entry_action = action;
37777c478bd9Sstevel@tonic-gate 	entry->entry_type = type;
37787c478bd9Sstevel@tonic-gate 
37797c478bd9Sstevel@tonic-gate 	entry->entry_state = ENTRY_STATE_IN_TX_ACTION;
37807c478bd9Sstevel@tonic-gate 	entry->entry_tx = tran;
37817c478bd9Sstevel@tonic-gate 	uu_list_insert(tran->tran_props, entry, idx);
37827c478bd9Sstevel@tonic-gate 
37837c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
37847c478bd9Sstevel@tonic-gate 
37857c478bd9Sstevel@tonic-gate 	HANDLE_RELE_PROPERTY(h);
37867c478bd9Sstevel@tonic-gate 
37877c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
37887c478bd9Sstevel@tonic-gate 
37897c478bd9Sstevel@tonic-gate error:
37907c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
37917c478bd9Sstevel@tonic-gate 
37927c478bd9Sstevel@tonic-gate 	HANDLE_RELE_PROPERTY(h);
37937c478bd9Sstevel@tonic-gate 
37947c478bd9Sstevel@tonic-gate 	return (scf_set_error(error));
37957c478bd9Sstevel@tonic-gate }
37967c478bd9Sstevel@tonic-gate 
379776cf44abSjeanm /*
379876cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
379976cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
380076cf44abSjeanm  * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
380176cf44abSjeanm  */
38027c478bd9Sstevel@tonic-gate int
38037c478bd9Sstevel@tonic-gate scf_transaction_property_new(scf_transaction_t *tx,
38047c478bd9Sstevel@tonic-gate     scf_transaction_entry_t *entry, const char *prop, scf_type_t type)
38057c478bd9Sstevel@tonic-gate {
38067c478bd9Sstevel@tonic-gate 	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_NEW,
38077c478bd9Sstevel@tonic-gate 	    prop, scf_type_to_protocol_type(type)));
38087c478bd9Sstevel@tonic-gate }
38097c478bd9Sstevel@tonic-gate 
381076cf44abSjeanm /*
381176cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
381276cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
381376cf44abSjeanm  * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
381476cf44abSjeanm  */
38157c478bd9Sstevel@tonic-gate int
38167c478bd9Sstevel@tonic-gate scf_transaction_property_change(scf_transaction_t *tx,
38177c478bd9Sstevel@tonic-gate     scf_transaction_entry_t *entry, const char *prop, scf_type_t type)
38187c478bd9Sstevel@tonic-gate {
38197c478bd9Sstevel@tonic-gate 	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_CLEAR,
38207c478bd9Sstevel@tonic-gate 	    prop, scf_type_to_protocol_type(type)));
38217c478bd9Sstevel@tonic-gate }
38227c478bd9Sstevel@tonic-gate 
382376cf44abSjeanm /*
382476cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
382576cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
382676cf44abSjeanm  * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
382776cf44abSjeanm  */
38287c478bd9Sstevel@tonic-gate int
38297c478bd9Sstevel@tonic-gate scf_transaction_property_change_type(scf_transaction_t *tx,
38307c478bd9Sstevel@tonic-gate     scf_transaction_entry_t *entry, const char *prop, scf_type_t type)
38317c478bd9Sstevel@tonic-gate {
38327c478bd9Sstevel@tonic-gate 	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_REPLACE,
38337c478bd9Sstevel@tonic-gate 	    prop, scf_type_to_protocol_type(type)));
38347c478bd9Sstevel@tonic-gate }
38357c478bd9Sstevel@tonic-gate 
383676cf44abSjeanm /*
383776cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _NOT_BOUND,
383876cf44abSjeanm  * _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED, _NO_RESOURCES,
383976cf44abSjeanm  * _BACKEND_ACCESS, _IN_USE, _NOT_FOUND, _EXISTS, _TYPE_MISMATCH.
384076cf44abSjeanm  */
38417c478bd9Sstevel@tonic-gate int
38427c478bd9Sstevel@tonic-gate scf_transaction_property_delete(scf_transaction_t *tx,
38437c478bd9Sstevel@tonic-gate     scf_transaction_entry_t *entry, const char *prop)
38447c478bd9Sstevel@tonic-gate {
38457c478bd9Sstevel@tonic-gate 	return (transaction_add(tx, entry, REP_PROTOCOL_TX_ENTRY_DELETE,
38467c478bd9Sstevel@tonic-gate 	    prop, REP_PROTOCOL_TYPE_INVALID));
38477c478bd9Sstevel@tonic-gate }
38487c478bd9Sstevel@tonic-gate 
38497c478bd9Sstevel@tonic-gate #define	BAD_SIZE (-1UL)
38507c478bd9Sstevel@tonic-gate 
38517c478bd9Sstevel@tonic-gate static size_t
38527c478bd9Sstevel@tonic-gate commit_value(caddr_t data, scf_value_t *val, rep_protocol_value_type_t t)
38537c478bd9Sstevel@tonic-gate {
38547c478bd9Sstevel@tonic-gate 	size_t len;
38557c478bd9Sstevel@tonic-gate 
38567c478bd9Sstevel@tonic-gate 	assert(val->value_type == t);
38577c478bd9Sstevel@tonic-gate 
38587c478bd9Sstevel@tonic-gate 	if (t == REP_PROTOCOL_TYPE_OPAQUE) {
38597c478bd9Sstevel@tonic-gate 		len = scf_opaque_encode(data, val->value_value,
38607c478bd9Sstevel@tonic-gate 		    val->value_size);
38617c478bd9Sstevel@tonic-gate 	} else {
38627c478bd9Sstevel@tonic-gate 		if (data != NULL)
38637c478bd9Sstevel@tonic-gate 			len = strlcpy(data, val->value_value,
38647c478bd9Sstevel@tonic-gate 			    REP_PROTOCOL_VALUE_LEN);
38657c478bd9Sstevel@tonic-gate 		else
38667c478bd9Sstevel@tonic-gate 			len = strlen(val->value_value);
38677c478bd9Sstevel@tonic-gate 		if (len >= REP_PROTOCOL_VALUE_LEN)
38687c478bd9Sstevel@tonic-gate 			return (BAD_SIZE);
38697c478bd9Sstevel@tonic-gate 	}
38707c478bd9Sstevel@tonic-gate 	return (len + 1);	/* count the '\0' */
38717c478bd9Sstevel@tonic-gate }
38727c478bd9Sstevel@tonic-gate 
38737c478bd9Sstevel@tonic-gate static size_t
38747c478bd9Sstevel@tonic-gate commit_process(scf_transaction_entry_t *cur,
38757c478bd9Sstevel@tonic-gate     struct rep_protocol_transaction_cmd *out)
38767c478bd9Sstevel@tonic-gate {
38777c478bd9Sstevel@tonic-gate 	scf_value_t *child;
38787c478bd9Sstevel@tonic-gate 	size_t sz = 0;
38797c478bd9Sstevel@tonic-gate 	size_t len;
38807c478bd9Sstevel@tonic-gate 	caddr_t data = (caddr_t)out->rptc_data;
38817c478bd9Sstevel@tonic-gate 	caddr_t val_data;
38827c478bd9Sstevel@tonic-gate 
38837c478bd9Sstevel@tonic-gate 	if (out != NULL) {
38847c478bd9Sstevel@tonic-gate 		len = strlcpy(data, cur->entry_property, REP_PROTOCOL_NAME_LEN);
38857c478bd9Sstevel@tonic-gate 
38867c478bd9Sstevel@tonic-gate 		out->rptc_action = cur->entry_action;
38877c478bd9Sstevel@tonic-gate 		out->rptc_type = cur->entry_type;
38887c478bd9Sstevel@tonic-gate 		out->rptc_name_len = len + 1;
38897c478bd9Sstevel@tonic-gate 	} else {
38907c478bd9Sstevel@tonic-gate 		len = strlen(cur->entry_property);
38917c478bd9Sstevel@tonic-gate 	}
38927c478bd9Sstevel@tonic-gate 
38937c478bd9Sstevel@tonic-gate 	if (len >= REP_PROTOCOL_NAME_LEN)
38947c478bd9Sstevel@tonic-gate 		return (BAD_SIZE);
38957c478bd9Sstevel@tonic-gate 
38967c478bd9Sstevel@tonic-gate 	len = TX_SIZE(len + 1);
38977c478bd9Sstevel@tonic-gate 
38987c478bd9Sstevel@tonic-gate 	sz += len;
38997c478bd9Sstevel@tonic-gate 	val_data = data + len;
39007c478bd9Sstevel@tonic-gate 
39017c478bd9Sstevel@tonic-gate 	for (child = cur->entry_head; child != NULL;
39027c478bd9Sstevel@tonic-gate 	    child = child->value_next) {
39037c478bd9Sstevel@tonic-gate 		assert(cur->entry_action != REP_PROTOCOL_TX_ENTRY_DELETE);
39047c478bd9Sstevel@tonic-gate 		if (out != NULL) {
39057c478bd9Sstevel@tonic-gate 			len = commit_value(val_data + sizeof (uint32_t), child,
39067c478bd9Sstevel@tonic-gate 			    cur->entry_type);
39077c478bd9Sstevel@tonic-gate 			/* LINTED alignment */
39087c478bd9Sstevel@tonic-gate 			*(uint32_t *)val_data = len;
39097c478bd9Sstevel@tonic-gate 		} else
39107c478bd9Sstevel@tonic-gate 			len = commit_value(NULL, child, cur->entry_type);
39117c478bd9Sstevel@tonic-gate 
39127c478bd9Sstevel@tonic-gate 		if (len == BAD_SIZE)
39137c478bd9Sstevel@tonic-gate 			return (BAD_SIZE);
39147c478bd9Sstevel@tonic-gate 
39157c478bd9Sstevel@tonic-gate 		len += sizeof (uint32_t);
39167c478bd9Sstevel@tonic-gate 		len = TX_SIZE(len);
39177c478bd9Sstevel@tonic-gate 
39187c478bd9Sstevel@tonic-gate 		sz += len;
39197c478bd9Sstevel@tonic-gate 		val_data += len;
39207c478bd9Sstevel@tonic-gate 	}
39217c478bd9Sstevel@tonic-gate 
39227c478bd9Sstevel@tonic-gate 	assert(val_data - data == sz);
39237c478bd9Sstevel@tonic-gate 
39247c478bd9Sstevel@tonic-gate 	if (out != NULL)
39257c478bd9Sstevel@tonic-gate 		out->rptc_size = REP_PROTOCOL_TRANSACTION_CMD_SIZE(sz);
39267c478bd9Sstevel@tonic-gate 
39277c478bd9Sstevel@tonic-gate 	return (REP_PROTOCOL_TRANSACTION_CMD_SIZE(sz));
39287c478bd9Sstevel@tonic-gate }
39297c478bd9Sstevel@tonic-gate 
39307c478bd9Sstevel@tonic-gate int
39317c478bd9Sstevel@tonic-gate scf_transaction_commit(scf_transaction_t *tran)
39327c478bd9Sstevel@tonic-gate {
39337c478bd9Sstevel@tonic-gate 	scf_handle_t *h = tran->tran_pg.rd_d.rd_handle;
39347c478bd9Sstevel@tonic-gate 
39357c478bd9Sstevel@tonic-gate 	struct rep_protocol_transaction_commit *request;
39367c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
39377c478bd9Sstevel@tonic-gate 	uintptr_t cmd;
39387c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *cur;
39397c478bd9Sstevel@tonic-gate 	size_t total, size;
39407c478bd9Sstevel@tonic-gate 	size_t request_size;
39417c478bd9Sstevel@tonic-gate 	size_t new_total;
39427c478bd9Sstevel@tonic-gate 	int r;
39437c478bd9Sstevel@tonic-gate 
39447c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
39457c478bd9Sstevel@tonic-gate 	if (tran->tran_state != TRAN_STATE_SETUP ||
39467c478bd9Sstevel@tonic-gate 	    tran->tran_invalid) {
39477c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
39487c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
39497c478bd9Sstevel@tonic-gate 	}
39507c478bd9Sstevel@tonic-gate 
39517c478bd9Sstevel@tonic-gate 	total = 0;
39527c478bd9Sstevel@tonic-gate 	for (cur = uu_list_first(tran->tran_props); cur != NULL;
39537c478bd9Sstevel@tonic-gate 	    cur = uu_list_next(tran->tran_props, cur)) {
39547c478bd9Sstevel@tonic-gate 		size = commit_process(cur, NULL);
39557c478bd9Sstevel@tonic-gate 		if (size == BAD_SIZE) {
39567c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&h->rh_lock);
39577c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INTERNAL));
39587c478bd9Sstevel@tonic-gate 		}
39597c478bd9Sstevel@tonic-gate 		assert(TX_SIZE(size) == size);
39607c478bd9Sstevel@tonic-gate 		total += size;
39617c478bd9Sstevel@tonic-gate 	}
39627c478bd9Sstevel@tonic-gate 
39637c478bd9Sstevel@tonic-gate 	request_size = REP_PROTOCOL_TRANSACTION_COMMIT_SIZE(total);
39647c478bd9Sstevel@tonic-gate 	request = alloca(request_size);
39657c478bd9Sstevel@tonic-gate 	(void) memset(request, '\0', request_size);
39667c478bd9Sstevel@tonic-gate 	request->rpr_request = REP_PROTOCOL_PROPERTYGRP_TX_COMMIT;
39677c478bd9Sstevel@tonic-gate 	request->rpr_entityid = tran->tran_pg.rd_d.rd_entity;
39687c478bd9Sstevel@tonic-gate 	request->rpr_size = request_size;
39697c478bd9Sstevel@tonic-gate 	cmd = (uintptr_t)request->rpr_cmd;
39707c478bd9Sstevel@tonic-gate 
39717c478bd9Sstevel@tonic-gate 	datael_finish_reset(&tran->tran_pg.rd_d);
39727c478bd9Sstevel@tonic-gate 
39737c478bd9Sstevel@tonic-gate 	new_total = 0;
39747c478bd9Sstevel@tonic-gate 	for (cur = uu_list_first(tran->tran_props); cur != NULL;
39757c478bd9Sstevel@tonic-gate 	    cur = uu_list_next(tran->tran_props, cur)) {
39767c478bd9Sstevel@tonic-gate 		size = commit_process(cur, (void *)cmd);
39777c478bd9Sstevel@tonic-gate 		if (size == BAD_SIZE) {
39787c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&h->rh_lock);
39797c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INTERNAL));
39807c478bd9Sstevel@tonic-gate 		}
39817c478bd9Sstevel@tonic-gate 		cmd += size;
39827c478bd9Sstevel@tonic-gate 		new_total += size;
39837c478bd9Sstevel@tonic-gate 	}
39847c478bd9Sstevel@tonic-gate 	assert(new_total == total);
39857c478bd9Sstevel@tonic-gate 
39867c478bd9Sstevel@tonic-gate 	r = make_door_call(h, request, request_size,
39877c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
39887c478bd9Sstevel@tonic-gate 
39897c478bd9Sstevel@tonic-gate 	if (r < 0) {
39907c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
39917c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
39927c478bd9Sstevel@tonic-gate 	}
39937c478bd9Sstevel@tonic-gate 
39947c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
39957c478bd9Sstevel@tonic-gate 	    response.rpr_response != REP_PROTOCOL_FAIL_NOT_LATEST) {
39967c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
39977c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
39987c478bd9Sstevel@tonic-gate 	}
39997c478bd9Sstevel@tonic-gate 
40007c478bd9Sstevel@tonic-gate 	tran->tran_state = TRAN_STATE_COMMITTED;
40017c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
40027c478bd9Sstevel@tonic-gate 	return (response.rpr_response == REP_PROTOCOL_SUCCESS);
40037c478bd9Sstevel@tonic-gate }
40047c478bd9Sstevel@tonic-gate 
40057c478bd9Sstevel@tonic-gate static void
40067c478bd9Sstevel@tonic-gate transaction_reset(scf_transaction_t *tran)
40077c478bd9Sstevel@tonic-gate {
40087c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&tran->tran_pg.rd_d.rd_handle->rh_lock));
40097c478bd9Sstevel@tonic-gate 
40107c478bd9Sstevel@tonic-gate 	tran->tran_state = TRAN_STATE_NEW;
40117c478bd9Sstevel@tonic-gate 	datael_reset_locked(&tran->tran_pg.rd_d);
40127c478bd9Sstevel@tonic-gate }
40137c478bd9Sstevel@tonic-gate 
40147c478bd9Sstevel@tonic-gate static void
40157c478bd9Sstevel@tonic-gate scf_transaction_reset_impl(scf_transaction_t *tran, int and_destroy,
40167c478bd9Sstevel@tonic-gate     int and_reset_value)
40177c478bd9Sstevel@tonic-gate {
40187c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *cur;
40197c478bd9Sstevel@tonic-gate 	void *cookie;
40207c478bd9Sstevel@tonic-gate 
40217c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&tran->tran_pg.rd_d.rd_handle->rh_lock);
40227c478bd9Sstevel@tonic-gate 	cookie = NULL;
40237c478bd9Sstevel@tonic-gate 	while ((cur = uu_list_teardown(tran->tran_props, &cookie)) != NULL) {
40247c478bd9Sstevel@tonic-gate 		cur->entry_tx = NULL;
40257c478bd9Sstevel@tonic-gate 
40267c478bd9Sstevel@tonic-gate 		assert(cur->entry_state == ENTRY_STATE_IN_TX_ACTION);
40277c478bd9Sstevel@tonic-gate 		cur->entry_state = ENTRY_STATE_INVALID;
40287c478bd9Sstevel@tonic-gate 
40297c478bd9Sstevel@tonic-gate 		entry_invalidate(cur, and_destroy, and_reset_value);
40307c478bd9Sstevel@tonic-gate 		if (and_destroy)
40317c478bd9Sstevel@tonic-gate 			entry_destroy_locked(cur);
40327c478bd9Sstevel@tonic-gate 	}
40337c478bd9Sstevel@tonic-gate 	transaction_reset(tran);
40347c478bd9Sstevel@tonic-gate 	handle_unrefed(tran->tran_pg.rd_d.rd_handle);
40357c478bd9Sstevel@tonic-gate }
40367c478bd9Sstevel@tonic-gate 
40377c478bd9Sstevel@tonic-gate void
40387c478bd9Sstevel@tonic-gate scf_transaction_reset(scf_transaction_t *tran)
40397c478bd9Sstevel@tonic-gate {
40407c478bd9Sstevel@tonic-gate 	scf_transaction_reset_impl(tran, 0, 0);
40417c478bd9Sstevel@tonic-gate }
40427c478bd9Sstevel@tonic-gate 
40437c478bd9Sstevel@tonic-gate void
40447c478bd9Sstevel@tonic-gate scf_transaction_reset_all(scf_transaction_t *tran)
40457c478bd9Sstevel@tonic-gate {
40467c478bd9Sstevel@tonic-gate 	scf_transaction_reset_impl(tran, 0, 1);
40477c478bd9Sstevel@tonic-gate }
40487c478bd9Sstevel@tonic-gate 
40497c478bd9Sstevel@tonic-gate void
40507c478bd9Sstevel@tonic-gate scf_transaction_destroy(scf_transaction_t *val)
40517c478bd9Sstevel@tonic-gate {
40527c478bd9Sstevel@tonic-gate 	if (val == NULL)
40537c478bd9Sstevel@tonic-gate 		return;
40547c478bd9Sstevel@tonic-gate 
40557c478bd9Sstevel@tonic-gate 	scf_transaction_reset(val);
40567c478bd9Sstevel@tonic-gate 
40577c478bd9Sstevel@tonic-gate 	datael_destroy(&val->tran_pg.rd_d);
40587c478bd9Sstevel@tonic-gate 
40597c478bd9Sstevel@tonic-gate 	uu_list_destroy(val->tran_props);
40607c478bd9Sstevel@tonic-gate 	uu_free(val);
40617c478bd9Sstevel@tonic-gate }
40627c478bd9Sstevel@tonic-gate 
40637c478bd9Sstevel@tonic-gate void
40647c478bd9Sstevel@tonic-gate scf_transaction_destroy_children(scf_transaction_t *tran)
40657c478bd9Sstevel@tonic-gate {
40667c478bd9Sstevel@tonic-gate 	scf_transaction_reset_impl(tran, 1, 0);
40677c478bd9Sstevel@tonic-gate }
40687c478bd9Sstevel@tonic-gate 
40697c478bd9Sstevel@tonic-gate scf_transaction_entry_t *
40707c478bd9Sstevel@tonic-gate scf_entry_create(scf_handle_t *h)
40717c478bd9Sstevel@tonic-gate {
40727c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *ret;
40737c478bd9Sstevel@tonic-gate 
40747c478bd9Sstevel@tonic-gate 	if (h == NULL) {
40757c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
40767c478bd9Sstevel@tonic-gate 		return (NULL);
40777c478bd9Sstevel@tonic-gate 	}
40787c478bd9Sstevel@tonic-gate 
40797c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (scf_transaction_entry_t));
40807c478bd9Sstevel@tonic-gate 	if (ret == NULL) {
40817c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
40827c478bd9Sstevel@tonic-gate 		return (NULL);
40837c478bd9Sstevel@tonic-gate 	}
40847c478bd9Sstevel@tonic-gate 	ret->entry_action = REP_PROTOCOL_TX_ENTRY_INVALID;
40857c478bd9Sstevel@tonic-gate 	ret->entry_handle = h;
40867c478bd9Sstevel@tonic-gate 
40877c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
40887c478bd9Sstevel@tonic-gate 	if (h->rh_flags & HANDLE_DEAD) {
40897c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
40907c478bd9Sstevel@tonic-gate 		uu_free(ret);
40917c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED);
40927c478bd9Sstevel@tonic-gate 		return (NULL);
40937c478bd9Sstevel@tonic-gate 	}
40947c478bd9Sstevel@tonic-gate 	h->rh_entries++;
40957c478bd9Sstevel@tonic-gate 	h->rh_extrefs++;
40967c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
40977c478bd9Sstevel@tonic-gate 
40987c478bd9Sstevel@tonic-gate 	uu_list_node_init(ret, &ret->entry_link, tran_entry_pool);
40997c478bd9Sstevel@tonic-gate 
41007c478bd9Sstevel@tonic-gate 	return (ret);
41017c478bd9Sstevel@tonic-gate }
41027c478bd9Sstevel@tonic-gate 
41037c478bd9Sstevel@tonic-gate scf_handle_t *
41047c478bd9Sstevel@tonic-gate scf_entry_handle(const scf_transaction_entry_t *val)
41057c478bd9Sstevel@tonic-gate {
41067c478bd9Sstevel@tonic-gate 	return (handle_get(val->entry_handle));
41077c478bd9Sstevel@tonic-gate }
41087c478bd9Sstevel@tonic-gate 
41097c478bd9Sstevel@tonic-gate void
41107c478bd9Sstevel@tonic-gate scf_entry_reset(scf_transaction_entry_t *entry)
41117c478bd9Sstevel@tonic-gate {
41127c478bd9Sstevel@tonic-gate 	scf_handle_t *h = entry->entry_handle;
41137c478bd9Sstevel@tonic-gate 
41147c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
41157c478bd9Sstevel@tonic-gate 	entry_invalidate(entry, 0, 0);
41167c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
41177c478bd9Sstevel@tonic-gate }
41187c478bd9Sstevel@tonic-gate 
41197c478bd9Sstevel@tonic-gate void
41207c478bd9Sstevel@tonic-gate scf_entry_destroy_children(scf_transaction_entry_t *entry)
41217c478bd9Sstevel@tonic-gate {
41227c478bd9Sstevel@tonic-gate 	scf_handle_t *h = entry->entry_handle;
41237c478bd9Sstevel@tonic-gate 
41247c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
41257c478bd9Sstevel@tonic-gate 	entry_invalidate(entry, 1, 0);
41267c478bd9Sstevel@tonic-gate 	handle_unrefed(h);			/* drops h->rh_lock */
41277c478bd9Sstevel@tonic-gate }
41287c478bd9Sstevel@tonic-gate 
41297c478bd9Sstevel@tonic-gate void
41307c478bd9Sstevel@tonic-gate scf_entry_destroy(scf_transaction_entry_t *entry)
41317c478bd9Sstevel@tonic-gate {
41327c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
41337c478bd9Sstevel@tonic-gate 
41347c478bd9Sstevel@tonic-gate 	if (entry == NULL)
41357c478bd9Sstevel@tonic-gate 		return;
41367c478bd9Sstevel@tonic-gate 
41377c478bd9Sstevel@tonic-gate 	h = entry->entry_handle;
41387c478bd9Sstevel@tonic-gate 
41397c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
41407c478bd9Sstevel@tonic-gate 	entry_destroy_locked(entry);
41417c478bd9Sstevel@tonic-gate 	handle_unrefed(h);			/* drops h->rh_lock */
41427c478bd9Sstevel@tonic-gate }
41437c478bd9Sstevel@tonic-gate 
41447c478bd9Sstevel@tonic-gate /*
41457c478bd9Sstevel@tonic-gate  * Fails with
41467c478bd9Sstevel@tonic-gate  *   _HANDLE_MISMATCH
41477c478bd9Sstevel@tonic-gate  *   _NOT_SET - has not been added to a transaction
41487c478bd9Sstevel@tonic-gate  *   _INTERNAL - entry is corrupt
41497c478bd9Sstevel@tonic-gate  *   _INVALID_ARGUMENT - entry's transaction is not started or corrupt
41507c478bd9Sstevel@tonic-gate  *			 entry is set to delete a property
41517c478bd9Sstevel@tonic-gate  *			 v is reset or corrupt
41527c478bd9Sstevel@tonic-gate  *   _TYPE_MISMATCH - entry & v's types aren't compatible
41537c478bd9Sstevel@tonic-gate  *   _IN_USE - v has been added to another entry
41547c478bd9Sstevel@tonic-gate  */
41557c478bd9Sstevel@tonic-gate int
41567c478bd9Sstevel@tonic-gate scf_entry_add_value(scf_transaction_entry_t *entry, scf_value_t *v)
41577c478bd9Sstevel@tonic-gate {
41587c478bd9Sstevel@tonic-gate 	scf_handle_t *h = entry->entry_handle;
41597c478bd9Sstevel@tonic-gate 
41607c478bd9Sstevel@tonic-gate 	if (h != v->value_handle)
41617c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
41627c478bd9Sstevel@tonic-gate 
41637c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
41647c478bd9Sstevel@tonic-gate 
41657c478bd9Sstevel@tonic-gate 	if (entry->entry_state == ENTRY_STATE_INVALID) {
41667c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
41677c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
41687c478bd9Sstevel@tonic-gate 	}
4169f2fa366aSjeanm 
4170f2fa366aSjeanm 	if (entry->entry_state != ENTRY_STATE_IN_TX_ACTION) {
4171f2fa366aSjeanm 		(void) pthread_mutex_unlock(&h->rh_lock);
4172f2fa366aSjeanm 		return (scf_set_error(SCF_ERROR_INTERNAL));
4173f2fa366aSjeanm 	}
41747c478bd9Sstevel@tonic-gate 
41757c478bd9Sstevel@tonic-gate 	if (entry->entry_tx->tran_state != TRAN_STATE_SETUP) {
41767c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
41777c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
41787c478bd9Sstevel@tonic-gate 	}
41797c478bd9Sstevel@tonic-gate 
41807c478bd9Sstevel@tonic-gate 	if (entry->entry_action == REP_PROTOCOL_TX_ENTRY_DELETE) {
41817c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
41827c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
41837c478bd9Sstevel@tonic-gate 	}
41847c478bd9Sstevel@tonic-gate 
41857c478bd9Sstevel@tonic-gate 	if (v->value_type == REP_PROTOCOL_TYPE_INVALID) {
41867c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
41877c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
41887c478bd9Sstevel@tonic-gate 	}
41897c478bd9Sstevel@tonic-gate 
41907c478bd9Sstevel@tonic-gate 	if (!scf_is_compatible_type(entry->entry_type, v->value_type)) {
41917c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
41927c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_TYPE_MISMATCH));
41937c478bd9Sstevel@tonic-gate 	}
41947c478bd9Sstevel@tonic-gate 
41957c478bd9Sstevel@tonic-gate 	if (v->value_tx != NULL) {
41967c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
41977c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_IN_USE));
41987c478bd9Sstevel@tonic-gate 	}
41997c478bd9Sstevel@tonic-gate 
42007c478bd9Sstevel@tonic-gate 	v->value_tx = entry;
42016e1d2b42Samaguire 	v->value_next = NULL;
42026e1d2b42Samaguire 	if (entry->entry_head == NULL) {
42036e1d2b42Samaguire 		entry->entry_head = v;
42046e1d2b42Samaguire 		entry->entry_tail = v;
42056e1d2b42Samaguire 	} else {
42066e1d2b42Samaguire 		entry->entry_tail->value_next = v;
42076e1d2b42Samaguire 		entry->entry_tail = v;
42086e1d2b42Samaguire 	}
42096e1d2b42Samaguire 
42107c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
42117c478bd9Sstevel@tonic-gate 
42127c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
42137c478bd9Sstevel@tonic-gate }
42147c478bd9Sstevel@tonic-gate 
42157c478bd9Sstevel@tonic-gate /*
42167c478bd9Sstevel@tonic-gate  * value functions
42177c478bd9Sstevel@tonic-gate  */
42187c478bd9Sstevel@tonic-gate scf_value_t *
42197c478bd9Sstevel@tonic-gate scf_value_create(scf_handle_t *h)
42207c478bd9Sstevel@tonic-gate {
42217c478bd9Sstevel@tonic-gate 	scf_value_t *ret;
42227c478bd9Sstevel@tonic-gate 
42237c478bd9Sstevel@tonic-gate 	if (h == NULL) {
42247c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
42257c478bd9Sstevel@tonic-gate 		return (NULL);
42267c478bd9Sstevel@tonic-gate 	}
42277c478bd9Sstevel@tonic-gate 
42287c478bd9Sstevel@tonic-gate 	ret = uu_zalloc(sizeof (*ret));
42297c478bd9Sstevel@tonic-gate 	if (ret != NULL) {
42307c478bd9Sstevel@tonic-gate 		ret->value_type = REP_PROTOCOL_TYPE_INVALID;
42317c478bd9Sstevel@tonic-gate 		ret->value_handle = h;
42327c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_lock(&h->rh_lock);
42337c478bd9Sstevel@tonic-gate 		if (h->rh_flags & HANDLE_DEAD) {
42347c478bd9Sstevel@tonic-gate 			(void) pthread_mutex_unlock(&h->rh_lock);
42357c478bd9Sstevel@tonic-gate 			uu_free(ret);
4236*1f6eb021SLiane Praza 			(void) scf_set_error(SCF_ERROR_HANDLE_DESTROYED);
42377c478bd9Sstevel@tonic-gate 			return (NULL);
42387c478bd9Sstevel@tonic-gate 		}
42397c478bd9Sstevel@tonic-gate 		h->rh_values++;
42407c478bd9Sstevel@tonic-gate 		h->rh_extrefs++;
42417c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
42427c478bd9Sstevel@tonic-gate 	} else {
42437c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
42447c478bd9Sstevel@tonic-gate 	}
42457c478bd9Sstevel@tonic-gate 
42467c478bd9Sstevel@tonic-gate 	return (ret);
42477c478bd9Sstevel@tonic-gate }
42487c478bd9Sstevel@tonic-gate 
42497c478bd9Sstevel@tonic-gate static void
42507c478bd9Sstevel@tonic-gate scf_value_reset_locked(scf_value_t *val, int and_destroy)
42517c478bd9Sstevel@tonic-gate {
42527c478bd9Sstevel@tonic-gate 	scf_value_t **curp;
42537c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *te;
42547c478bd9Sstevel@tonic-gate 
42557c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
42567c478bd9Sstevel@tonic-gate 	assert(MUTEX_HELD(&h->rh_lock));
42577c478bd9Sstevel@tonic-gate 	if (val->value_tx != NULL) {
42587c478bd9Sstevel@tonic-gate 		te = val->value_tx;
42597c478bd9Sstevel@tonic-gate 		te->entry_tx->tran_invalid = 1;
42607c478bd9Sstevel@tonic-gate 
42617c478bd9Sstevel@tonic-gate 		val->value_tx = NULL;
42627c478bd9Sstevel@tonic-gate 
42637c478bd9Sstevel@tonic-gate 		for (curp = &te->entry_head; *curp != NULL;
42647c478bd9Sstevel@tonic-gate 		    curp = &(*curp)->value_next) {
42657c478bd9Sstevel@tonic-gate 			if (*curp == val) {
42667c478bd9Sstevel@tonic-gate 				*curp = val->value_next;
42677c478bd9Sstevel@tonic-gate 				curp = NULL;
42687c478bd9Sstevel@tonic-gate 				break;
42697c478bd9Sstevel@tonic-gate 			}
42707c478bd9Sstevel@tonic-gate 		}
42717c478bd9Sstevel@tonic-gate 		assert(curp == NULL);
42727c478bd9Sstevel@tonic-gate 	}
42737c478bd9Sstevel@tonic-gate 	val->value_type = REP_PROTOCOL_TYPE_INVALID;
42747c478bd9Sstevel@tonic-gate 
42757c478bd9Sstevel@tonic-gate 	if (and_destroy) {
42767c478bd9Sstevel@tonic-gate 		val->value_handle = NULL;
42777c478bd9Sstevel@tonic-gate 		assert(h->rh_values > 0);
42787c478bd9Sstevel@tonic-gate 		--h->rh_values;
42797c478bd9Sstevel@tonic-gate 		--h->rh_extrefs;
42807c478bd9Sstevel@tonic-gate 		uu_free(val);
42817c478bd9Sstevel@tonic-gate 	}
42827c478bd9Sstevel@tonic-gate }
42837c478bd9Sstevel@tonic-gate 
42847c478bd9Sstevel@tonic-gate void
42857c478bd9Sstevel@tonic-gate scf_value_reset(scf_value_t *val)
42867c478bd9Sstevel@tonic-gate {
42877c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
42887c478bd9Sstevel@tonic-gate 
42897c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
42907c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(val, 0);
42917c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
42927c478bd9Sstevel@tonic-gate }
42937c478bd9Sstevel@tonic-gate 
42947c478bd9Sstevel@tonic-gate scf_handle_t *
42957c478bd9Sstevel@tonic-gate scf_value_handle(const scf_value_t *val)
42967c478bd9Sstevel@tonic-gate {
42977c478bd9Sstevel@tonic-gate 	return (handle_get(val->value_handle));
42987c478bd9Sstevel@tonic-gate }
42997c478bd9Sstevel@tonic-gate 
43007c478bd9Sstevel@tonic-gate void
43017c478bd9Sstevel@tonic-gate scf_value_destroy(scf_value_t *val)
43027c478bd9Sstevel@tonic-gate {
43037c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
43047c478bd9Sstevel@tonic-gate 
43057c478bd9Sstevel@tonic-gate 	if (val == NULL)
43067c478bd9Sstevel@tonic-gate 		return;
43077c478bd9Sstevel@tonic-gate 
43087c478bd9Sstevel@tonic-gate 	h = val->value_handle;
43097c478bd9Sstevel@tonic-gate 
43107c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
43117c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(val, 1);
43127c478bd9Sstevel@tonic-gate 	handle_unrefed(h);			/* drops h->rh_lock */
43137c478bd9Sstevel@tonic-gate }
43147c478bd9Sstevel@tonic-gate 
43157c478bd9Sstevel@tonic-gate scf_type_t
43167c478bd9Sstevel@tonic-gate scf_value_base_type(const scf_value_t *val)
43177c478bd9Sstevel@tonic-gate {
43187c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t t, cur;
43197c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
43207c478bd9Sstevel@tonic-gate 
43217c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
43227c478bd9Sstevel@tonic-gate 	t = val->value_type;
43237c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
43247c478bd9Sstevel@tonic-gate 
43257c478bd9Sstevel@tonic-gate 	for (;;) {
43267c478bd9Sstevel@tonic-gate 		cur = scf_proto_underlying_type(t);
43277c478bd9Sstevel@tonic-gate 		if (cur == t)
43287c478bd9Sstevel@tonic-gate 			break;
43297c478bd9Sstevel@tonic-gate 		t = cur;
43307c478bd9Sstevel@tonic-gate 	}
43317c478bd9Sstevel@tonic-gate 
43327c478bd9Sstevel@tonic-gate 	return (scf_protocol_type_to_type(t));
43337c478bd9Sstevel@tonic-gate }
43347c478bd9Sstevel@tonic-gate 
43357c478bd9Sstevel@tonic-gate scf_type_t
43367c478bd9Sstevel@tonic-gate scf_value_type(const scf_value_t *val)
43377c478bd9Sstevel@tonic-gate {
43387c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t t;
43397c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
43407c478bd9Sstevel@tonic-gate 
43417c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
43427c478bd9Sstevel@tonic-gate 	t = val->value_type;
43437c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
43447c478bd9Sstevel@tonic-gate 
43457c478bd9Sstevel@tonic-gate 	return (scf_protocol_type_to_type(t));
43467c478bd9Sstevel@tonic-gate }
43477c478bd9Sstevel@tonic-gate 
43487c478bd9Sstevel@tonic-gate int
43497c478bd9Sstevel@tonic-gate scf_value_is_type(const scf_value_t *val, scf_type_t base_arg)
43507c478bd9Sstevel@tonic-gate {
43517c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t t;
43527c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t base = scf_type_to_protocol_type(base_arg);
43537c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
43547c478bd9Sstevel@tonic-gate 
43557c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
43567c478bd9Sstevel@tonic-gate 	t = val->value_type;
43577c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
43587c478bd9Sstevel@tonic-gate 
43597c478bd9Sstevel@tonic-gate 	if (t == REP_PROTOCOL_TYPE_INVALID)
43607c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
43617c478bd9Sstevel@tonic-gate 	if (base == REP_PROTOCOL_TYPE_INVALID)
43627c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
43637c478bd9Sstevel@tonic-gate 	if (!scf_is_compatible_type(base, t))
43647c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_TYPE_MISMATCH));
43657c478bd9Sstevel@tonic-gate 
43667c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
43677c478bd9Sstevel@tonic-gate }
43687c478bd9Sstevel@tonic-gate 
43697c478bd9Sstevel@tonic-gate /*
43707c478bd9Sstevel@tonic-gate  * Fails with
43717c478bd9Sstevel@tonic-gate  *   _NOT_SET - val is reset
43727c478bd9Sstevel@tonic-gate  *   _TYPE_MISMATCH - val's type is not compatible with t
43737c478bd9Sstevel@tonic-gate  */
43747c478bd9Sstevel@tonic-gate static int
43757c478bd9Sstevel@tonic-gate scf_value_check_type(const scf_value_t *val, rep_protocol_value_type_t t)
43767c478bd9Sstevel@tonic-gate {
43777c478bd9Sstevel@tonic-gate 	if (val->value_type == REP_PROTOCOL_TYPE_INVALID) {
43787c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_SET);
43797c478bd9Sstevel@tonic-gate 		return (0);
43807c478bd9Sstevel@tonic-gate 	}
43817c478bd9Sstevel@tonic-gate 	if (!scf_is_compatible_type(t, val->value_type)) {
43827c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_TYPE_MISMATCH);
43837c478bd9Sstevel@tonic-gate 		return (0);
43847c478bd9Sstevel@tonic-gate 	}
43857c478bd9Sstevel@tonic-gate 	return (1);
43867c478bd9Sstevel@tonic-gate }
43877c478bd9Sstevel@tonic-gate 
43887c478bd9Sstevel@tonic-gate /*
43897c478bd9Sstevel@tonic-gate  * Fails with
43907c478bd9Sstevel@tonic-gate  *   _NOT_SET - val is reset
43917c478bd9Sstevel@tonic-gate  *   _TYPE_MISMATCH - val is not _TYPE_BOOLEAN
43927c478bd9Sstevel@tonic-gate  */
43937c478bd9Sstevel@tonic-gate int
43947c478bd9Sstevel@tonic-gate scf_value_get_boolean(const scf_value_t *val, uint8_t *out)
43957c478bd9Sstevel@tonic-gate {
43967c478bd9Sstevel@tonic-gate 	char c;
43977c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
43987c478bd9Sstevel@tonic-gate 	uint8_t o;
43997c478bd9Sstevel@tonic-gate 
44007c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
44017c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_BOOLEAN)) {
44027c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
44037c478bd9Sstevel@tonic-gate 		return (-1);
44047c478bd9Sstevel@tonic-gate 	}
44057c478bd9Sstevel@tonic-gate 
44067c478bd9Sstevel@tonic-gate 	c = val->value_value[0];
44077c478bd9Sstevel@tonic-gate 	assert((c == '0' || c == '1') && val->value_value[1] == 0);
44087c478bd9Sstevel@tonic-gate 
44097c478bd9Sstevel@tonic-gate 	o = (c != '0');
44107c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
44117c478bd9Sstevel@tonic-gate 	if (out != NULL)
44127c478bd9Sstevel@tonic-gate 		*out = o;
44137c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
44147c478bd9Sstevel@tonic-gate }
44157c478bd9Sstevel@tonic-gate 
44167c478bd9Sstevel@tonic-gate int
44177c478bd9Sstevel@tonic-gate scf_value_get_count(const scf_value_t *val, uint64_t *out)
44187c478bd9Sstevel@tonic-gate {
44197c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
44207c478bd9Sstevel@tonic-gate 	uint64_t o;
44217c478bd9Sstevel@tonic-gate 
44227c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
44237c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_COUNT)) {
44247c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
44257c478bd9Sstevel@tonic-gate 		return (-1);
44267c478bd9Sstevel@tonic-gate 	}
44277c478bd9Sstevel@tonic-gate 
44287c478bd9Sstevel@tonic-gate 	o = strtoull(val->value_value, NULL, 10);
44297c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
44307c478bd9Sstevel@tonic-gate 	if (out != NULL)
44317c478bd9Sstevel@tonic-gate 		*out = o;
44327c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
44337c478bd9Sstevel@tonic-gate }
44347c478bd9Sstevel@tonic-gate 
44357c478bd9Sstevel@tonic-gate int
44367c478bd9Sstevel@tonic-gate scf_value_get_integer(const scf_value_t *val, int64_t *out)
44377c478bd9Sstevel@tonic-gate {
44387c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
44397c478bd9Sstevel@tonic-gate 	int64_t o;
44407c478bd9Sstevel@tonic-gate 
44417c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
44427c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_INTEGER)) {
44437c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
44447c478bd9Sstevel@tonic-gate 		return (-1);
44457c478bd9Sstevel@tonic-gate 	}
44467c478bd9Sstevel@tonic-gate 
44477c478bd9Sstevel@tonic-gate 	o = strtoll(val->value_value, NULL, 10);
44487c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
44497c478bd9Sstevel@tonic-gate 	if (out != NULL)
44507c478bd9Sstevel@tonic-gate 		*out = o;
44517c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
44527c478bd9Sstevel@tonic-gate }
44537c478bd9Sstevel@tonic-gate 
44547c478bd9Sstevel@tonic-gate int
44557c478bd9Sstevel@tonic-gate scf_value_get_time(const scf_value_t *val, int64_t *sec_out, int32_t *nsec_out)
44567c478bd9Sstevel@tonic-gate {
44577c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
44587c478bd9Sstevel@tonic-gate 	char *p;
44597c478bd9Sstevel@tonic-gate 	int64_t os;
44607c478bd9Sstevel@tonic-gate 	int32_t ons;
44617c478bd9Sstevel@tonic-gate 
44627c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
44637c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_TIME)) {
44647c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
44657c478bd9Sstevel@tonic-gate 		return (-1);
44667c478bd9Sstevel@tonic-gate 	}
44677c478bd9Sstevel@tonic-gate 
44687c478bd9Sstevel@tonic-gate 	os = strtoll(val->value_value, &p, 10);
44697c478bd9Sstevel@tonic-gate 	if (*p == '.')
44707c478bd9Sstevel@tonic-gate 		ons = strtoul(p + 1, NULL, 10);
44717c478bd9Sstevel@tonic-gate 	else
44727c478bd9Sstevel@tonic-gate 		ons = 0;
44737c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
44747c478bd9Sstevel@tonic-gate 	if (sec_out != NULL)
44757c478bd9Sstevel@tonic-gate 		*sec_out = os;
44767c478bd9Sstevel@tonic-gate 	if (nsec_out != NULL)
44777c478bd9Sstevel@tonic-gate 		*nsec_out = ons;
44787c478bd9Sstevel@tonic-gate 
44797c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
44807c478bd9Sstevel@tonic-gate }
44817c478bd9Sstevel@tonic-gate 
44827c478bd9Sstevel@tonic-gate /*
44837c478bd9Sstevel@tonic-gate  * Fails with
44847c478bd9Sstevel@tonic-gate  *   _NOT_SET - val is reset
44857c478bd9Sstevel@tonic-gate  *   _TYPE_MISMATCH - val's type is not compatible with _TYPE_STRING.
44867c478bd9Sstevel@tonic-gate  */
44877c478bd9Sstevel@tonic-gate ssize_t
44887c478bd9Sstevel@tonic-gate scf_value_get_astring(const scf_value_t *val, char *out, size_t len)
44897c478bd9Sstevel@tonic-gate {
44907c478bd9Sstevel@tonic-gate 	ssize_t ret;
44917c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
44927c478bd9Sstevel@tonic-gate 
44937c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
44947c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(val, REP_PROTOCOL_TYPE_STRING)) {
44957c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
44967c478bd9Sstevel@tonic-gate 		return ((ssize_t)-1);
44977c478bd9Sstevel@tonic-gate 	}
44987c478bd9Sstevel@tonic-gate 	ret = (ssize_t)strlcpy(out, val->value_value, len);
44997c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45007c478bd9Sstevel@tonic-gate 	return (ret);
45017c478bd9Sstevel@tonic-gate }
45027c478bd9Sstevel@tonic-gate 
45037c478bd9Sstevel@tonic-gate ssize_t
45047c478bd9Sstevel@tonic-gate scf_value_get_ustring(const scf_value_t *val, char *out, size_t len)
45057c478bd9Sstevel@tonic-gate {
45067c478bd9Sstevel@tonic-gate 	ssize_t ret;
45077c478bd9Sstevel@tonic-gate 	scf_handle_t *h = val->value_handle;
45087c478bd9Sstevel@tonic-gate 
45097c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
45107c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(val, REP_PROTOCOL_SUBTYPE_USTRING)) {
45117c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
45127c478bd9Sstevel@tonic-gate 		return ((ssize_t)-1);
45137c478bd9Sstevel@tonic-gate 	}
45147c478bd9Sstevel@tonic-gate 	ret = (ssize_t)strlcpy(out, val->value_value, len);
45157c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45167c478bd9Sstevel@tonic-gate 	return (ret);
45177c478bd9Sstevel@tonic-gate }
45187c478bd9Sstevel@tonic-gate 
45197c478bd9Sstevel@tonic-gate ssize_t
45207c478bd9Sstevel@tonic-gate scf_value_get_opaque(const scf_value_t *v, void *out, size_t len)
45217c478bd9Sstevel@tonic-gate {
45227c478bd9Sstevel@tonic-gate 	ssize_t ret;
45237c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
45247c478bd9Sstevel@tonic-gate 
45257c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
45267c478bd9Sstevel@tonic-gate 	if (!scf_value_check_type(v, REP_PROTOCOL_TYPE_OPAQUE)) {
45277c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
45287c478bd9Sstevel@tonic-gate 		return ((ssize_t)-1);
45297c478bd9Sstevel@tonic-gate 	}
45307c478bd9Sstevel@tonic-gate 	if (len > v->value_size)
45317c478bd9Sstevel@tonic-gate 		len = v->value_size;
45327c478bd9Sstevel@tonic-gate 	ret = len;
45337c478bd9Sstevel@tonic-gate 
45347c478bd9Sstevel@tonic-gate 	(void) memcpy(out, v->value_value, len);
45357c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45367c478bd9Sstevel@tonic-gate 	return (ret);
45377c478bd9Sstevel@tonic-gate }
45387c478bd9Sstevel@tonic-gate 
45397c478bd9Sstevel@tonic-gate void
45407c478bd9Sstevel@tonic-gate scf_value_set_boolean(scf_value_t *v, uint8_t new)
45417c478bd9Sstevel@tonic-gate {
45427c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
45437c478bd9Sstevel@tonic-gate 
45447c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
45457c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
45467c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_TYPE_BOOLEAN;
45477c478bd9Sstevel@tonic-gate 	(void) sprintf(v->value_value, "%d", (new != 0));
45487c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45497c478bd9Sstevel@tonic-gate }
45507c478bd9Sstevel@tonic-gate 
45517c478bd9Sstevel@tonic-gate void
45527c478bd9Sstevel@tonic-gate scf_value_set_count(scf_value_t *v, uint64_t new)
45537c478bd9Sstevel@tonic-gate {
45547c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
45557c478bd9Sstevel@tonic-gate 
45567c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
45577c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
45587c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_TYPE_COUNT;
45597c478bd9Sstevel@tonic-gate 	(void) sprintf(v->value_value, "%llu", (unsigned long long)new);
45607c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45617c478bd9Sstevel@tonic-gate }
45627c478bd9Sstevel@tonic-gate 
45637c478bd9Sstevel@tonic-gate void
45647c478bd9Sstevel@tonic-gate scf_value_set_integer(scf_value_t *v, int64_t new)
45657c478bd9Sstevel@tonic-gate {
45667c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
45677c478bd9Sstevel@tonic-gate 
45687c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
45697c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
45707c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_TYPE_INTEGER;
45717c478bd9Sstevel@tonic-gate 	(void) sprintf(v->value_value, "%lld", (long long)new);
45727c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45737c478bd9Sstevel@tonic-gate }
45747c478bd9Sstevel@tonic-gate 
45757c478bd9Sstevel@tonic-gate int
45767c478bd9Sstevel@tonic-gate scf_value_set_time(scf_value_t *v, int64_t new_sec, int32_t new_nsec)
45777c478bd9Sstevel@tonic-gate {
45787c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
45797c478bd9Sstevel@tonic-gate 
45807c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
45817c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
45827c478bd9Sstevel@tonic-gate 	if (new_nsec < 0 || new_nsec >= NANOSEC) {
45837c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
45847c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
45857c478bd9Sstevel@tonic-gate 	}
45867c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_TYPE_TIME;
45877c478bd9Sstevel@tonic-gate 	if (new_nsec == 0)
45887c478bd9Sstevel@tonic-gate 		(void) sprintf(v->value_value, "%lld", (long long)new_sec);
45897c478bd9Sstevel@tonic-gate 	else
45907c478bd9Sstevel@tonic-gate 		(void) sprintf(v->value_value, "%lld.%09u", (long long)new_sec,
45917c478bd9Sstevel@tonic-gate 		    (unsigned)new_nsec);
45927c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
45937c478bd9Sstevel@tonic-gate 	return (0);
45947c478bd9Sstevel@tonic-gate }
45957c478bd9Sstevel@tonic-gate 
45967c478bd9Sstevel@tonic-gate int
45977c478bd9Sstevel@tonic-gate scf_value_set_astring(scf_value_t *v, const char *new)
45987c478bd9Sstevel@tonic-gate {
45997c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
46007c478bd9Sstevel@tonic-gate 
46017c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
46027c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
46037c478bd9Sstevel@tonic-gate 	if (!scf_validate_encoded_value(REP_PROTOCOL_TYPE_STRING, new)) {
46047c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
46057c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
46067c478bd9Sstevel@tonic-gate 	}
46077c478bd9Sstevel@tonic-gate 	if (strlcpy(v->value_value, new, sizeof (v->value_value)) >=
46087c478bd9Sstevel@tonic-gate 	    sizeof (v->value_value)) {
46097c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
46107c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
46117c478bd9Sstevel@tonic-gate 	}
46127c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_TYPE_STRING;
46137c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
46147c478bd9Sstevel@tonic-gate 	return (0);
46157c478bd9Sstevel@tonic-gate }
46167c478bd9Sstevel@tonic-gate 
46177c478bd9Sstevel@tonic-gate int
46187c478bd9Sstevel@tonic-gate scf_value_set_ustring(scf_value_t *v, const char *new)
46197c478bd9Sstevel@tonic-gate {
46207c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
46217c478bd9Sstevel@tonic-gate 
46227c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
46237c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
46247c478bd9Sstevel@tonic-gate 	if (!scf_validate_encoded_value(REP_PROTOCOL_SUBTYPE_USTRING, new)) {
46257c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
46267c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
46277c478bd9Sstevel@tonic-gate 	}
46287c478bd9Sstevel@tonic-gate 	if (strlcpy(v->value_value, new, sizeof (v->value_value)) >=
46297c478bd9Sstevel@tonic-gate 	    sizeof (v->value_value)) {
46307c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
46317c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
46327c478bd9Sstevel@tonic-gate 	}
46337c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_SUBTYPE_USTRING;
46347c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
46357c478bd9Sstevel@tonic-gate 	return (0);
46367c478bd9Sstevel@tonic-gate }
46377c478bd9Sstevel@tonic-gate 
46387c478bd9Sstevel@tonic-gate int
46397c478bd9Sstevel@tonic-gate scf_value_set_opaque(scf_value_t *v, const void *new, size_t len)
46407c478bd9Sstevel@tonic-gate {
46417c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
46427c478bd9Sstevel@tonic-gate 
46437c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
46447c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
46457c478bd9Sstevel@tonic-gate 	if (len > sizeof (v->value_value)) {
46467c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
46477c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
46487c478bd9Sstevel@tonic-gate 	}
46497c478bd9Sstevel@tonic-gate 	(void) memcpy(v->value_value, new, len);
46507c478bd9Sstevel@tonic-gate 	v->value_size = len;
46517c478bd9Sstevel@tonic-gate 	v->value_type = REP_PROTOCOL_TYPE_OPAQUE;
46527c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
46537c478bd9Sstevel@tonic-gate 	return (0);
46547c478bd9Sstevel@tonic-gate }
46557c478bd9Sstevel@tonic-gate 
46567c478bd9Sstevel@tonic-gate /*
46577c478bd9Sstevel@tonic-gate  * Fails with
46587c478bd9Sstevel@tonic-gate  *   _NOT_SET - v_arg is reset
46597c478bd9Sstevel@tonic-gate  *   _INTERNAL - v_arg is corrupt
46607c478bd9Sstevel@tonic-gate  *
46617c478bd9Sstevel@tonic-gate  * If t is not _TYPE_INVALID, fails with
46627c478bd9Sstevel@tonic-gate  *   _TYPE_MISMATCH - v_arg's type is not compatible with t
46637c478bd9Sstevel@tonic-gate  */
46647c478bd9Sstevel@tonic-gate static ssize_t
46657c478bd9Sstevel@tonic-gate scf_value_get_as_string_common(const scf_value_t *v_arg,
46667c478bd9Sstevel@tonic-gate     rep_protocol_value_type_t t, char *buf, size_t bufsz)
46677c478bd9Sstevel@tonic-gate {
46687c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v_arg->value_handle;
46697c478bd9Sstevel@tonic-gate 	scf_value_t v_s;
46707c478bd9Sstevel@tonic-gate 	scf_value_t *v = &v_s;
46717c478bd9Sstevel@tonic-gate 	ssize_t r;
46727c478bd9Sstevel@tonic-gate 	uint8_t b;
46737c478bd9Sstevel@tonic-gate 
46747c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
46757c478bd9Sstevel@tonic-gate 	if (t != REP_PROTOCOL_TYPE_INVALID && !scf_value_check_type(v_arg, t)) {
46767c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
46777c478bd9Sstevel@tonic-gate 		return (-1);
46787c478bd9Sstevel@tonic-gate 	}
46797c478bd9Sstevel@tonic-gate 
46807c478bd9Sstevel@tonic-gate 	v_s = *v_arg;			/* copy locally so we can unlock */
46817c478bd9Sstevel@tonic-gate 	h->rh_values++;			/* keep the handle from going away */
46827c478bd9Sstevel@tonic-gate 	h->rh_extrefs++;
46837c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
46847c478bd9Sstevel@tonic-gate 
46857c478bd9Sstevel@tonic-gate 
46867c478bd9Sstevel@tonic-gate 	switch (REP_PROTOCOL_BASE_TYPE(v->value_type)) {
46877c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_BOOLEAN:
46887c478bd9Sstevel@tonic-gate 		r = scf_value_get_boolean(v, &b);
46897c478bd9Sstevel@tonic-gate 		assert(r == SCF_SUCCESS);
46907c478bd9Sstevel@tonic-gate 
46917c478bd9Sstevel@tonic-gate 		r = strlcpy(buf, b ? "true" : "false", bufsz);
46927c478bd9Sstevel@tonic-gate 		break;
46937c478bd9Sstevel@tonic-gate 
46947c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_COUNT:
46957c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_INTEGER:
46967c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_TIME:
46977c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_STRING:
46987c478bd9Sstevel@tonic-gate 		r = strlcpy(buf, v->value_value, bufsz);
46997c478bd9Sstevel@tonic-gate 		break;
47007c478bd9Sstevel@tonic-gate 
47017c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_OPAQUE:
47027c478bd9Sstevel@tonic-gate 		/*
47037c478bd9Sstevel@tonic-gate 		 * Note that we only write out full hex bytes -- if they're
47047c478bd9Sstevel@tonic-gate 		 * short, and bufsz is even, we'll only fill (bufsz - 2) bytes
47057c478bd9Sstevel@tonic-gate 		 * with data.
47067c478bd9Sstevel@tonic-gate 		 */
47077c478bd9Sstevel@tonic-gate 		if (bufsz > 0)
47087c478bd9Sstevel@tonic-gate 			(void) scf_opaque_encode(buf, v->value_value,
47097c478bd9Sstevel@tonic-gate 			    MIN(v->value_size, (bufsz - 1)/2));
47107c478bd9Sstevel@tonic-gate 		r = (v->value_size * 2);
47117c478bd9Sstevel@tonic-gate 		break;
47127c478bd9Sstevel@tonic-gate 
47137c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_INVALID:
47147c478bd9Sstevel@tonic-gate 		r = scf_set_error(SCF_ERROR_NOT_SET);
47157c478bd9Sstevel@tonic-gate 		break;
47167c478bd9Sstevel@tonic-gate 
47177c478bd9Sstevel@tonic-gate 	default:
47187c478bd9Sstevel@tonic-gate 		r = (scf_set_error(SCF_ERROR_INTERNAL));
47197c478bd9Sstevel@tonic-gate 		break;
47207c478bd9Sstevel@tonic-gate 	}
47217c478bd9Sstevel@tonic-gate 
47227c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
47237c478bd9Sstevel@tonic-gate 	h->rh_values--;
47247c478bd9Sstevel@tonic-gate 	h->rh_extrefs--;
47257c478bd9Sstevel@tonic-gate 	handle_unrefed(h);
47267c478bd9Sstevel@tonic-gate 
47277c478bd9Sstevel@tonic-gate 	return (r);
47287c478bd9Sstevel@tonic-gate }
47297c478bd9Sstevel@tonic-gate 
47307c478bd9Sstevel@tonic-gate ssize_t
47317c478bd9Sstevel@tonic-gate scf_value_get_as_string(const scf_value_t *v, char *buf, size_t bufsz)
47327c478bd9Sstevel@tonic-gate {
47337c478bd9Sstevel@tonic-gate 	return (scf_value_get_as_string_common(v, REP_PROTOCOL_TYPE_INVALID,
47347c478bd9Sstevel@tonic-gate 	    buf, bufsz));
47357c478bd9Sstevel@tonic-gate }
47367c478bd9Sstevel@tonic-gate 
47377c478bd9Sstevel@tonic-gate ssize_t
47387c478bd9Sstevel@tonic-gate scf_value_get_as_string_typed(const scf_value_t *v, scf_type_t type,
47397c478bd9Sstevel@tonic-gate     char *buf, size_t bufsz)
47407c478bd9Sstevel@tonic-gate {
47417c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t ty = scf_type_to_protocol_type(type);
47427c478bd9Sstevel@tonic-gate 	if (ty == REP_PROTOCOL_TYPE_INVALID)
47437c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
47447c478bd9Sstevel@tonic-gate 
47457c478bd9Sstevel@tonic-gate 	return (scf_value_get_as_string_common(v, ty, buf, bufsz));
47467c478bd9Sstevel@tonic-gate }
47477c478bd9Sstevel@tonic-gate 
47487c478bd9Sstevel@tonic-gate int
47497c478bd9Sstevel@tonic-gate scf_value_set_from_string(scf_value_t *v, scf_type_t type, const char *str)
47507c478bd9Sstevel@tonic-gate {
47517c478bd9Sstevel@tonic-gate 	scf_handle_t *h = v->value_handle;
47527c478bd9Sstevel@tonic-gate 	rep_protocol_value_type_t ty;
47537c478bd9Sstevel@tonic-gate 
47547c478bd9Sstevel@tonic-gate 	switch (type) {
47557c478bd9Sstevel@tonic-gate 	case SCF_TYPE_BOOLEAN: {
47567c478bd9Sstevel@tonic-gate 		uint8_t b;
47577c478bd9Sstevel@tonic-gate 
47587c478bd9Sstevel@tonic-gate 		if (strcmp(str, "true") == 0 || strcmp(str, "t") == 0 ||
47597c478bd9Sstevel@tonic-gate 		    strcmp(str, "1") == 0)
47607c478bd9Sstevel@tonic-gate 			b = 1;
47617c478bd9Sstevel@tonic-gate 		else if (strcmp(str, "false") == 0 ||
47627c478bd9Sstevel@tonic-gate 		    strcmp(str, "f") == 0 || strcmp(str, "0") == 0)
47637c478bd9Sstevel@tonic-gate 			b = 0;
47647c478bd9Sstevel@tonic-gate 		else {
47657c478bd9Sstevel@tonic-gate 			goto bad;
47667c478bd9Sstevel@tonic-gate 		}
47677c478bd9Sstevel@tonic-gate 
47687c478bd9Sstevel@tonic-gate 		scf_value_set_boolean(v, b);
47697c478bd9Sstevel@tonic-gate 		return (0);
47707c478bd9Sstevel@tonic-gate 	}
47717c478bd9Sstevel@tonic-gate 
47727c478bd9Sstevel@tonic-gate 	case SCF_TYPE_COUNT: {
47737c478bd9Sstevel@tonic-gate 		uint64_t c;
47747c478bd9Sstevel@tonic-gate 		char *endp;
47757c478bd9Sstevel@tonic-gate 
47767c478bd9Sstevel@tonic-gate 		errno = 0;
4777f2fa366aSjeanm 		c = strtoull(str, &endp, 0);
47787c478bd9Sstevel@tonic-gate 
47797c478bd9Sstevel@tonic-gate 		if (errno != 0 || endp == str || *endp != '\0')
47807c478bd9Sstevel@tonic-gate 			goto bad;
47817c478bd9Sstevel@tonic-gate 
47827c478bd9Sstevel@tonic-gate 		scf_value_set_count(v, c);
47837c478bd9Sstevel@tonic-gate 		return (0);
47847c478bd9Sstevel@tonic-gate 	}
47857c478bd9Sstevel@tonic-gate 
47867c478bd9Sstevel@tonic-gate 	case SCF_TYPE_INTEGER: {
47877c478bd9Sstevel@tonic-gate 		int64_t i;
47887c478bd9Sstevel@tonic-gate 		char *endp;
47897c478bd9Sstevel@tonic-gate 
47907c478bd9Sstevel@tonic-gate 		errno = 0;
4791f2fa366aSjeanm 		i = strtoll(str, &endp, 0);
47927c478bd9Sstevel@tonic-gate 
47937c478bd9Sstevel@tonic-gate 		if (errno != 0 || endp == str || *endp != '\0')
47947c478bd9Sstevel@tonic-gate 			goto bad;
47957c478bd9Sstevel@tonic-gate 
47967c478bd9Sstevel@tonic-gate 		scf_value_set_integer(v, i);
47977c478bd9Sstevel@tonic-gate 		return (0);
47987c478bd9Sstevel@tonic-gate 	}
47997c478bd9Sstevel@tonic-gate 
48007c478bd9Sstevel@tonic-gate 	case SCF_TYPE_TIME: {
48017c478bd9Sstevel@tonic-gate 		int64_t s;
48027c478bd9Sstevel@tonic-gate 		uint32_t ns = 0;
48037c478bd9Sstevel@tonic-gate 		char *endp, *ns_str;
48047c478bd9Sstevel@tonic-gate 		size_t len;
48057c478bd9Sstevel@tonic-gate 
48067c478bd9Sstevel@tonic-gate 		errno = 0;
48077c478bd9Sstevel@tonic-gate 		s = strtoll(str, &endp, 10);
48087c478bd9Sstevel@tonic-gate 		if (errno != 0 || endp == str ||
48097c478bd9Sstevel@tonic-gate 		    (*endp != '\0' && *endp != '.'))
48107c478bd9Sstevel@tonic-gate 			goto bad;
48117c478bd9Sstevel@tonic-gate 
48127c478bd9Sstevel@tonic-gate 		if (*endp == '.') {
48137c478bd9Sstevel@tonic-gate 			ns_str = endp + 1;
48147c478bd9Sstevel@tonic-gate 			len = strlen(ns_str);
48157c478bd9Sstevel@tonic-gate 			if (len == 0 || len > 9)
48167c478bd9Sstevel@tonic-gate 				goto bad;
48177c478bd9Sstevel@tonic-gate 
48187c478bd9Sstevel@tonic-gate 			ns = strtoul(ns_str, &endp, 10);
48197c478bd9Sstevel@tonic-gate 			if (errno != 0 || endp == ns_str || *endp != '\0')
48207c478bd9Sstevel@tonic-gate 				goto bad;
48217c478bd9Sstevel@tonic-gate 
48227c478bd9Sstevel@tonic-gate 			while (len++ < 9)
48237c478bd9Sstevel@tonic-gate 				ns *= 10;
48247c478bd9Sstevel@tonic-gate 			assert(ns < NANOSEC);
48257c478bd9Sstevel@tonic-gate 		}
48267c478bd9Sstevel@tonic-gate 
48277c478bd9Sstevel@tonic-gate 		return (scf_value_set_time(v, s, ns));
48287c478bd9Sstevel@tonic-gate 	}
48297c478bd9Sstevel@tonic-gate 
48307c478bd9Sstevel@tonic-gate 	case SCF_TYPE_ASTRING:
48317c478bd9Sstevel@tonic-gate 	case SCF_TYPE_USTRING:
48327c478bd9Sstevel@tonic-gate 	case SCF_TYPE_OPAQUE:
48337c478bd9Sstevel@tonic-gate 	case SCF_TYPE_URI:
48347c478bd9Sstevel@tonic-gate 	case SCF_TYPE_FMRI:
48357c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOST:
48367c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOSTNAME:
48377c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V4:
48387c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V6:
48397c478bd9Sstevel@tonic-gate 		ty = scf_type_to_protocol_type(type);
48407c478bd9Sstevel@tonic-gate 
48417c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_lock(&h->rh_lock);
48427c478bd9Sstevel@tonic-gate 		scf_value_reset_locked(v, 0);
48437c478bd9Sstevel@tonic-gate 		if (type == SCF_TYPE_OPAQUE) {
48447c478bd9Sstevel@tonic-gate 			v->value_size = scf_opaque_decode(v->value_value,
48457c478bd9Sstevel@tonic-gate 			    str, sizeof (v->value_value));
48467c478bd9Sstevel@tonic-gate 			if (!scf_validate_encoded_value(ty, str)) {
48477c478bd9Sstevel@tonic-gate 				(void) pthread_mutex_lock(&h->rh_lock);
48487c478bd9Sstevel@tonic-gate 				goto bad;
48497c478bd9Sstevel@tonic-gate 			}
48507c478bd9Sstevel@tonic-gate 		} else {
48517c478bd9Sstevel@tonic-gate 			(void) strlcpy(v->value_value, str,
48527c478bd9Sstevel@tonic-gate 			    sizeof (v->value_value));
48537c478bd9Sstevel@tonic-gate 			if (!scf_validate_encoded_value(ty, v->value_value)) {
48547c478bd9Sstevel@tonic-gate 				(void) pthread_mutex_lock(&h->rh_lock);
48557c478bd9Sstevel@tonic-gate 				goto bad;
48567c478bd9Sstevel@tonic-gate 			}
48577c478bd9Sstevel@tonic-gate 		}
48587c478bd9Sstevel@tonic-gate 		v->value_type = ty;
48597c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
48607c478bd9Sstevel@tonic-gate 		return (SCF_SUCCESS);
48617c478bd9Sstevel@tonic-gate 
48627c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_TYPE_INVALID:
48637c478bd9Sstevel@tonic-gate 	default:
48647c478bd9Sstevel@tonic-gate 		scf_value_reset(v);
48657c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_TYPE_MISMATCH));
48667c478bd9Sstevel@tonic-gate 	}
48677c478bd9Sstevel@tonic-gate bad:
48687c478bd9Sstevel@tonic-gate 	scf_value_reset(v);
48697c478bd9Sstevel@tonic-gate 	return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
48707c478bd9Sstevel@tonic-gate }
48717c478bd9Sstevel@tonic-gate 
48727c478bd9Sstevel@tonic-gate int
48737c478bd9Sstevel@tonic-gate scf_iter_property_values(scf_iter_t *iter, const scf_property_t *prop)
48747c478bd9Sstevel@tonic-gate {
48757c478bd9Sstevel@tonic-gate 	return (datael_setup_iter(iter, &prop->rd_d,
48767c478bd9Sstevel@tonic-gate 	    REP_PROTOCOL_ENTITY_VALUE, 0));
48777c478bd9Sstevel@tonic-gate }
48787c478bd9Sstevel@tonic-gate 
48797c478bd9Sstevel@tonic-gate int
48807c478bd9Sstevel@tonic-gate scf_iter_next_value(scf_iter_t *iter, scf_value_t *v)
48817c478bd9Sstevel@tonic-gate {
48827c478bd9Sstevel@tonic-gate 	scf_handle_t *h = iter->iter_handle;
48837c478bd9Sstevel@tonic-gate 
48847c478bd9Sstevel@tonic-gate 	struct rep_protocol_iter_read_value request;
48857c478bd9Sstevel@tonic-gate 	struct rep_protocol_value_response response;
48867c478bd9Sstevel@tonic-gate 
48877c478bd9Sstevel@tonic-gate 	int r;
48887c478bd9Sstevel@tonic-gate 
48897c478bd9Sstevel@tonic-gate 	if (h != v->value_handle)
48907c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
48917c478bd9Sstevel@tonic-gate 
48927c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
48937c478bd9Sstevel@tonic-gate 
48947c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
48957c478bd9Sstevel@tonic-gate 
48967c478bd9Sstevel@tonic-gate 	if (iter->iter_type == REP_PROTOCOL_ENTITY_NONE) {
48977c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
48987c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
48997c478bd9Sstevel@tonic-gate 	}
49007c478bd9Sstevel@tonic-gate 
49017c478bd9Sstevel@tonic-gate 	if (iter->iter_type != REP_PROTOCOL_ENTITY_VALUE) {
49027c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
49037c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
49047c478bd9Sstevel@tonic-gate 	}
49057c478bd9Sstevel@tonic-gate 
49067c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ITER_READ_VALUE;
49077c478bd9Sstevel@tonic-gate 	request.rpr_iterid = iter->iter_id;
49087c478bd9Sstevel@tonic-gate 	request.rpr_sequence = iter->iter_sequence;
49097c478bd9Sstevel@tonic-gate 
49107c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
49117c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
49127c478bd9Sstevel@tonic-gate 
49137c478bd9Sstevel@tonic-gate 	if (r < 0) {
49147c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
49157c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
49167c478bd9Sstevel@tonic-gate 	}
49177c478bd9Sstevel@tonic-gate 
49187c478bd9Sstevel@tonic-gate 	if (response.rpr_response == REP_PROTOCOL_DONE) {
49197c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
49207c478bd9Sstevel@tonic-gate 		return (0);
49217c478bd9Sstevel@tonic-gate 	}
49227c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS) {
49237c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
49247c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
49257c478bd9Sstevel@tonic-gate 	}
49267c478bd9Sstevel@tonic-gate 	iter->iter_sequence++;
49277c478bd9Sstevel@tonic-gate 
49287c478bd9Sstevel@tonic-gate 	v->value_type = response.rpr_type;
49297c478bd9Sstevel@tonic-gate 
49307c478bd9Sstevel@tonic-gate 	assert(scf_validate_encoded_value(response.rpr_type,
49317c478bd9Sstevel@tonic-gate 	    response.rpr_value));
49327c478bd9Sstevel@tonic-gate 
49337c478bd9Sstevel@tonic-gate 	if (v->value_type != REP_PROTOCOL_TYPE_OPAQUE) {
49347c478bd9Sstevel@tonic-gate 		(void) strlcpy(v->value_value, response.rpr_value,
49357c478bd9Sstevel@tonic-gate 		    sizeof (v->value_value));
49367c478bd9Sstevel@tonic-gate 	} else {
49377c478bd9Sstevel@tonic-gate 		v->value_size = scf_opaque_decode(v->value_value,
49387c478bd9Sstevel@tonic-gate 		    response.rpr_value, sizeof (v->value_value));
49397c478bd9Sstevel@tonic-gate 	}
49407c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
49417c478bd9Sstevel@tonic-gate 
49427c478bd9Sstevel@tonic-gate 	return (1);
49437c478bd9Sstevel@tonic-gate }
49447c478bd9Sstevel@tonic-gate 
49457c478bd9Sstevel@tonic-gate int
49467c478bd9Sstevel@tonic-gate scf_property_get_value(const scf_property_t *prop, scf_value_t *v)
49477c478bd9Sstevel@tonic-gate {
49487c478bd9Sstevel@tonic-gate 	scf_handle_t *h = prop->rd_d.rd_handle;
49497c478bd9Sstevel@tonic-gate 	struct rep_protocol_property_request request;
49507c478bd9Sstevel@tonic-gate 	struct rep_protocol_value_response response;
49517c478bd9Sstevel@tonic-gate 	int r;
49527c478bd9Sstevel@tonic-gate 
49537c478bd9Sstevel@tonic-gate 	if (h != v->value_handle)
49547c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
49557c478bd9Sstevel@tonic-gate 
49567c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
49577c478bd9Sstevel@tonic-gate 
49587c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_PROPERTY_GET_VALUE;
49597c478bd9Sstevel@tonic-gate 	request.rpr_entityid = prop->rd_d.rd_entity;
49607c478bd9Sstevel@tonic-gate 
49617c478bd9Sstevel@tonic-gate 	scf_value_reset_locked(v, 0);
49627c478bd9Sstevel@tonic-gate 	datael_finish_reset(&prop->rd_d);
49637c478bd9Sstevel@tonic-gate 
49647c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
49657c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
49667c478bd9Sstevel@tonic-gate 
49677c478bd9Sstevel@tonic-gate 	if (r < 0) {
49687c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
49697c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
49707c478bd9Sstevel@tonic-gate 	}
49717c478bd9Sstevel@tonic-gate 
49727c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS &&
49737c478bd9Sstevel@tonic-gate 	    response.rpr_response != REP_PROTOCOL_FAIL_TRUNCATED) {
49747c478bd9Sstevel@tonic-gate 		(void) pthread_mutex_unlock(&h->rh_lock);
49757c478bd9Sstevel@tonic-gate 		assert(response.rpr_response !=
49767c478bd9Sstevel@tonic-gate 		    REP_PROTOCOL_FAIL_TYPE_MISMATCH);
49777c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
49787c478bd9Sstevel@tonic-gate 	}
49797c478bd9Sstevel@tonic-gate 
49807c478bd9Sstevel@tonic-gate 	v->value_type = response.rpr_type;
49817c478bd9Sstevel@tonic-gate 	if (v->value_type != REP_PROTOCOL_TYPE_OPAQUE) {
49827c478bd9Sstevel@tonic-gate 		(void) strlcpy(v->value_value, response.rpr_value,
49837c478bd9Sstevel@tonic-gate 		    sizeof (v->value_value));
49847c478bd9Sstevel@tonic-gate 	} else {
49857c478bd9Sstevel@tonic-gate 		v->value_size = scf_opaque_decode(v->value_value,
49867c478bd9Sstevel@tonic-gate 		    response.rpr_value, sizeof (v->value_value));
49877c478bd9Sstevel@tonic-gate 	}
49887c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
49897c478bd9Sstevel@tonic-gate 	return ((response.rpr_response == REP_PROTOCOL_SUCCESS)?
49907c478bd9Sstevel@tonic-gate 	    SCF_SUCCESS : scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
49917c478bd9Sstevel@tonic-gate }
49927c478bd9Sstevel@tonic-gate 
49937c478bd9Sstevel@tonic-gate int
49947c478bd9Sstevel@tonic-gate scf_pg_get_parent_service(const scf_propertygroup_t *pg, scf_service_t *svc)
49957c478bd9Sstevel@tonic-gate {
49967c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&pg->rd_d, &svc->rd_d));
49977c478bd9Sstevel@tonic-gate }
49987c478bd9Sstevel@tonic-gate 
49997c478bd9Sstevel@tonic-gate int
50007c478bd9Sstevel@tonic-gate scf_pg_get_parent_instance(const scf_propertygroup_t *pg, scf_instance_t *inst)
50017c478bd9Sstevel@tonic-gate {
50027c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&pg->rd_d, &inst->rd_d));
50037c478bd9Sstevel@tonic-gate }
50047c478bd9Sstevel@tonic-gate 
50057c478bd9Sstevel@tonic-gate int
50067c478bd9Sstevel@tonic-gate scf_pg_get_parent_snaplevel(const scf_propertygroup_t *pg,
50077c478bd9Sstevel@tonic-gate     scf_snaplevel_t *level)
50087c478bd9Sstevel@tonic-gate {
50097c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&pg->rd_d, &level->rd_d));
50107c478bd9Sstevel@tonic-gate }
50117c478bd9Sstevel@tonic-gate 
50127c478bd9Sstevel@tonic-gate int
50137c478bd9Sstevel@tonic-gate scf_service_get_parent(const scf_service_t *svc, scf_scope_t *s)
50147c478bd9Sstevel@tonic-gate {
50157c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&svc->rd_d, &s->rd_d));
50167c478bd9Sstevel@tonic-gate }
50177c478bd9Sstevel@tonic-gate 
50187c478bd9Sstevel@tonic-gate int
50197c478bd9Sstevel@tonic-gate scf_instance_get_parent(const scf_instance_t *inst, scf_service_t *svc)
50207c478bd9Sstevel@tonic-gate {
50217c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&inst->rd_d, &svc->rd_d));
50227c478bd9Sstevel@tonic-gate }
50237c478bd9Sstevel@tonic-gate 
50247c478bd9Sstevel@tonic-gate int
50257c478bd9Sstevel@tonic-gate scf_snapshot_get_parent(const scf_snapshot_t *inst, scf_instance_t *svc)
50267c478bd9Sstevel@tonic-gate {
50277c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&inst->rd_d, &svc->rd_d));
50287c478bd9Sstevel@tonic-gate }
50297c478bd9Sstevel@tonic-gate 
50307c478bd9Sstevel@tonic-gate int
50317c478bd9Sstevel@tonic-gate scf_snaplevel_get_parent(const scf_snaplevel_t *inst, scf_snapshot_t *svc)
50327c478bd9Sstevel@tonic-gate {
50337c478bd9Sstevel@tonic-gate 	return (datael_get_parent(&inst->rd_d, &svc->rd_d));
50347c478bd9Sstevel@tonic-gate }
50357c478bd9Sstevel@tonic-gate 
50367c478bd9Sstevel@tonic-gate /*
50377c478bd9Sstevel@tonic-gate  * FMRI functions
50387c478bd9Sstevel@tonic-gate  *
50397c478bd9Sstevel@tonic-gate  * Note: In the scf_parse_svc_fmri(), scf_parse_file_fmri() and
50407c478bd9Sstevel@tonic-gate  * scf_parse_fmri(), fmri isn't const because that would require
50417c478bd9Sstevel@tonic-gate  * allocating memory. Also, note that scope, at least, is not necessarily
50427c478bd9Sstevel@tonic-gate  * in the passed in fmri.
50437c478bd9Sstevel@tonic-gate  */
50447c478bd9Sstevel@tonic-gate 
50457c478bd9Sstevel@tonic-gate int
50467c478bd9Sstevel@tonic-gate scf_parse_svc_fmri(char *fmri, const char **scope, const char **service,
50477c478bd9Sstevel@tonic-gate     const char **instance, const char **propertygroup, const char **property)
50487c478bd9Sstevel@tonic-gate {
50497c478bd9Sstevel@tonic-gate 	char *s, *e, *te, *tpg;
50507c478bd9Sstevel@tonic-gate 	char *my_s = NULL, *my_i = NULL, *my_pg = NULL, *my_p = NULL;
50517c478bd9Sstevel@tonic-gate 
50527c478bd9Sstevel@tonic-gate 	if (scope != NULL)
50537c478bd9Sstevel@tonic-gate 		*scope = NULL;
50547c478bd9Sstevel@tonic-gate 	if (service != NULL)
50557c478bd9Sstevel@tonic-gate 		*service = NULL;
50567c478bd9Sstevel@tonic-gate 	if (instance != NULL)
50577c478bd9Sstevel@tonic-gate 		*instance = NULL;
50587c478bd9Sstevel@tonic-gate 	if (propertygroup != NULL)
50597c478bd9Sstevel@tonic-gate 		*propertygroup = NULL;
50607c478bd9Sstevel@tonic-gate 	if (property != NULL)
50617c478bd9Sstevel@tonic-gate 		*property = NULL;
50627c478bd9Sstevel@tonic-gate 
50637c478bd9Sstevel@tonic-gate 	s = fmri;
50647c478bd9Sstevel@tonic-gate 	e = strchr(s, '\0');
50657c478bd9Sstevel@tonic-gate 
50667c478bd9Sstevel@tonic-gate 	if (strncmp(s, SCF_FMRI_SVC_PREFIX,
50677c478bd9Sstevel@tonic-gate 	    sizeof (SCF_FMRI_SVC_PREFIX) - 1) == 0)
50687c478bd9Sstevel@tonic-gate 		s += sizeof (SCF_FMRI_SVC_PREFIX) - 1;
50697c478bd9Sstevel@tonic-gate 
50707c478bd9Sstevel@tonic-gate 	if (strncmp(s, SCF_FMRI_SCOPE_PREFIX,
50717c478bd9Sstevel@tonic-gate 	    sizeof (SCF_FMRI_SCOPE_PREFIX) - 1) == 0) {
50727c478bd9Sstevel@tonic-gate 		char *my_scope;
50737c478bd9Sstevel@tonic-gate 
50747c478bd9Sstevel@tonic-gate 		s += sizeof (SCF_FMRI_SCOPE_PREFIX) - 1;
50757c478bd9Sstevel@tonic-gate 		te = strstr(s, SCF_FMRI_SERVICE_PREFIX);
50767c478bd9Sstevel@tonic-gate 		if (te == NULL)
50777c478bd9Sstevel@tonic-gate 			te = e;
50787c478bd9Sstevel@tonic-gate 
50797c478bd9Sstevel@tonic-gate 		*te = 0;
50807c478bd9Sstevel@tonic-gate 		my_scope = s;
50817c478bd9Sstevel@tonic-gate 
50827c478bd9Sstevel@tonic-gate 		s = te;
50837c478bd9Sstevel@tonic-gate 		if (s < e)
50847c478bd9Sstevel@tonic-gate 			s += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1;
50857c478bd9Sstevel@tonic-gate 
50867c478bd9Sstevel@tonic-gate 		/* If the scope ends with the suffix, remove it. */
50877c478bd9Sstevel@tonic-gate 		te = strstr(my_scope, SCF_FMRI_SCOPE_SUFFIX);
50887c478bd9Sstevel@tonic-gate 		if (te != NULL && te[sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1] == 0)
50897c478bd9Sstevel@tonic-gate 			*te = 0;
50907c478bd9Sstevel@tonic-gate 
50917c478bd9Sstevel@tonic-gate 		/* Validate the scope. */
50927c478bd9Sstevel@tonic-gate 		if (my_scope[0] == '\0')
50937c478bd9Sstevel@tonic-gate 			my_scope = SCF_FMRI_LOCAL_SCOPE;
50947c478bd9Sstevel@tonic-gate 		else if (uu_check_name(my_scope, 0) == -1) {
50957c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
50967c478bd9Sstevel@tonic-gate 		}
50977c478bd9Sstevel@tonic-gate 
50987c478bd9Sstevel@tonic-gate 		if (scope != NULL)
50997c478bd9Sstevel@tonic-gate 			*scope = my_scope;
51007c478bd9Sstevel@tonic-gate 	} else {
51017c478bd9Sstevel@tonic-gate 		if (scope != NULL)
51027c478bd9Sstevel@tonic-gate 			*scope = SCF_FMRI_LOCAL_SCOPE;
51037c478bd9Sstevel@tonic-gate 	}
51047c478bd9Sstevel@tonic-gate 
51057c478bd9Sstevel@tonic-gate 	if (s[0] != 0) {
51067c478bd9Sstevel@tonic-gate 		if (strncmp(s, SCF_FMRI_SERVICE_PREFIX,
51077c478bd9Sstevel@tonic-gate 		    sizeof (SCF_FMRI_SERVICE_PREFIX) - 1) == 0)
51087c478bd9Sstevel@tonic-gate 			s += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1;
51097c478bd9Sstevel@tonic-gate 
51107c478bd9Sstevel@tonic-gate 		/*
51117c478bd9Sstevel@tonic-gate 		 * Can't validate service here because it might not be null
51127c478bd9Sstevel@tonic-gate 		 * terminated.
51137c478bd9Sstevel@tonic-gate 		 */
51147c478bd9Sstevel@tonic-gate 		my_s = s;
51157c478bd9Sstevel@tonic-gate 	}
51167c478bd9Sstevel@tonic-gate 
51177c478bd9Sstevel@tonic-gate 	tpg = strstr(s, SCF_FMRI_PROPERTYGRP_PREFIX);
51187c478bd9Sstevel@tonic-gate 	te = strstr(s, SCF_FMRI_INSTANCE_PREFIX);
51197c478bd9Sstevel@tonic-gate 	if (te != NULL && (tpg == NULL || te < tpg)) {
51207c478bd9Sstevel@tonic-gate 		*te = 0;
51217c478bd9Sstevel@tonic-gate 		te += sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1;
51227c478bd9Sstevel@tonic-gate 
51237c478bd9Sstevel@tonic-gate 		/* Can't validate instance here either. */
51247c478bd9Sstevel@tonic-gate 		my_i = s = te;
51257c478bd9Sstevel@tonic-gate 
51267c478bd9Sstevel@tonic-gate 		te = strstr(s, SCF_FMRI_PROPERTYGRP_PREFIX);
51277c478bd9Sstevel@tonic-gate 	} else {
51287c478bd9Sstevel@tonic-gate 		te = tpg;
51297c478bd9Sstevel@tonic-gate 	}
51307c478bd9Sstevel@tonic-gate 
51317c478bd9Sstevel@tonic-gate 	if (te != NULL) {
51327c478bd9Sstevel@tonic-gate 		*te = 0;
51337c478bd9Sstevel@tonic-gate 		te += sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1;
51347c478bd9Sstevel@tonic-gate 
51357c478bd9Sstevel@tonic-gate 		my_pg = s = te;
51367c478bd9Sstevel@tonic-gate 		te = strstr(s, SCF_FMRI_PROPERTY_PREFIX);
51377c478bd9Sstevel@tonic-gate 		if (te != NULL) {
51387c478bd9Sstevel@tonic-gate 			*te = 0;
51397c478bd9Sstevel@tonic-gate 			te += sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1;
51407c478bd9Sstevel@tonic-gate 
51417c478bd9Sstevel@tonic-gate 			my_p = te;
51427c478bd9Sstevel@tonic-gate 			s = te;
51437c478bd9Sstevel@tonic-gate 		}
51447c478bd9Sstevel@tonic-gate 	}
51457c478bd9Sstevel@tonic-gate 
51467c478bd9Sstevel@tonic-gate 	if (my_s != NULL) {
51477c478bd9Sstevel@tonic-gate 		if (uu_check_name(my_s, UU_NAME_DOMAIN | UU_NAME_PATH) == -1)
51487c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
51497c478bd9Sstevel@tonic-gate 
51507c478bd9Sstevel@tonic-gate 		if (service != NULL)
51517c478bd9Sstevel@tonic-gate 			*service = my_s;
51527c478bd9Sstevel@tonic-gate 	}
51537c478bd9Sstevel@tonic-gate 
51547c478bd9Sstevel@tonic-gate 	if (my_i != NULL) {
51557c478bd9Sstevel@tonic-gate 		if (uu_check_name(my_i, UU_NAME_DOMAIN) == -1)
51567c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
51577c478bd9Sstevel@tonic-gate 
51587c478bd9Sstevel@tonic-gate 		if (instance != NULL)
51597c478bd9Sstevel@tonic-gate 			*instance = my_i;
51607c478bd9Sstevel@tonic-gate 	}
51617c478bd9Sstevel@tonic-gate 
51627c478bd9Sstevel@tonic-gate 	if (my_pg != NULL) {
51637c478bd9Sstevel@tonic-gate 		if (uu_check_name(my_pg, UU_NAME_DOMAIN) == -1)
51647c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
51657c478bd9Sstevel@tonic-gate 
51667c478bd9Sstevel@tonic-gate 		if (propertygroup != NULL)
51677c478bd9Sstevel@tonic-gate 			*propertygroup = my_pg;
51687c478bd9Sstevel@tonic-gate 	}
51697c478bd9Sstevel@tonic-gate 
51707c478bd9Sstevel@tonic-gate 	if (my_p != NULL) {
51717c478bd9Sstevel@tonic-gate 		if (uu_check_name(my_p, UU_NAME_DOMAIN) == -1)
51727c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
51737c478bd9Sstevel@tonic-gate 
51747c478bd9Sstevel@tonic-gate 		if (property != NULL)
51757c478bd9Sstevel@tonic-gate 			*property = my_p;
51767c478bd9Sstevel@tonic-gate 	}
51777c478bd9Sstevel@tonic-gate 
51787c478bd9Sstevel@tonic-gate 	return (0);
51797c478bd9Sstevel@tonic-gate }
51807c478bd9Sstevel@tonic-gate 
51817c478bd9Sstevel@tonic-gate int
51827c478bd9Sstevel@tonic-gate scf_parse_file_fmri(char *fmri, const char **scope, const char **path)
51837c478bd9Sstevel@tonic-gate {
51847c478bd9Sstevel@tonic-gate 	char *s, *e, *te;
51857c478bd9Sstevel@tonic-gate 
51867c478bd9Sstevel@tonic-gate 	if (scope != NULL)
51877c478bd9Sstevel@tonic-gate 		*scope = NULL;
51887c478bd9Sstevel@tonic-gate 
51897c478bd9Sstevel@tonic-gate 	s = fmri;
51907c478bd9Sstevel@tonic-gate 	e = strchr(s, '\0');
51917c478bd9Sstevel@tonic-gate 
51927c478bd9Sstevel@tonic-gate 	if (strncmp(s, SCF_FMRI_FILE_PREFIX,
51937c478bd9Sstevel@tonic-gate 	    sizeof (SCF_FMRI_FILE_PREFIX) - 1) == 0)
51947c478bd9Sstevel@tonic-gate 		s += sizeof (SCF_FMRI_FILE_PREFIX) - 1;
51957c478bd9Sstevel@tonic-gate 
51967c478bd9Sstevel@tonic-gate 	if (strncmp(s, SCF_FMRI_SCOPE_PREFIX,
51977c478bd9Sstevel@tonic-gate 	    sizeof (SCF_FMRI_SCOPE_PREFIX) - 1) == 0) {
51987c478bd9Sstevel@tonic-gate 		char *my_scope;
51997c478bd9Sstevel@tonic-gate 
52007c478bd9Sstevel@tonic-gate 		s += sizeof (SCF_FMRI_SCOPE_PREFIX) - 1;
52017c478bd9Sstevel@tonic-gate 		te = strstr(s, SCF_FMRI_SERVICE_PREFIX);
52027c478bd9Sstevel@tonic-gate 		if (te == NULL)
52037c478bd9Sstevel@tonic-gate 			te = e;
52047c478bd9Sstevel@tonic-gate 
52057c478bd9Sstevel@tonic-gate 		*te = 0;
52067c478bd9Sstevel@tonic-gate 		my_scope = s;
52077c478bd9Sstevel@tonic-gate 
52087c478bd9Sstevel@tonic-gate 		s = te;
52097c478bd9Sstevel@tonic-gate 
52107c478bd9Sstevel@tonic-gate 		/* Validate the scope. */
52117c478bd9Sstevel@tonic-gate 		if (my_scope[0] != '\0' &&
52127c478bd9Sstevel@tonic-gate 		    strcmp(my_scope, SCF_FMRI_LOCAL_SCOPE) != 0) {
52137c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
52147c478bd9Sstevel@tonic-gate 		}
52157c478bd9Sstevel@tonic-gate 
52167c478bd9Sstevel@tonic-gate 		if (scope != NULL)
52177c478bd9Sstevel@tonic-gate 			*scope = my_scope;
52187c478bd9Sstevel@tonic-gate 	} else {
52197c478bd9Sstevel@tonic-gate 		/*
52207c478bd9Sstevel@tonic-gate 		 * FMRI paths must be absolute
52217c478bd9Sstevel@tonic-gate 		 */
52227c478bd9Sstevel@tonic-gate 		if (s[0] != '/')
52237c478bd9Sstevel@tonic-gate 			return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
52247c478bd9Sstevel@tonic-gate 	}
52257c478bd9Sstevel@tonic-gate 
52267c478bd9Sstevel@tonic-gate 	s += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1;
52277c478bd9Sstevel@tonic-gate 
52287c478bd9Sstevel@tonic-gate 	if (s >= e)
52297c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
52307c478bd9Sstevel@tonic-gate 
52317c478bd9Sstevel@tonic-gate 	/*
52327c478bd9Sstevel@tonic-gate 	 * If the user requests it, return the full path of the file.
52337c478bd9Sstevel@tonic-gate 	 */
52347c478bd9Sstevel@tonic-gate 	if (path != NULL) {
52357c478bd9Sstevel@tonic-gate 		assert(s > fmri);
52367c478bd9Sstevel@tonic-gate 		s[-1] = '/';
52377c478bd9Sstevel@tonic-gate 		*path = s - 1;
52387c478bd9Sstevel@tonic-gate 	}
52397c478bd9Sstevel@tonic-gate 
52407c478bd9Sstevel@tonic-gate 	return (0);
52417c478bd9Sstevel@tonic-gate }
52427c478bd9Sstevel@tonic-gate 
52437c478bd9Sstevel@tonic-gate int
52447c478bd9Sstevel@tonic-gate scf_parse_fmri(char *fmri, int *type, const char **scope, const char **service,
52457c478bd9Sstevel@tonic-gate     const char **instance, const char **propertygroup, const char **property)
52467c478bd9Sstevel@tonic-gate {
52477c478bd9Sstevel@tonic-gate 	if (strncmp(fmri, SCF_FMRI_SVC_PREFIX,
52487c478bd9Sstevel@tonic-gate 	    sizeof (SCF_FMRI_SVC_PREFIX) - 1) == 0) {
52497c478bd9Sstevel@tonic-gate 		if (type)
52507c478bd9Sstevel@tonic-gate 			*type = SCF_FMRI_TYPE_SVC;
52517c478bd9Sstevel@tonic-gate 		return (scf_parse_svc_fmri(fmri, scope, service, instance,
525276cf44abSjeanm 		    propertygroup, property));
52537c478bd9Sstevel@tonic-gate 	} else if (strncmp(fmri, SCF_FMRI_FILE_PREFIX,
52547c478bd9Sstevel@tonic-gate 	    sizeof (SCF_FMRI_FILE_PREFIX) - 1) == 0) {
52557c478bd9Sstevel@tonic-gate 		if (type)
52567c478bd9Sstevel@tonic-gate 			*type = SCF_FMRI_TYPE_FILE;
52577c478bd9Sstevel@tonic-gate 		return (scf_parse_file_fmri(fmri, scope, NULL));
52587c478bd9Sstevel@tonic-gate 	} else {
52597c478bd9Sstevel@tonic-gate 		/*
52607c478bd9Sstevel@tonic-gate 		 * Parse as a svc if the fmri type is not explicitly
52617c478bd9Sstevel@tonic-gate 		 * specified.
52627c478bd9Sstevel@tonic-gate 		 */
52637c478bd9Sstevel@tonic-gate 		if (type)
52647c478bd9Sstevel@tonic-gate 			*type = SCF_FMRI_TYPE_SVC;
52657c478bd9Sstevel@tonic-gate 		return (scf_parse_svc_fmri(fmri, scope, service, instance,
52667c478bd9Sstevel@tonic-gate 		    propertygroup, property));
52677c478bd9Sstevel@tonic-gate 	}
52687c478bd9Sstevel@tonic-gate }
52697c478bd9Sstevel@tonic-gate 
52707c478bd9Sstevel@tonic-gate /*
52717c478bd9Sstevel@tonic-gate  * Fails with _INVALID_ARGUMENT.  fmri and buf may be equal.
52727c478bd9Sstevel@tonic-gate  */
52737c478bd9Sstevel@tonic-gate ssize_t
52747c478bd9Sstevel@tonic-gate scf_canonify_fmri(const char *fmri, char *buf, size_t bufsz)
52757c478bd9Sstevel@tonic-gate {
52767c478bd9Sstevel@tonic-gate 	const char *scope, *service, *instance, *pg, *property;
52777c478bd9Sstevel@tonic-gate 	char local[6 * REP_PROTOCOL_NAME_LEN];
52787c478bd9Sstevel@tonic-gate 	int r;
52797c478bd9Sstevel@tonic-gate 	size_t len;
52807c478bd9Sstevel@tonic-gate 
52817c478bd9Sstevel@tonic-gate 	if (strlcpy(local, fmri, sizeof (local)) >= sizeof (local)) {
52827c478bd9Sstevel@tonic-gate 		/* Should this be CONSTRAINT_VIOLATED? */
52837c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
52847c478bd9Sstevel@tonic-gate 		return (-1);
52857c478bd9Sstevel@tonic-gate 	}
52867c478bd9Sstevel@tonic-gate 
52877c478bd9Sstevel@tonic-gate 
52887c478bd9Sstevel@tonic-gate 	r = scf_parse_svc_fmri(local, &scope, &service, &instance, &pg,
52897c478bd9Sstevel@tonic-gate 	    &property);
52907c478bd9Sstevel@tonic-gate 	if (r != 0)
52917c478bd9Sstevel@tonic-gate 		return (-1);
52927c478bd9Sstevel@tonic-gate 
52937c478bd9Sstevel@tonic-gate 	len = strlcpy(buf, "svc:/", bufsz);
52947c478bd9Sstevel@tonic-gate 
52957c478bd9Sstevel@tonic-gate 	if (scope != NULL && strcmp(scope, SCF_SCOPE_LOCAL) != 0) {
52967c478bd9Sstevel@tonic-gate 		len += strlcat(buf, "/", bufsz);
52977c478bd9Sstevel@tonic-gate 		len += strlcat(buf, scope, bufsz);
52987c478bd9Sstevel@tonic-gate 	}
52997c478bd9Sstevel@tonic-gate 
53007c478bd9Sstevel@tonic-gate 	if (service)
53017c478bd9Sstevel@tonic-gate 		len += strlcat(buf, service, bufsz);
53027c478bd9Sstevel@tonic-gate 
53037c478bd9Sstevel@tonic-gate 	if (instance) {
53047c478bd9Sstevel@tonic-gate 		len += strlcat(buf, ":", bufsz);
53057c478bd9Sstevel@tonic-gate 		len += strlcat(buf, instance, bufsz);
53067c478bd9Sstevel@tonic-gate 	}
53077c478bd9Sstevel@tonic-gate 
53087c478bd9Sstevel@tonic-gate 	if (pg) {
53097c478bd9Sstevel@tonic-gate 		len += strlcat(buf, "/:properties/", bufsz);
53107c478bd9Sstevel@tonic-gate 		len += strlcat(buf, pg, bufsz);
53117c478bd9Sstevel@tonic-gate 	}
53127c478bd9Sstevel@tonic-gate 
53137c478bd9Sstevel@tonic-gate 	if (property) {
53147c478bd9Sstevel@tonic-gate 		len += strlcat(buf, "/", bufsz);
53157c478bd9Sstevel@tonic-gate 		len += strlcat(buf, property, bufsz);
53167c478bd9Sstevel@tonic-gate 	}
53177c478bd9Sstevel@tonic-gate 
53187c478bd9Sstevel@tonic-gate 	return (len);
53197c478bd9Sstevel@tonic-gate }
53207c478bd9Sstevel@tonic-gate 
532176cf44abSjeanm /*
532276cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _INVALID_ARGUMENT, _CONSTRAINT_VIOLATED,
532376cf44abSjeanm  * _NOT_FOUND, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL, _NOT_SET, _DELETED,
532476cf44abSjeanm  * _NO_RESOURCES, _BACKEND_ACCESS.
532576cf44abSjeanm  */
53267c478bd9Sstevel@tonic-gate int
53277c478bd9Sstevel@tonic-gate scf_handle_decode_fmri(scf_handle_t *h, const char *fmri, scf_scope_t *sc,
53287c478bd9Sstevel@tonic-gate     scf_service_t *svc, scf_instance_t *inst, scf_propertygroup_t *pg,
53297c478bd9Sstevel@tonic-gate     scf_property_t *prop, int flags)
53307c478bd9Sstevel@tonic-gate {
53317c478bd9Sstevel@tonic-gate 	const char *scope, *service, *instance, *propertygroup, *property;
53327c478bd9Sstevel@tonic-gate 	int last;
53337c478bd9Sstevel@tonic-gate 	char local[6 * REP_PROTOCOL_NAME_LEN];
53347c478bd9Sstevel@tonic-gate 	int ret;
53357c478bd9Sstevel@tonic-gate 	const uint32_t holds = RH_HOLD_SCOPE | RH_HOLD_SERVICE |
53367c478bd9Sstevel@tonic-gate 	    RH_HOLD_INSTANCE | RH_HOLD_PG | RH_HOLD_PROPERTY;
53377c478bd9Sstevel@tonic-gate 
53387c478bd9Sstevel@tonic-gate 	/*
53397c478bd9Sstevel@tonic-gate 	 * verify that all handles match
53407c478bd9Sstevel@tonic-gate 	 */
53417c478bd9Sstevel@tonic-gate 	if ((sc != NULL && h != sc->rd_d.rd_handle) ||
53427c478bd9Sstevel@tonic-gate 	    (svc != NULL && h != svc->rd_d.rd_handle) ||
53437c478bd9Sstevel@tonic-gate 	    (inst != NULL && h != inst->rd_d.rd_handle) ||
53447c478bd9Sstevel@tonic-gate 	    (pg != NULL && h != pg->rd_d.rd_handle) ||
53457c478bd9Sstevel@tonic-gate 	    (prop != NULL && h != prop->rd_d.rd_handle))
53467c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
53477c478bd9Sstevel@tonic-gate 
53487c478bd9Sstevel@tonic-gate 	if (strlcpy(local, fmri, sizeof (local)) >= sizeof (local)) {
53497c478bd9Sstevel@tonic-gate 		ret = scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
53507c478bd9Sstevel@tonic-gate 		goto reset_args;
53517c478bd9Sstevel@tonic-gate 	}
53527c478bd9Sstevel@tonic-gate 
53537c478bd9Sstevel@tonic-gate 	/*
53547c478bd9Sstevel@tonic-gate 	 * We can simply return from an error in parsing, because
53557c478bd9Sstevel@tonic-gate 	 * scf_parse_fmri sets the error code correctly.
53567c478bd9Sstevel@tonic-gate 	 */
53577c478bd9Sstevel@tonic-gate 	if (scf_parse_svc_fmri(local, &scope, &service, &instance,
53587c478bd9Sstevel@tonic-gate 	    &propertygroup, &property) == -1) {
53597c478bd9Sstevel@tonic-gate 		ret = -1;
53607c478bd9Sstevel@tonic-gate 		goto reset_args;
53617c478bd9Sstevel@tonic-gate 	}
53627c478bd9Sstevel@tonic-gate 
53637c478bd9Sstevel@tonic-gate 	/*
53647c478bd9Sstevel@tonic-gate 	 * the FMRI looks valid at this point -- do constraint checks.
53657c478bd9Sstevel@tonic-gate 	 */
53667c478bd9Sstevel@tonic-gate 
53677c478bd9Sstevel@tonic-gate 	if (instance != NULL && (flags & SCF_DECODE_FMRI_REQUIRE_NO_INSTANCE)) {
53687c478bd9Sstevel@tonic-gate 		ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED);
53697c478bd9Sstevel@tonic-gate 		goto reset_args;
53707c478bd9Sstevel@tonic-gate 	}
53717c478bd9Sstevel@tonic-gate 	if (instance == NULL && (flags & SCF_DECODE_FMRI_REQUIRE_INSTANCE)) {
53727c478bd9Sstevel@tonic-gate 		ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED);
53737c478bd9Sstevel@tonic-gate 		goto reset_args;
53747c478bd9Sstevel@tonic-gate 	}
53757c478bd9Sstevel@tonic-gate 
53767c478bd9Sstevel@tonic-gate 	if (prop != NULL)
53777c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_PROPERTY;
53787c478bd9Sstevel@tonic-gate 	else if (pg != NULL)
53797c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_PROPERTYGRP;
53807c478bd9Sstevel@tonic-gate 	else if (inst != NULL)
53817c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_INSTANCE;
53827c478bd9Sstevel@tonic-gate 	else if (svc != NULL)
53837c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_SERVICE;
53847c478bd9Sstevel@tonic-gate 	else if (sc != NULL)
53857c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_SCOPE;
53867c478bd9Sstevel@tonic-gate 	else
53877c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_NONE;
53887c478bd9Sstevel@tonic-gate 
53897c478bd9Sstevel@tonic-gate 	if (flags & SCF_DECODE_FMRI_EXACT) {
53907c478bd9Sstevel@tonic-gate 		int last_fmri;
53917c478bd9Sstevel@tonic-gate 
53927c478bd9Sstevel@tonic-gate 		if (property != NULL)
53937c478bd9Sstevel@tonic-gate 			last_fmri = REP_PROTOCOL_ENTITY_PROPERTY;
53947c478bd9Sstevel@tonic-gate 		else if (propertygroup != NULL)
53957c478bd9Sstevel@tonic-gate 			last_fmri = REP_PROTOCOL_ENTITY_PROPERTYGRP;
53967c478bd9Sstevel@tonic-gate 		else if (instance != NULL)
53977c478bd9Sstevel@tonic-gate 			last_fmri = REP_PROTOCOL_ENTITY_INSTANCE;
53987c478bd9Sstevel@tonic-gate 		else if (service != NULL)
53997c478bd9Sstevel@tonic-gate 			last_fmri = REP_PROTOCOL_ENTITY_SERVICE;
54007c478bd9Sstevel@tonic-gate 		else if (scope != NULL)
54017c478bd9Sstevel@tonic-gate 			last_fmri = REP_PROTOCOL_ENTITY_SCOPE;
54027c478bd9Sstevel@tonic-gate 		else
54037c478bd9Sstevel@tonic-gate 			last_fmri = REP_PROTOCOL_ENTITY_NONE;
54047c478bd9Sstevel@tonic-gate 
54057c478bd9Sstevel@tonic-gate 		if (last != last_fmri) {
54067c478bd9Sstevel@tonic-gate 			ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED);
54077c478bd9Sstevel@tonic-gate 			goto reset_args;
54087c478bd9Sstevel@tonic-gate 		}
54097c478bd9Sstevel@tonic-gate 	}
54107c478bd9Sstevel@tonic-gate 
54117c478bd9Sstevel@tonic-gate 	if ((flags & SCF_DECODE_FMRI_TRUNCATE) &&
54127c478bd9Sstevel@tonic-gate 	    last == REP_PROTOCOL_ENTITY_NONE) {
54137c478bd9Sstevel@tonic-gate 		ret = 0;				/* nothing to do */
54147c478bd9Sstevel@tonic-gate 		goto reset_args;
54157c478bd9Sstevel@tonic-gate 	}
54167c478bd9Sstevel@tonic-gate 
54177c478bd9Sstevel@tonic-gate 	if (!(flags & SCF_DECODE_FMRI_TRUNCATE))
54187c478bd9Sstevel@tonic-gate 		last = REP_PROTOCOL_ENTITY_NONE;	/* never stop */
54197c478bd9Sstevel@tonic-gate 
54207c478bd9Sstevel@tonic-gate 	/*
54217c478bd9Sstevel@tonic-gate 	 * passed the constraint checks -- try to grab the thing itself.
54227c478bd9Sstevel@tonic-gate 	 */
54237c478bd9Sstevel@tonic-gate 
54247c478bd9Sstevel@tonic-gate 	handle_hold_subhandles(h, holds);
54257c478bd9Sstevel@tonic-gate 	if (sc == NULL)
54267c478bd9Sstevel@tonic-gate 		sc = h->rh_scope;
54277c478bd9Sstevel@tonic-gate 	else
54287c478bd9Sstevel@tonic-gate 		datael_reset(&sc->rd_d);
54297c478bd9Sstevel@tonic-gate 
54307c478bd9Sstevel@tonic-gate 	if (svc == NULL)
54317c478bd9Sstevel@tonic-gate 		svc = h->rh_service;
54327c478bd9Sstevel@tonic-gate 	else
54337c478bd9Sstevel@tonic-gate 		datael_reset(&svc->rd_d);
54347c478bd9Sstevel@tonic-gate 
54357c478bd9Sstevel@tonic-gate 	if (inst == NULL)
54367c478bd9Sstevel@tonic-gate 		inst = h->rh_instance;
54377c478bd9Sstevel@tonic-gate 	else
54387c478bd9Sstevel@tonic-gate 		datael_reset(&inst->rd_d);
54397c478bd9Sstevel@tonic-gate 
54407c478bd9Sstevel@tonic-gate 	if (pg == NULL)
54417c478bd9Sstevel@tonic-gate 		pg = h->rh_pg;
54427c478bd9Sstevel@tonic-gate 	else
54437c478bd9Sstevel@tonic-gate 		datael_reset(&pg->rd_d);
54447c478bd9Sstevel@tonic-gate 
54457c478bd9Sstevel@tonic-gate 	if (prop == NULL)
54467c478bd9Sstevel@tonic-gate 		prop = h->rh_property;
54477c478bd9Sstevel@tonic-gate 	else
54487c478bd9Sstevel@tonic-gate 		datael_reset(&prop->rd_d);
54497c478bd9Sstevel@tonic-gate 
54507c478bd9Sstevel@tonic-gate 	/*
54517c478bd9Sstevel@tonic-gate 	 * We only support local scopes, but we check *after* getting
54527c478bd9Sstevel@tonic-gate 	 * the local scope, so that any repository-related errors take
54537c478bd9Sstevel@tonic-gate 	 * precedence.
54547c478bd9Sstevel@tonic-gate 	 */
54557c478bd9Sstevel@tonic-gate 	if (scf_handle_get_scope(h, SCF_SCOPE_LOCAL, sc) == -1) {
54567c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
54577c478bd9Sstevel@tonic-gate 		ret = -1;
54587c478bd9Sstevel@tonic-gate 		goto reset_args;
54597c478bd9Sstevel@tonic-gate 	}
54607c478bd9Sstevel@tonic-gate 
54617c478bd9Sstevel@tonic-gate 	if (scope != NULL && strcmp(scope, SCF_FMRI_LOCAL_SCOPE) != 0) {
54627c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
54637c478bd9Sstevel@tonic-gate 		ret = scf_set_error(SCF_ERROR_NOT_FOUND);
54647c478bd9Sstevel@tonic-gate 		goto reset_args;
54657c478bd9Sstevel@tonic-gate 	}
54667c478bd9Sstevel@tonic-gate 
54677c478bd9Sstevel@tonic-gate 
54687c478bd9Sstevel@tonic-gate 	if (service == NULL || last == REP_PROTOCOL_ENTITY_SCOPE) {
54697c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
54707c478bd9Sstevel@tonic-gate 		return (0);
54717c478bd9Sstevel@tonic-gate 	}
54727c478bd9Sstevel@tonic-gate 
54737c478bd9Sstevel@tonic-gate 	if (scf_scope_get_service(sc, service, svc) == -1) {
54747c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
54757c478bd9Sstevel@tonic-gate 		ret = -1;
54767c478bd9Sstevel@tonic-gate 		assert(scf_error() != SCF_ERROR_NOT_SET);
54777c478bd9Sstevel@tonic-gate 		if (scf_error() == SCF_ERROR_DELETED)
54787c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_NOT_FOUND);
54797c478bd9Sstevel@tonic-gate 		goto reset_args;
54807c478bd9Sstevel@tonic-gate 	}
54817c478bd9Sstevel@tonic-gate 
54827c478bd9Sstevel@tonic-gate 	if (last == REP_PROTOCOL_ENTITY_SERVICE) {
54837c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
54847c478bd9Sstevel@tonic-gate 		return (0);
54857c478bd9Sstevel@tonic-gate 	}
54867c478bd9Sstevel@tonic-gate 
54877c478bd9Sstevel@tonic-gate 	if (instance == NULL) {
54887c478bd9Sstevel@tonic-gate 		if (propertygroup == NULL ||
54897c478bd9Sstevel@tonic-gate 		    last == REP_PROTOCOL_ENTITY_INSTANCE) {
54907c478bd9Sstevel@tonic-gate 			handle_rele_subhandles(h, holds);
54917c478bd9Sstevel@tonic-gate 			return (0);
54927c478bd9Sstevel@tonic-gate 		}
54937c478bd9Sstevel@tonic-gate 
54947c478bd9Sstevel@tonic-gate 		if (scf_service_get_pg(svc, propertygroup, pg) == -1) {
54957c478bd9Sstevel@tonic-gate 			handle_rele_subhandles(h, holds);
54967c478bd9Sstevel@tonic-gate 			ret = -1;
54977c478bd9Sstevel@tonic-gate 			assert(scf_error() != SCF_ERROR_NOT_SET);
54987c478bd9Sstevel@tonic-gate 			if (scf_error() == SCF_ERROR_DELETED)
54997c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NOT_FOUND);
55007c478bd9Sstevel@tonic-gate 			goto reset_args;
55017c478bd9Sstevel@tonic-gate 		}
55027c478bd9Sstevel@tonic-gate 	} else {
55037c478bd9Sstevel@tonic-gate 		if (scf_service_get_instance(svc, instance, inst) == -1) {
55047c478bd9Sstevel@tonic-gate 			handle_rele_subhandles(h, holds);
55057c478bd9Sstevel@tonic-gate 			ret = -1;
55067c478bd9Sstevel@tonic-gate 			assert(scf_error() != SCF_ERROR_NOT_SET);
55077c478bd9Sstevel@tonic-gate 			if (scf_error() == SCF_ERROR_DELETED)
55087c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NOT_FOUND);
55097c478bd9Sstevel@tonic-gate 			goto reset_args;
55107c478bd9Sstevel@tonic-gate 		}
55117c478bd9Sstevel@tonic-gate 
55127c478bd9Sstevel@tonic-gate 		if (propertygroup == NULL ||
55137c478bd9Sstevel@tonic-gate 		    last == REP_PROTOCOL_ENTITY_INSTANCE) {
55147c478bd9Sstevel@tonic-gate 			handle_rele_subhandles(h, holds);
55157c478bd9Sstevel@tonic-gate 			return (0);
55167c478bd9Sstevel@tonic-gate 		}
55177c478bd9Sstevel@tonic-gate 
55187c478bd9Sstevel@tonic-gate 		if (scf_instance_get_pg(inst, propertygroup, pg) == -1) {
55197c478bd9Sstevel@tonic-gate 			handle_rele_subhandles(h, holds);
55207c478bd9Sstevel@tonic-gate 			ret = -1;
55217c478bd9Sstevel@tonic-gate 			assert(scf_error() != SCF_ERROR_NOT_SET);
55227c478bd9Sstevel@tonic-gate 			if (scf_error() == SCF_ERROR_DELETED)
55237c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NOT_FOUND);
55247c478bd9Sstevel@tonic-gate 			goto reset_args;
55257c478bd9Sstevel@tonic-gate 		}
55267c478bd9Sstevel@tonic-gate 	}
55277c478bd9Sstevel@tonic-gate 
55287c478bd9Sstevel@tonic-gate 	if (property == NULL || last == REP_PROTOCOL_ENTITY_PROPERTYGRP) {
55297c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
55307c478bd9Sstevel@tonic-gate 		return (0);
55317c478bd9Sstevel@tonic-gate 	}
55327c478bd9Sstevel@tonic-gate 
55337c478bd9Sstevel@tonic-gate 	if (scf_pg_get_property(pg, property, prop) == -1) {
55347c478bd9Sstevel@tonic-gate 		handle_rele_subhandles(h, holds);
55357c478bd9Sstevel@tonic-gate 		ret = -1;
55367c478bd9Sstevel@tonic-gate 		assert(scf_error() != SCF_ERROR_NOT_SET);
55377c478bd9Sstevel@tonic-gate 		if (scf_error() == SCF_ERROR_DELETED)
55387c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_NOT_FOUND);
55397c478bd9Sstevel@tonic-gate 		goto reset_args;
55407c478bd9Sstevel@tonic-gate 	}
55417c478bd9Sstevel@tonic-gate 
55427c478bd9Sstevel@tonic-gate 	handle_rele_subhandles(h, holds);
55437c478bd9Sstevel@tonic-gate 	return (0);
55447c478bd9Sstevel@tonic-gate 
55457c478bd9Sstevel@tonic-gate reset_args:
55467c478bd9Sstevel@tonic-gate 	if (sc != NULL)
55477c478bd9Sstevel@tonic-gate 		datael_reset(&sc->rd_d);
55487c478bd9Sstevel@tonic-gate 	if (svc != NULL)
55497c478bd9Sstevel@tonic-gate 		datael_reset(&svc->rd_d);
55507c478bd9Sstevel@tonic-gate 	if (inst != NULL)
55517c478bd9Sstevel@tonic-gate 		datael_reset(&inst->rd_d);
55527c478bd9Sstevel@tonic-gate 	if (pg != NULL)
55537c478bd9Sstevel@tonic-gate 		datael_reset(&pg->rd_d);
55547c478bd9Sstevel@tonic-gate 	if (prop != NULL)
55557c478bd9Sstevel@tonic-gate 		datael_reset(&prop->rd_d);
55567c478bd9Sstevel@tonic-gate 
55577c478bd9Sstevel@tonic-gate 	return (ret);
55587c478bd9Sstevel@tonic-gate }
55597c478bd9Sstevel@tonic-gate 
55607c478bd9Sstevel@tonic-gate /*
55617c478bd9Sstevel@tonic-gate  * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
55627c478bd9Sstevel@tonic-gate  * big, bad entity id, request not applicable to entity, name too long for
55637c478bd9Sstevel@tonic-gate  * buffer), _NOT_SET, or _DELETED.
55647c478bd9Sstevel@tonic-gate  */
55657c478bd9Sstevel@tonic-gate ssize_t
55667c478bd9Sstevel@tonic-gate scf_scope_to_fmri(const scf_scope_t *scope, char *out, size_t sz)
55677c478bd9Sstevel@tonic-gate {
55687c478bd9Sstevel@tonic-gate 	ssize_t r, len;
55697c478bd9Sstevel@tonic-gate 
55707c478bd9Sstevel@tonic-gate 	char tmp[REP_PROTOCOL_NAME_LEN];
55717c478bd9Sstevel@tonic-gate 
55727c478bd9Sstevel@tonic-gate 	r = scf_scope_get_name(scope, tmp, sizeof (tmp));
55737c478bd9Sstevel@tonic-gate 
55747c478bd9Sstevel@tonic-gate 	if (r <= 0)
55757c478bd9Sstevel@tonic-gate 		return (r);
55767c478bd9Sstevel@tonic-gate 
55777c478bd9Sstevel@tonic-gate 	len = strlcpy(out, SCF_FMRI_SVC_PREFIX, sz);
55787c478bd9Sstevel@tonic-gate 	if (strcmp(tmp, SCF_FMRI_LOCAL_SCOPE) != 0) {
55797c478bd9Sstevel@tonic-gate 		if (len >= sz)
55807c478bd9Sstevel@tonic-gate 			return (len + r + sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1);
55817c478bd9Sstevel@tonic-gate 
55827c478bd9Sstevel@tonic-gate 		len = strlcat(out, tmp, sz);
55837c478bd9Sstevel@tonic-gate 		if (len >= sz)
55847c478bd9Sstevel@tonic-gate 			return (len + sizeof (SCF_FMRI_SCOPE_SUFFIX) - 1);
55857c478bd9Sstevel@tonic-gate 		len = strlcat(out,
55867c478bd9Sstevel@tonic-gate 		    SCF_FMRI_SCOPE_SUFFIX SCF_FMRI_SERVICE_PREFIX, sz);
55877c478bd9Sstevel@tonic-gate 	}
55887c478bd9Sstevel@tonic-gate 
55897c478bd9Sstevel@tonic-gate 	return (len);
55907c478bd9Sstevel@tonic-gate }
55917c478bd9Sstevel@tonic-gate 
55927c478bd9Sstevel@tonic-gate /*
55937c478bd9Sstevel@tonic-gate  * Fails with _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL (server response too
55947c478bd9Sstevel@tonic-gate  * big, bad element id, bad ids, bad types, scope has no parent, request not
55957c478bd9Sstevel@tonic-gate  * applicable to entity, name too long), _NOT_SET, _DELETED,
55967c478bd9Sstevel@tonic-gate  */
55977c478bd9Sstevel@tonic-gate ssize_t
55987c478bd9Sstevel@tonic-gate scf_service_to_fmri(const scf_service_t *svc, char *out, size_t sz)
55997c478bd9Sstevel@tonic-gate {
56007c478bd9Sstevel@tonic-gate 	scf_handle_t *h = svc->rd_d.rd_handle;
56017c478bd9Sstevel@tonic-gate 	scf_scope_t *scope = HANDLE_HOLD_SCOPE(h);
56027c478bd9Sstevel@tonic-gate 	ssize_t r, len;
56037c478bd9Sstevel@tonic-gate 
56047c478bd9Sstevel@tonic-gate 	char tmp[REP_PROTOCOL_NAME_LEN];
56057c478bd9Sstevel@tonic-gate 
56067c478bd9Sstevel@tonic-gate 	r = datael_get_parent(&svc->rd_d, &scope->rd_d);
56077c478bd9Sstevel@tonic-gate 	if (r != SCF_SUCCESS) {
56087c478bd9Sstevel@tonic-gate 		HANDLE_RELE_SCOPE(h);
56097c478bd9Sstevel@tonic-gate 
56107c478bd9Sstevel@tonic-gate 		assert(scf_error() != SCF_ERROR_HANDLE_MISMATCH);
56117c478bd9Sstevel@tonic-gate 		return (-1);
56127c478bd9Sstevel@tonic-gate 	}
56137c478bd9Sstevel@tonic-gate 	if (out != NULL && sz > 0)
56147c478bd9Sstevel@tonic-gate 		len = scf_scope_to_fmri(scope, out, sz);
56157c478bd9Sstevel@tonic-gate 	else
56167c478bd9Sstevel@tonic-gate 		len = scf_scope_to_fmri(scope, tmp, 2);
56177c478bd9Sstevel@tonic-gate 
56187c478bd9Sstevel@tonic-gate 	HANDLE_RELE_SCOPE(h);
56197c478bd9Sstevel@tonic-gate 
56207c478bd9Sstevel@tonic-gate 	if (len < 0)
56217c478bd9Sstevel@tonic-gate 		return (-1);
56227c478bd9Sstevel@tonic-gate 
56237c478bd9Sstevel@tonic-gate 	if (out == NULL || len >= sz)
56247c478bd9Sstevel@tonic-gate 		len += sizeof (SCF_FMRI_SERVICE_PREFIX) - 1;
56257c478bd9Sstevel@tonic-gate 	else
56267c478bd9Sstevel@tonic-gate 		len = strlcat(out, SCF_FMRI_SERVICE_PREFIX, sz);
56277c478bd9Sstevel@tonic-gate 
56287c478bd9Sstevel@tonic-gate 	r = scf_service_get_name(svc, tmp, sizeof (tmp));
56297c478bd9Sstevel@tonic-gate 	if (r < 0)
56307c478bd9Sstevel@tonic-gate 		return (r);
56317c478bd9Sstevel@tonic-gate 
56327c478bd9Sstevel@tonic-gate 	if (out == NULL || len >= sz)
56337c478bd9Sstevel@tonic-gate 		len += r;
56347c478bd9Sstevel@tonic-gate 	else
56357c478bd9Sstevel@tonic-gate 		len = strlcat(out, tmp, sz);
56367c478bd9Sstevel@tonic-gate 
56377c478bd9Sstevel@tonic-gate 	return (len);
56387c478bd9Sstevel@tonic-gate }
56397c478bd9Sstevel@tonic-gate 
56407c478bd9Sstevel@tonic-gate ssize_t
56417c478bd9Sstevel@tonic-gate scf_instance_to_fmri(const scf_instance_t *inst, char *out, size_t sz)
56427c478bd9Sstevel@tonic-gate {
56437c478bd9Sstevel@tonic-gate 	scf_handle_t *h = inst->rd_d.rd_handle;
56447c478bd9Sstevel@tonic-gate 	scf_service_t *svc = HANDLE_HOLD_SERVICE(h);
56457c478bd9Sstevel@tonic-gate 	ssize_t r, len;
56467c478bd9Sstevel@tonic-gate 
56477c478bd9Sstevel@tonic-gate 	char tmp[REP_PROTOCOL_NAME_LEN];
56487c478bd9Sstevel@tonic-gate 
56497c478bd9Sstevel@tonic-gate 	r = datael_get_parent(&inst->rd_d, &svc->rd_d);
56507c478bd9Sstevel@tonic-gate 	if (r != SCF_SUCCESS) {
56517c478bd9Sstevel@tonic-gate 		HANDLE_RELE_SERVICE(h);
56527c478bd9Sstevel@tonic-gate 		return (-1);
56537c478bd9Sstevel@tonic-gate 	}
56547c478bd9Sstevel@tonic-gate 
56557c478bd9Sstevel@tonic-gate 	len = scf_service_to_fmri(svc, out, sz);
56567c478bd9Sstevel@tonic-gate 
56577c478bd9Sstevel@tonic-gate 	HANDLE_RELE_SERVICE(h);
56587c478bd9Sstevel@tonic-gate 
56597c478bd9Sstevel@tonic-gate 	if (len < 0)
56607c478bd9Sstevel@tonic-gate 		return (len);
56617c478bd9Sstevel@tonic-gate 
56627c478bd9Sstevel@tonic-gate 	if (len >= sz)
56637c478bd9Sstevel@tonic-gate 		len += sizeof (SCF_FMRI_INSTANCE_PREFIX) - 1;
56647c478bd9Sstevel@tonic-gate 	else
56657c478bd9Sstevel@tonic-gate 		len = strlcat(out, SCF_FMRI_INSTANCE_PREFIX, sz);
56667c478bd9Sstevel@tonic-gate 
56677c478bd9Sstevel@tonic-gate 	r = scf_instance_get_name(inst, tmp, sizeof (tmp));
56687c478bd9Sstevel@tonic-gate 	if (r < 0)
56697c478bd9Sstevel@tonic-gate 		return (r);
56707c478bd9Sstevel@tonic-gate 
56717c478bd9Sstevel@tonic-gate 	if (len >= sz)
56727c478bd9Sstevel@tonic-gate 		len += r;
56737c478bd9Sstevel@tonic-gate 	else
56747c478bd9Sstevel@tonic-gate 		len = strlcat(out, tmp, sz);
56757c478bd9Sstevel@tonic-gate 
56767c478bd9Sstevel@tonic-gate 	return (len);
56777c478bd9Sstevel@tonic-gate }
56787c478bd9Sstevel@tonic-gate 
56797c478bd9Sstevel@tonic-gate ssize_t
56807c478bd9Sstevel@tonic-gate scf_pg_to_fmri(const scf_propertygroup_t *pg, char *out, size_t sz)
56817c478bd9Sstevel@tonic-gate {
56827c478bd9Sstevel@tonic-gate 	scf_handle_t *h = pg->rd_d.rd_handle;
56837c478bd9Sstevel@tonic-gate 
56847c478bd9Sstevel@tonic-gate 	struct rep_protocol_entity_parent_type request;
56857c478bd9Sstevel@tonic-gate 	struct rep_protocol_integer_response response;
56867c478bd9Sstevel@tonic-gate 
56877c478bd9Sstevel@tonic-gate 	char tmp[REP_PROTOCOL_NAME_LEN];
56887c478bd9Sstevel@tonic-gate 	ssize_t len, r;
56897c478bd9Sstevel@tonic-gate 
56907c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
56917c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_ENTITY_PARENT_TYPE;
56927c478bd9Sstevel@tonic-gate 	request.rpr_entityid = pg->rd_d.rd_entity;
56937c478bd9Sstevel@tonic-gate 
56947c478bd9Sstevel@tonic-gate 	datael_finish_reset(&pg->rd_d);
56957c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
56967c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
56977c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
56987c478bd9Sstevel@tonic-gate 
56997c478bd9Sstevel@tonic-gate 	if (r < 0)
57007c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
57017c478bd9Sstevel@tonic-gate 
57027c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS ||
57037c478bd9Sstevel@tonic-gate 	    r < sizeof (response)) {
57047c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
57057c478bd9Sstevel@tonic-gate 	}
57067c478bd9Sstevel@tonic-gate 
57077c478bd9Sstevel@tonic-gate 	switch (response.rpr_value) {
57087c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_ENTITY_SERVICE: {
57097c478bd9Sstevel@tonic-gate 		scf_service_t *svc;
57107c478bd9Sstevel@tonic-gate 
57117c478bd9Sstevel@tonic-gate 		svc = HANDLE_HOLD_SERVICE(h);
57127c478bd9Sstevel@tonic-gate 
57137c478bd9Sstevel@tonic-gate 		r = datael_get_parent(&pg->rd_d, &svc->rd_d);
57147c478bd9Sstevel@tonic-gate 
57157c478bd9Sstevel@tonic-gate 		if (r == SCF_SUCCESS)
57167c478bd9Sstevel@tonic-gate 			len = scf_service_to_fmri(svc, out, sz);
57177c478bd9Sstevel@tonic-gate 
57187c478bd9Sstevel@tonic-gate 		HANDLE_RELE_SERVICE(h);
57197c478bd9Sstevel@tonic-gate 		break;
57207c478bd9Sstevel@tonic-gate 	}
57217c478bd9Sstevel@tonic-gate 
57227c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_ENTITY_INSTANCE: {
57237c478bd9Sstevel@tonic-gate 		scf_instance_t *inst;
57247c478bd9Sstevel@tonic-gate 
57257c478bd9Sstevel@tonic-gate 		inst = HANDLE_HOLD_INSTANCE(h);
57267c478bd9Sstevel@tonic-gate 
57277c478bd9Sstevel@tonic-gate 		r = datael_get_parent(&pg->rd_d, &inst->rd_d);
57287c478bd9Sstevel@tonic-gate 
57297c478bd9Sstevel@tonic-gate 		if (r == SCF_SUCCESS)
57307c478bd9Sstevel@tonic-gate 			len = scf_instance_to_fmri(inst, out, sz);
57317c478bd9Sstevel@tonic-gate 
57327c478bd9Sstevel@tonic-gate 		HANDLE_RELE_INSTANCE(h);
57337c478bd9Sstevel@tonic-gate 		break;
57347c478bd9Sstevel@tonic-gate 	}
57357c478bd9Sstevel@tonic-gate 
57367c478bd9Sstevel@tonic-gate 	case REP_PROTOCOL_ENTITY_SNAPLEVEL: {
57377c478bd9Sstevel@tonic-gate 		scf_instance_t *inst = HANDLE_HOLD_INSTANCE(h);
57387c478bd9Sstevel@tonic-gate 		scf_snapshot_t *snap = HANDLE_HOLD_SNAPSHOT(h);
57397c478bd9Sstevel@tonic-gate 		scf_snaplevel_t *level = HANDLE_HOLD_SNAPLVL(h);
57407c478bd9Sstevel@tonic-gate 
57417c478bd9Sstevel@tonic-gate 		r = datael_get_parent(&pg->rd_d, &level->rd_d);
57427c478bd9Sstevel@tonic-gate 
57437c478bd9Sstevel@tonic-gate 		if (r == SCF_SUCCESS)
57447c478bd9Sstevel@tonic-gate 			r = datael_get_parent(&level->rd_d, &snap->rd_d);
57457c478bd9Sstevel@tonic-gate 
57467c478bd9Sstevel@tonic-gate 		if (r == SCF_SUCCESS)
57477c478bd9Sstevel@tonic-gate 			r = datael_get_parent(&snap->rd_d, &inst->rd_d);
57487c478bd9Sstevel@tonic-gate 
57497c478bd9Sstevel@tonic-gate 		if (r == SCF_SUCCESS)
57507c478bd9Sstevel@tonic-gate 			len = scf_instance_to_fmri(inst, out, sz);
57517c478bd9Sstevel@tonic-gate 
57527c478bd9Sstevel@tonic-gate 		HANDLE_RELE_INSTANCE(h);
57537c478bd9Sstevel@tonic-gate 		HANDLE_RELE_SNAPSHOT(h);
57547c478bd9Sstevel@tonic-gate 		HANDLE_RELE_SNAPLVL(h);
57557c478bd9Sstevel@tonic-gate 		break;
57567c478bd9Sstevel@tonic-gate 	}
57577c478bd9Sstevel@tonic-gate 
57587c478bd9Sstevel@tonic-gate 	default:
57597c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INTERNAL));
57607c478bd9Sstevel@tonic-gate 	}
57617c478bd9Sstevel@tonic-gate 
57627c478bd9Sstevel@tonic-gate 	if (r != SCF_SUCCESS)
57637c478bd9Sstevel@tonic-gate 		return (r);
57647c478bd9Sstevel@tonic-gate 
57657c478bd9Sstevel@tonic-gate 	if (len >= sz)
57667c478bd9Sstevel@tonic-gate 		len += sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1;
57677c478bd9Sstevel@tonic-gate 	else
57687c478bd9Sstevel@tonic-gate 		len = strlcat(out, SCF_FMRI_PROPERTYGRP_PREFIX, sz);
57697c478bd9Sstevel@tonic-gate 
57707c478bd9Sstevel@tonic-gate 	r = scf_pg_get_name(pg, tmp, sizeof (tmp));
57717c478bd9Sstevel@tonic-gate 
57727c478bd9Sstevel@tonic-gate 	if (r < 0)
57737c478bd9Sstevel@tonic-gate 		return (r);
57747c478bd9Sstevel@tonic-gate 
57757c478bd9Sstevel@tonic-gate 	if (len >= sz)
57767c478bd9Sstevel@tonic-gate 		len += r;
57777c478bd9Sstevel@tonic-gate 	else
57787c478bd9Sstevel@tonic-gate 		len = strlcat(out, tmp, sz);
57797c478bd9Sstevel@tonic-gate 
57807c478bd9Sstevel@tonic-gate 	return (len);
57817c478bd9Sstevel@tonic-gate }
57827c478bd9Sstevel@tonic-gate 
57837c478bd9Sstevel@tonic-gate ssize_t
57847c478bd9Sstevel@tonic-gate scf_property_to_fmri(const scf_property_t *prop, char *out, size_t sz)
57857c478bd9Sstevel@tonic-gate {
57867c478bd9Sstevel@tonic-gate 	scf_handle_t *h = prop->rd_d.rd_handle;
57877c478bd9Sstevel@tonic-gate 	scf_propertygroup_t *pg = HANDLE_HOLD_PG(h);
57887c478bd9Sstevel@tonic-gate 
57897c478bd9Sstevel@tonic-gate 	char tmp[REP_PROTOCOL_NAME_LEN];
57907c478bd9Sstevel@tonic-gate 	ssize_t len;
57917c478bd9Sstevel@tonic-gate 	int r;
57927c478bd9Sstevel@tonic-gate 
57937c478bd9Sstevel@tonic-gate 	r = datael_get_parent(&prop->rd_d, &pg->rd_d);
57947c478bd9Sstevel@tonic-gate 	if (r != SCF_SUCCESS) {
57957c478bd9Sstevel@tonic-gate 		HANDLE_RELE_PG(h);
57967c478bd9Sstevel@tonic-gate 		return (-1);
57977c478bd9Sstevel@tonic-gate 	}
57987c478bd9Sstevel@tonic-gate 
57997c478bd9Sstevel@tonic-gate 	len = scf_pg_to_fmri(pg, out, sz);
58007c478bd9Sstevel@tonic-gate 
58017c478bd9Sstevel@tonic-gate 	HANDLE_RELE_PG(h);
58027c478bd9Sstevel@tonic-gate 
58037c478bd9Sstevel@tonic-gate 	if (len >= sz)
58047c478bd9Sstevel@tonic-gate 		len += sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1;
58057c478bd9Sstevel@tonic-gate 	else
58067c478bd9Sstevel@tonic-gate 		len = strlcat(out, SCF_FMRI_PROPERTY_PREFIX, sz);
58077c478bd9Sstevel@tonic-gate 
58087c478bd9Sstevel@tonic-gate 	r = scf_property_get_name(prop, tmp, sizeof (tmp));
58097c478bd9Sstevel@tonic-gate 
58107c478bd9Sstevel@tonic-gate 	if (r < 0)
58117c478bd9Sstevel@tonic-gate 		return (r);
58127c478bd9Sstevel@tonic-gate 
58137c478bd9Sstevel@tonic-gate 	if (len >= sz)
58147c478bd9Sstevel@tonic-gate 		len += r;
58157c478bd9Sstevel@tonic-gate 	else
58167c478bd9Sstevel@tonic-gate 		len = strlcat(out, tmp, sz);
58177c478bd9Sstevel@tonic-gate 
58187c478bd9Sstevel@tonic-gate 	return (len);
58197c478bd9Sstevel@tonic-gate }
58207c478bd9Sstevel@tonic-gate 
582176cf44abSjeanm /*
582276cf44abSjeanm  * Fails with _HANDLE_MISMATCH, _NOT_BOUND, _CONNECTION_BROKEN, _INTERNAL
582376cf44abSjeanm  * (server response too big, bad entity id, request not applicable to entity,
582476cf44abSjeanm  * name too long for buffer, bad element id, iter already exists, element
582576cf44abSjeanm  * cannot have children of type, type is invalid, iter was reset, sequence
582676cf44abSjeanm  * was bad, iter walks values, iter does not walk type entities),
582776cf44abSjeanm  * _NOT_SET, _DELETED, or _CONSTRAINT_VIOLATED,
582876cf44abSjeanm  * _NOT_FOUND (scope has no parent),  _INVALID_ARGUMENT, _NO_RESOURCES,
582976cf44abSjeanm  * _BACKEND_ACCESS.
583076cf44abSjeanm  */
58317c478bd9Sstevel@tonic-gate int
58327c478bd9Sstevel@tonic-gate scf_pg_get_underlying_pg(const scf_propertygroup_t *pg,
58337c478bd9Sstevel@tonic-gate     scf_propertygroup_t *out)
58347c478bd9Sstevel@tonic-gate {
58357c478bd9Sstevel@tonic-gate 	scf_handle_t *h = pg->rd_d.rd_handle;
58367c478bd9Sstevel@tonic-gate 	scf_service_t *svc;
58377c478bd9Sstevel@tonic-gate 	scf_instance_t *inst;
58387c478bd9Sstevel@tonic-gate 
58397c478bd9Sstevel@tonic-gate 	char me[REP_PROTOCOL_NAME_LEN];
58407c478bd9Sstevel@tonic-gate 	int r;
58417c478bd9Sstevel@tonic-gate 
58427c478bd9Sstevel@tonic-gate 	if (h != out->rd_d.rd_handle)
58437c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_HANDLE_MISMATCH));
58447c478bd9Sstevel@tonic-gate 
58457c478bd9Sstevel@tonic-gate 	r = scf_pg_get_name(pg, me, sizeof (me));
58467c478bd9Sstevel@tonic-gate 
58477c478bd9Sstevel@tonic-gate 	if (r < 0)
58487c478bd9Sstevel@tonic-gate 		return (r);
58497c478bd9Sstevel@tonic-gate 
58507c478bd9Sstevel@tonic-gate 	svc = HANDLE_HOLD_SERVICE(h);
58517c478bd9Sstevel@tonic-gate 	inst = HANDLE_HOLD_INSTANCE(h);
58527c478bd9Sstevel@tonic-gate 
58537c478bd9Sstevel@tonic-gate 	r = datael_get_parent(&pg->rd_d, &inst->rd_d);
58547c478bd9Sstevel@tonic-gate 
58557c478bd9Sstevel@tonic-gate 	if (r == SCF_SUCCESS) {
58567c478bd9Sstevel@tonic-gate 		r = datael_get_parent(&inst->rd_d, &svc->rd_d);
58577c478bd9Sstevel@tonic-gate 		if (r != SCF_SUCCESS) {
58587c478bd9Sstevel@tonic-gate 			goto out;
58597c478bd9Sstevel@tonic-gate 		}
58607c478bd9Sstevel@tonic-gate 		r = scf_service_get_pg(svc, me, out);
58617c478bd9Sstevel@tonic-gate 	} else {
58627c478bd9Sstevel@tonic-gate 		r = scf_set_error(SCF_ERROR_NOT_FOUND);
58637c478bd9Sstevel@tonic-gate 	}
58647c478bd9Sstevel@tonic-gate 
58657c478bd9Sstevel@tonic-gate out:
58667c478bd9Sstevel@tonic-gate 	HANDLE_RELE_SERVICE(h);
58677c478bd9Sstevel@tonic-gate 	HANDLE_RELE_INSTANCE(h);
58687c478bd9Sstevel@tonic-gate 	return (r);
58697c478bd9Sstevel@tonic-gate }
58707c478bd9Sstevel@tonic-gate 
58717c478bd9Sstevel@tonic-gate #define	LEGACY_SCHEME	"lrc:"
58727c478bd9Sstevel@tonic-gate #define	LEGACY_UNKNOWN	"unknown"
58737c478bd9Sstevel@tonic-gate 
58747c478bd9Sstevel@tonic-gate /*
58757c478bd9Sstevel@tonic-gate  * Implementation of scf_walk_fmri()
58767c478bd9Sstevel@tonic-gate  *
58777c478bd9Sstevel@tonic-gate  * This is a little tricky due to the many-to-many relationship between patterns
58787c478bd9Sstevel@tonic-gate  * and matches.  We need to be able to satisfy the following requirements:
58797c478bd9Sstevel@tonic-gate  *
58807c478bd9Sstevel@tonic-gate  * 	1) Detect patterns which match more than one FMRI, and be able to
58817c478bd9Sstevel@tonic-gate  *         report which FMRIs have been matched.
58827c478bd9Sstevel@tonic-gate  * 	2) Detect patterns which have not matched any FMRIs
58837c478bd9Sstevel@tonic-gate  * 	3) Visit each matching FMRI exactly once across all patterns
58847c478bd9Sstevel@tonic-gate  * 	4) Ignore FMRIs which have only been matched due to multiply-matching
58857c478bd9Sstevel@tonic-gate  *         patterns.
58867c478bd9Sstevel@tonic-gate  *
58877c478bd9Sstevel@tonic-gate  * We maintain an array of scf_pattern_t structures, one for each argument, and
58887c478bd9Sstevel@tonic-gate  * maintain a linked list of scf_match_t structures for each one.  We first
58897c478bd9Sstevel@tonic-gate  * qualify each pattern's type:
58907c478bd9Sstevel@tonic-gate  *
58917c478bd9Sstevel@tonic-gate  *	PATTERN_INVALID		The argument is invalid (too long).
58927c478bd9Sstevel@tonic-gate  *
58937c478bd9Sstevel@tonic-gate  *	PATTERN_EXACT		The pattern is a complete FMRI.  The list of
58947c478bd9Sstevel@tonic-gate  *				matches contains only a single entry.
58957c478bd9Sstevel@tonic-gate  *
58967c478bd9Sstevel@tonic-gate  * 	PATTERN_GLOB		The pattern will be matched against all
58977c478bd9Sstevel@tonic-gate  * 				FMRIs via fnmatch() in the second phase.
58987c478bd9Sstevel@tonic-gate  * 				Matches will be added to the pattern's list
58997c478bd9Sstevel@tonic-gate  * 				as they are found.
59007c478bd9Sstevel@tonic-gate  *
59017c478bd9Sstevel@tonic-gate  * 	PATTERN_PARTIAL		Everything else.  We will assume that this is
59027c478bd9Sstevel@tonic-gate  * 				an abbreviated FMRI, and match according to
59037c478bd9Sstevel@tonic-gate  * 				our abbreviated FMRI rules.  Matches will be
59047c478bd9Sstevel@tonic-gate  * 				added to the pattern's list as they are found.
59057c478bd9Sstevel@tonic-gate  *
59067c478bd9Sstevel@tonic-gate  * The first pass searches for arguments that are complete FMRIs.  These are
59077c478bd9Sstevel@tonic-gate  * classified as EXACT patterns and do not necessitate searching the entire
59087c478bd9Sstevel@tonic-gate  * tree.
59097c478bd9Sstevel@tonic-gate  *
59107c478bd9Sstevel@tonic-gate  * Once this is done, if we have any GLOB or PARTIAL patterns (or if no
59117c478bd9Sstevel@tonic-gate  * arguments were given), we iterate over all services and instances in the
59127c478bd9Sstevel@tonic-gate  * repository, looking for matches.
59137c478bd9Sstevel@tonic-gate  *
59147c478bd9Sstevel@tonic-gate  * When a match is found, we add the match to the pattern's list.  We also enter
59157c478bd9Sstevel@tonic-gate  * the match into a hash table, resulting in something like this:
59167c478bd9Sstevel@tonic-gate  *
59177c478bd9Sstevel@tonic-gate  *       scf_pattern_t       scf_match_t
59187c478bd9Sstevel@tonic-gate  *     +---------------+      +-------+     +-------+
59197c478bd9Sstevel@tonic-gate  *     | pattern 'foo' |----->| match |---->| match |
59207c478bd9Sstevel@tonic-gate  *     +---------------+      +-------+     +-------+
59217c478bd9Sstevel@tonic-gate  *                                |             |
59227c478bd9Sstevel@tonic-gate  *           scf_match_key_t      |             |
59237c478bd9Sstevel@tonic-gate  *           +--------------+     |             |
59247c478bd9Sstevel@tonic-gate  *           | FMRI bar/foo |<----+             |
59257c478bd9Sstevel@tonic-gate  *           +--------------+                   |
59267c478bd9Sstevel@tonic-gate  *           | FMRI baz/foo |<------------------+
59277c478bd9Sstevel@tonic-gate  *           +--------------+
59287c478bd9Sstevel@tonic-gate  *
59297c478bd9Sstevel@tonic-gate  * Once we have all of this set up, we do one pass to report patterns matching
59307c478bd9Sstevel@tonic-gate  * multiple FMRIs (if SCF_WALK_MULTIPLE is not set) and patterns for which no
59317c478bd9Sstevel@tonic-gate  * match was found.
59327c478bd9Sstevel@tonic-gate  *
59337c478bd9Sstevel@tonic-gate  * Finally, we walk through all valid patterns, and for each match, if we
59347c478bd9Sstevel@tonic-gate  * haven't already seen the match (as recorded in the hash table), then we
59357c478bd9Sstevel@tonic-gate  * execute the callback.
59367c478bd9Sstevel@tonic-gate  */
59377c478bd9Sstevel@tonic-gate 
59387c478bd9Sstevel@tonic-gate struct scf_matchkey;
59397c478bd9Sstevel@tonic-gate struct scf_match;
59407c478bd9Sstevel@tonic-gate 
59417c478bd9Sstevel@tonic-gate /*
59427c478bd9Sstevel@tonic-gate  * scf_matchkey_t
59437c478bd9Sstevel@tonic-gate  */
59447c478bd9Sstevel@tonic-gate typedef struct scf_matchkey {
59457c478bd9Sstevel@tonic-gate 	char			*sk_fmri;	/* Matching FMRI */
59467c478bd9Sstevel@tonic-gate 	char			*sk_legacy;	/* Legacy name */
59477c478bd9Sstevel@tonic-gate 	int			sk_seen;	/* If we've been seen */
59487c478bd9Sstevel@tonic-gate 	struct scf_matchkey	*sk_next;	/* Next in hash chain */
59497c478bd9Sstevel@tonic-gate } scf_matchkey_t;
59507c478bd9Sstevel@tonic-gate 
59517c478bd9Sstevel@tonic-gate /*
59527c478bd9Sstevel@tonic-gate  * scf_match_t
59537c478bd9Sstevel@tonic-gate  */
59547c478bd9Sstevel@tonic-gate typedef struct scf_match {
59557c478bd9Sstevel@tonic-gate 	scf_matchkey_t		*sm_key;
59567c478bd9Sstevel@tonic-gate 	struct scf_match	*sm_next;
59577c478bd9Sstevel@tonic-gate } scf_match_t;
59587c478bd9Sstevel@tonic-gate 
59597c478bd9Sstevel@tonic-gate #define	WALK_HTABLE_SIZE	123
59607c478bd9Sstevel@tonic-gate 
59617c478bd9Sstevel@tonic-gate /*
59627c478bd9Sstevel@tonic-gate  * scf_get_key()
59637c478bd9Sstevel@tonic-gate  *
59647c478bd9Sstevel@tonic-gate  * Given an FMRI and a hash table, returns the scf_matchkey_t corresponding to
59657c478bd9Sstevel@tonic-gate  * this FMRI.  If the FMRI does not exist, it is added to the hash table.  If a
59667c478bd9Sstevel@tonic-gate  * new entry cannot be allocated due to lack of memory, NULL is returned.
59677c478bd9Sstevel@tonic-gate  */
59687c478bd9Sstevel@tonic-gate static scf_matchkey_t *
59697c478bd9Sstevel@tonic-gate scf_get_key(scf_matchkey_t **htable, const char *fmri, const char *legacy)
59707c478bd9Sstevel@tonic-gate {
59717c478bd9Sstevel@tonic-gate 	uint_t h = 0, g;
59727c478bd9Sstevel@tonic-gate 	const char *p, *k;
59737c478bd9Sstevel@tonic-gate 	scf_matchkey_t *key;
59747c478bd9Sstevel@tonic-gate 
59757c478bd9Sstevel@tonic-gate 	k = strstr(fmri, ":/");
59767c478bd9Sstevel@tonic-gate 	assert(k != NULL);
59777c478bd9Sstevel@tonic-gate 	k += 2;
59787c478bd9Sstevel@tonic-gate 
59797c478bd9Sstevel@tonic-gate 	/*
59807c478bd9Sstevel@tonic-gate 	 * Generic hash function from uts/common/os/modhash.c.
59817c478bd9Sstevel@tonic-gate 	 */
59827c478bd9Sstevel@tonic-gate 	for (p = k; *p != '\0'; ++p) {
59837c478bd9Sstevel@tonic-gate 		h = (h << 4) + *p;
59847c478bd9Sstevel@tonic-gate 		if ((g = (h & 0xf0000000)) != 0) {
59857c478bd9Sstevel@tonic-gate 			h ^= (g >> 24);
59867c478bd9Sstevel@tonic-gate 			h ^= g;
59877c478bd9Sstevel@tonic-gate 		}
59887c478bd9Sstevel@tonic-gate 	}
59897c478bd9Sstevel@tonic-gate 
59907c478bd9Sstevel@tonic-gate 	h %= WALK_HTABLE_SIZE;
59917c478bd9Sstevel@tonic-gate 
59927c478bd9Sstevel@tonic-gate 	/*
59937c478bd9Sstevel@tonic-gate 	 * Search for an existing key
59947c478bd9Sstevel@tonic-gate 	 */
59957c478bd9Sstevel@tonic-gate 	for (key = htable[h]; key != NULL; key = key->sk_next) {
59967c478bd9Sstevel@tonic-gate 		if (strcmp(key->sk_fmri, fmri) == 0)
59977c478bd9Sstevel@tonic-gate 			return (key);
59987c478bd9Sstevel@tonic-gate 	}
59997c478bd9Sstevel@tonic-gate 
60007c478bd9Sstevel@tonic-gate 	if ((key = calloc(sizeof (scf_matchkey_t), 1)) == NULL)
60017c478bd9Sstevel@tonic-gate 		return (NULL);
60027c478bd9Sstevel@tonic-gate 
60037c478bd9Sstevel@tonic-gate 	/*
60047c478bd9Sstevel@tonic-gate 	 * Add new key to hash table.
60057c478bd9Sstevel@tonic-gate 	 */
60067c478bd9Sstevel@tonic-gate 	if ((key->sk_fmri = strdup(fmri)) == NULL) {
60077c478bd9Sstevel@tonic-gate 		free(key);
60087c478bd9Sstevel@tonic-gate 		return (NULL);
60097c478bd9Sstevel@tonic-gate 	}
60107c478bd9Sstevel@tonic-gate 
60117c478bd9Sstevel@tonic-gate 	if (legacy == NULL) {
60127c478bd9Sstevel@tonic-gate 		key->sk_legacy = NULL;
60137c478bd9Sstevel@tonic-gate 	} else if ((key->sk_legacy = strdup(legacy)) == NULL) {
60147c478bd9Sstevel@tonic-gate 		free(key->sk_fmri);
60157c478bd9Sstevel@tonic-gate 		free(key);
60167c478bd9Sstevel@tonic-gate 		return (NULL);
60177c478bd9Sstevel@tonic-gate 	}
60187c478bd9Sstevel@tonic-gate 
60197c478bd9Sstevel@tonic-gate 	key->sk_next = htable[h];
60207c478bd9Sstevel@tonic-gate 	htable[h] = key;
60217c478bd9Sstevel@tonic-gate 
60227c478bd9Sstevel@tonic-gate 	return (key);
60237c478bd9Sstevel@tonic-gate }
60247c478bd9Sstevel@tonic-gate 
60257c478bd9Sstevel@tonic-gate /*
60267c478bd9Sstevel@tonic-gate  * Given an FMRI, insert it into the pattern's list appropriately.
60277c478bd9Sstevel@tonic-gate  * svc_explicit indicates whether matching services should take
60287c478bd9Sstevel@tonic-gate  * precedence over matching instances.
60297c478bd9Sstevel@tonic-gate  */
60307c478bd9Sstevel@tonic-gate static scf_error_t
60317c478bd9Sstevel@tonic-gate scf_add_match(scf_matchkey_t **htable, const char *fmri, const char *legacy,
60327c478bd9Sstevel@tonic-gate     scf_pattern_t *pattern, int svc_explicit)
60337c478bd9Sstevel@tonic-gate {
60347c478bd9Sstevel@tonic-gate 	scf_match_t *match;
60357c478bd9Sstevel@tonic-gate 
60367c478bd9Sstevel@tonic-gate 	/*
60377c478bd9Sstevel@tonic-gate 	 * If svc_explicit is set, enforce the constaint that matching
60387c478bd9Sstevel@tonic-gate 	 * instances take precedence over matching services. Otherwise,
60397c478bd9Sstevel@tonic-gate 	 * matching services take precedence over matching instances.
60407c478bd9Sstevel@tonic-gate 	 */
60417c478bd9Sstevel@tonic-gate 	if (svc_explicit) {
60427c478bd9Sstevel@tonic-gate 		scf_match_t *next, *prev;
60437c478bd9Sstevel@tonic-gate 		/*
60447c478bd9Sstevel@tonic-gate 		 * If we match an instance, check to see if we must remove
60457c478bd9Sstevel@tonic-gate 		 * any matching services (for SCF_WALK_EXPLICIT).
60467c478bd9Sstevel@tonic-gate 		 */
60477c478bd9Sstevel@tonic-gate 		for (prev = match = pattern->sp_matches; match != NULL;
60487c478bd9Sstevel@tonic-gate 		    match = next) {
60497c478bd9Sstevel@tonic-gate 			size_t len = strlen(match->sm_key->sk_fmri);
60507c478bd9Sstevel@tonic-gate 			next = match->sm_next;
60517c478bd9Sstevel@tonic-gate 			if (strncmp(match->sm_key->sk_fmri, fmri, len) == 0 &&
60527c478bd9Sstevel@tonic-gate 			    fmri[len] == ':') {
60537c478bd9Sstevel@tonic-gate 				if (prev == match)
60547c478bd9Sstevel@tonic-gate 					pattern->sp_matches = match->sm_next;
60557c478bd9Sstevel@tonic-gate 				else
60567c478bd9Sstevel@tonic-gate 					prev->sm_next = match->sm_next;
60577c478bd9Sstevel@tonic-gate 				pattern->sp_matchcount--;
60587c478bd9Sstevel@tonic-gate 				free(match);
60597c478bd9Sstevel@tonic-gate 			} else
60607c478bd9Sstevel@tonic-gate 				prev = match;
60617c478bd9Sstevel@tonic-gate 		}
60627c478bd9Sstevel@tonic-gate 	} else {
60637c478bd9Sstevel@tonic-gate 		/*
60647c478bd9Sstevel@tonic-gate 		 * If we've matched a service don't add any instances (for
60657c478bd9Sstevel@tonic-gate 		 * SCF_WALK_SERVICE).
60667c478bd9Sstevel@tonic-gate 		 */
60677c478bd9Sstevel@tonic-gate 		for (match = pattern->sp_matches; match != NULL;
60687c478bd9Sstevel@tonic-gate 		    match = match->sm_next) {
60697c478bd9Sstevel@tonic-gate 			size_t len = strlen(match->sm_key->sk_fmri);
60707c478bd9Sstevel@tonic-gate 			if (strncmp(match->sm_key->sk_fmri, fmri, len) == 0 &&
60717c478bd9Sstevel@tonic-gate 			    fmri[len] == ':')
60727c478bd9Sstevel@tonic-gate 				return (0);
60737c478bd9Sstevel@tonic-gate 		}
60747c478bd9Sstevel@tonic-gate 	}
60757c478bd9Sstevel@tonic-gate 
60767c478bd9Sstevel@tonic-gate 	if ((match = malloc(sizeof (scf_match_t))) == NULL)
60777c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_NO_MEMORY);
60787c478bd9Sstevel@tonic-gate 
60797c478bd9Sstevel@tonic-gate 	if ((match->sm_key = scf_get_key(htable, fmri, legacy)) == NULL) {
60807c478bd9Sstevel@tonic-gate 		free(match);
60817c478bd9Sstevel@tonic-gate 		return (SCF_ERROR_NO_MEMORY);
60827c478bd9Sstevel@tonic-gate 	}
60837c478bd9Sstevel@tonic-gate 
60847c478bd9Sstevel@tonic-gate 	match->sm_next = pattern->sp_matches;
60857c478bd9Sstevel@tonic-gate 	pattern->sp_matches = match;
60867c478bd9Sstevel@tonic-gate 	pattern->sp_matchcount++;
60877c478bd9Sstevel@tonic-gate 
60887c478bd9Sstevel@tonic-gate 	return (0);
60897c478bd9Sstevel@tonic-gate }
60907c478bd9Sstevel@tonic-gate 
60917c478bd9Sstevel@tonic-gate /*
60927c478bd9Sstevel@tonic-gate  * Returns 1 if the fmri matches the given pattern, 0 otherwise.
60937c478bd9Sstevel@tonic-gate  */
6094103b2b15Sgww int
60957c478bd9Sstevel@tonic-gate scf_cmp_pattern(char *fmri, scf_pattern_t *pattern)
60967c478bd9Sstevel@tonic-gate {
60977c478bd9Sstevel@tonic-gate 	char *tmp;
60987c478bd9Sstevel@tonic-gate 
60997c478bd9Sstevel@tonic-gate 	if (pattern->sp_type == PATTERN_GLOB) {
61007c478bd9Sstevel@tonic-gate 		if (fnmatch(pattern->sp_arg, fmri, 0) == 0)
61017c478bd9Sstevel@tonic-gate 			return (1);
61027c478bd9Sstevel@tonic-gate 	} else if (pattern->sp_type == PATTERN_PARTIAL &&
61037c478bd9Sstevel@tonic-gate 	    (tmp = strstr(fmri, pattern->sp_arg)) != NULL) {
61047c478bd9Sstevel@tonic-gate 		/*
61057c478bd9Sstevel@tonic-gate 		 * We only allow partial matches anchored on the end of
61067c478bd9Sstevel@tonic-gate 		 * a service or instance, and beginning on an element
61077c478bd9Sstevel@tonic-gate 		 * boundary.
61087c478bd9Sstevel@tonic-gate 		 */
61097c478bd9Sstevel@tonic-gate 		if (tmp != fmri && tmp[-1] != '/' && tmp[-1] != ':' &&
61107c478bd9Sstevel@tonic-gate 		    tmp[0] != ':')
61117c478bd9Sstevel@tonic-gate 			return (0);
61127c478bd9Sstevel@tonic-gate 		tmp += strlen(pattern->sp_arg);
61137c478bd9Sstevel@tonic-gate 		if (tmp != fmri + strlen(fmri) && tmp[0] != ':' &&
61147c478bd9Sstevel@tonic-gate 		    tmp[-1] != ':')
61157c478bd9Sstevel@tonic-gate 			return (0);
61167c478bd9Sstevel@tonic-gate 
61177c478bd9Sstevel@tonic-gate 		/*
61187c478bd9Sstevel@tonic-gate 		 * If the user has supplied a short pattern that matches
61197c478bd9Sstevel@tonic-gate 		 * 'svc:/' or 'lrc:/', ignore it.
61207c478bd9Sstevel@tonic-gate 		 */
61217c478bd9Sstevel@tonic-gate 		if (tmp <= fmri + 4)
61227c478bd9Sstevel@tonic-gate 			return (0);
61237c478bd9Sstevel@tonic-gate 
61247c478bd9Sstevel@tonic-gate 		return (1);
61257c478bd9Sstevel@tonic-gate 	}
61267c478bd9Sstevel@tonic-gate 
61277c478bd9Sstevel@tonic-gate 	return (0);
61287c478bd9Sstevel@tonic-gate }
61297c478bd9Sstevel@tonic-gate 
61307c478bd9Sstevel@tonic-gate /*
61317c478bd9Sstevel@tonic-gate  * Attempts to match the given FMRI against a set of patterns, keeping track of
61327c478bd9Sstevel@tonic-gate  * the results.
61337c478bd9Sstevel@tonic-gate  */
61347c478bd9Sstevel@tonic-gate static scf_error_t
61357c478bd9Sstevel@tonic-gate scf_pattern_match(scf_matchkey_t **htable, char *fmri, const char *legacy,
61367c478bd9Sstevel@tonic-gate     int npattern, scf_pattern_t *pattern, int svc_explicit)
61377c478bd9Sstevel@tonic-gate {
61387c478bd9Sstevel@tonic-gate 	int i;
61397c478bd9Sstevel@tonic-gate 	int ret = 0;
61407c478bd9Sstevel@tonic-gate 
61417c478bd9Sstevel@tonic-gate 	for (i = 0; i < npattern; i++) {
61427c478bd9Sstevel@tonic-gate 		if (scf_cmp_pattern(fmri, &pattern[i]) &&
61437c478bd9Sstevel@tonic-gate 		    (ret = scf_add_match(htable, fmri,
61447c478bd9Sstevel@tonic-gate 		    legacy, &pattern[i], svc_explicit)) != 0)
61457c478bd9Sstevel@tonic-gate 			return (ret);
61467c478bd9Sstevel@tonic-gate 	}
61477c478bd9Sstevel@tonic-gate 
61487c478bd9Sstevel@tonic-gate 	return (0);
61497c478bd9Sstevel@tonic-gate }
61507c478bd9Sstevel@tonic-gate 
615176cf44abSjeanm /*
615276cf44abSjeanm  * Fails with _INVALID_ARGUMENT, _HANDLE_DESTROYED, _INTERNAL (bad server
615376cf44abSjeanm  * response or id in use), _NO_MEMORY, _HANDLE_MISMATCH, _CONSTRAINT_VIOLATED,
615476cf44abSjeanm  * _NOT_FOUND, _NOT_BOUND, _CONNECTION_BROKEN, _NOT_SET, _DELETED,
615576cf44abSjeanm  * _NO_RESOURCES, _BACKEND_ACCESS, _TYPE_MISMATCH.
615676cf44abSjeanm  */
61577c478bd9Sstevel@tonic-gate scf_error_t
61587c478bd9Sstevel@tonic-gate scf_walk_fmri(scf_handle_t *h, int argc, char **argv, int flags,
61597c478bd9Sstevel@tonic-gate     scf_walk_callback callback, void *data, int *err,
61607c478bd9Sstevel@tonic-gate     void (*errfunc)(const char *, ...))
61617c478bd9Sstevel@tonic-gate {
61627c478bd9Sstevel@tonic-gate 	scf_pattern_t *pattern = NULL;
61637c478bd9Sstevel@tonic-gate 	int i;
61647c478bd9Sstevel@tonic-gate 	char *fmri = NULL;
61657c478bd9Sstevel@tonic-gate 	ssize_t max_fmri_length;
61667c478bd9Sstevel@tonic-gate 	scf_service_t *svc = NULL;
61677c478bd9Sstevel@tonic-gate 	scf_instance_t *inst = NULL;
61687c478bd9Sstevel@tonic-gate 	scf_iter_t *iter = NULL, *sciter = NULL, *siter = NULL;
61697c478bd9Sstevel@tonic-gate 	scf_scope_t *scope = NULL;
61707c478bd9Sstevel@tonic-gate 	scf_propertygroup_t *pg = NULL;
61717c478bd9Sstevel@tonic-gate 	scf_property_t *prop = NULL;
61727c478bd9Sstevel@tonic-gate 	scf_value_t *value = NULL;
61737c478bd9Sstevel@tonic-gate 	int ret = 0;
61747c478bd9Sstevel@tonic-gate 	scf_matchkey_t **htable = NULL;
61757c478bd9Sstevel@tonic-gate 	int pattern_search = 0;
61767c478bd9Sstevel@tonic-gate 	ssize_t max_name_length;
61777c478bd9Sstevel@tonic-gate 	char *pgname = NULL;
61787c478bd9Sstevel@tonic-gate 	scf_walkinfo_t info;
61797c478bd9Sstevel@tonic-gate 
61807c478bd9Sstevel@tonic-gate #ifndef NDEBUG
61817c478bd9Sstevel@tonic-gate 	if (flags & SCF_WALK_EXPLICIT)
61827c478bd9Sstevel@tonic-gate 		assert(flags & SCF_WALK_SERVICE);
61837c478bd9Sstevel@tonic-gate 	if (flags & SCF_WALK_NOINSTANCE)
61847c478bd9Sstevel@tonic-gate 		assert(flags & SCF_WALK_SERVICE);
61857c478bd9Sstevel@tonic-gate 	if (flags & SCF_WALK_PROPERTY)
61867c478bd9Sstevel@tonic-gate 		assert(!(flags & SCF_WALK_LEGACY));
61877c478bd9Sstevel@tonic-gate #endif
61887c478bd9Sstevel@tonic-gate 
61897c478bd9Sstevel@tonic-gate 	/*
61907c478bd9Sstevel@tonic-gate 	 * Setup initial variables
61917c478bd9Sstevel@tonic-gate 	 */
6192*1f6eb021SLiane Praza 	max_fmri_length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
6193*1f6eb021SLiane Praza 	assert(max_fmri_length != -1);
6194*1f6eb021SLiane Praza 	max_name_length = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
6195*1f6eb021SLiane Praza 	assert(max_name_length != -1);
61967c478bd9Sstevel@tonic-gate 
61977c478bd9Sstevel@tonic-gate 	if ((fmri = malloc(max_fmri_length + 1)) == NULL ||
61987c478bd9Sstevel@tonic-gate 	    (pgname = malloc(max_name_length + 1)) == NULL) {
61997c478bd9Sstevel@tonic-gate 		ret = SCF_ERROR_NO_MEMORY;
62007c478bd9Sstevel@tonic-gate 		goto error;
62017c478bd9Sstevel@tonic-gate 	}
62027c478bd9Sstevel@tonic-gate 
62037c478bd9Sstevel@tonic-gate 	if (argc == 0) {
62047c478bd9Sstevel@tonic-gate 		pattern = NULL;
62057c478bd9Sstevel@tonic-gate 	} else if ((pattern = calloc(argc, sizeof (scf_pattern_t)))
62067c478bd9Sstevel@tonic-gate 	    == NULL) {
62077c478bd9Sstevel@tonic-gate 		ret = SCF_ERROR_NO_MEMORY;
62087c478bd9Sstevel@tonic-gate 		goto error;
62097c478bd9Sstevel@tonic-gate 	}
62107c478bd9Sstevel@tonic-gate 
62117c478bd9Sstevel@tonic-gate 	if ((htable = calloc(WALK_HTABLE_SIZE, sizeof (void *))) == NULL) {
62127c478bd9Sstevel@tonic-gate 		ret = SCF_ERROR_NO_MEMORY;
62137c478bd9Sstevel@tonic-gate 		goto error;
62147c478bd9Sstevel@tonic-gate 	}
62157c478bd9Sstevel@tonic-gate 
62167c478bd9Sstevel@tonic-gate 	if ((inst = scf_instance_create(h)) == NULL ||
62177c478bd9Sstevel@tonic-gate 	    (svc = scf_service_create(h)) == NULL ||
62187c478bd9Sstevel@tonic-gate 	    (iter = scf_iter_create(h)) == NULL ||
62197c478bd9Sstevel@tonic-gate 	    (sciter = scf_iter_create(h)) == NULL ||
62207c478bd9Sstevel@tonic-gate 	    (siter = scf_iter_create(h)) == NULL ||
62217c478bd9Sstevel@tonic-gate 	    (scope = scf_scope_create(h)) == NULL ||
62227c478bd9Sstevel@tonic-gate 	    (pg = scf_pg_create(h)) == NULL ||
62237c478bd9Sstevel@tonic-gate 	    (prop = scf_property_create(h)) == NULL ||
62247c478bd9Sstevel@tonic-gate 	    (value = scf_value_create(h)) == NULL) {
62257c478bd9Sstevel@tonic-gate 		ret = scf_error();
62267c478bd9Sstevel@tonic-gate 		goto error;
62277c478bd9Sstevel@tonic-gate 	}
62287c478bd9Sstevel@tonic-gate 
62297c478bd9Sstevel@tonic-gate 	/*
62307c478bd9Sstevel@tonic-gate 	 * For each fmri given, we first check to see if it's a full service,
62317c478bd9Sstevel@tonic-gate 	 * instance, property group, or property FMRI.  This avoids having to do
62327c478bd9Sstevel@tonic-gate 	 * the (rather expensive) walk of all instances.  Any element which does
62337c478bd9Sstevel@tonic-gate 	 * not match a full fmri is identified as a globbed pattern or a partial
62347c478bd9Sstevel@tonic-gate 	 * fmri and stored in a private array when walking instances.
62357c478bd9Sstevel@tonic-gate 	 */
62367c478bd9Sstevel@tonic-gate 	for (i = 0; i < argc; i++) {
62377c478bd9Sstevel@tonic-gate 		const char *scope_name, *svc_name, *inst_name, *pg_name;
62387c478bd9Sstevel@tonic-gate 		const char *prop_name;
62397c478bd9Sstevel@tonic-gate 
62407c478bd9Sstevel@tonic-gate 		if (strlen(argv[i]) > max_fmri_length) {
62417c478bd9Sstevel@tonic-gate 			errfunc(scf_get_msg(SCF_MSG_ARGTOOLONG), argv[i]);
62427c478bd9Sstevel@tonic-gate 			if (err != NULL)
62437c478bd9Sstevel@tonic-gate 				*err = UU_EXIT_FATAL;
62447c478bd9Sstevel@tonic-gate 			continue;
62457c478bd9Sstevel@tonic-gate 		}
62467c478bd9Sstevel@tonic-gate 
62477c478bd9Sstevel@tonic-gate 		(void) strcpy(fmri, argv[i]);
62487c478bd9Sstevel@tonic-gate 		if (scf_parse_svc_fmri(fmri, &scope_name, &svc_name, &inst_name,
62497c478bd9Sstevel@tonic-gate 		    &pg_name, &prop_name) != SCF_SUCCESS)
62507c478bd9Sstevel@tonic-gate 			goto badfmri;
62517c478bd9Sstevel@tonic-gate 
62527c478bd9Sstevel@tonic-gate 		/*
62537c478bd9Sstevel@tonic-gate 		 * If the user has specified SCF_WALK_PROPERTY, allow property
62547c478bd9Sstevel@tonic-gate 		 * groups and properties.
62557c478bd9Sstevel@tonic-gate 		 */
62567c478bd9Sstevel@tonic-gate 		if (pg_name != NULL || prop_name != NULL) {
62577c478bd9Sstevel@tonic-gate 			if (!(flags & SCF_WALK_PROPERTY))
62587c478bd9Sstevel@tonic-gate 				goto badfmri;
62597c478bd9Sstevel@tonic-gate 
62607c478bd9Sstevel@tonic-gate 			if (scf_handle_decode_fmri(h, argv[i], NULL, NULL,
62617c478bd9Sstevel@tonic-gate 			    NULL, pg, prop, 0) != 0)
62627c478bd9Sstevel@tonic-gate 				goto badfmri;
62637c478bd9Sstevel@tonic-gate 
62647c478bd9Sstevel@tonic-gate 			if (scf_pg_get_name(pg, NULL, 0) < 0 &&
62657c478bd9Sstevel@tonic-gate 			    scf_property_get_name(prop, NULL, 0) < 0)
62667c478bd9Sstevel@tonic-gate 				goto badfmri;
62677c478bd9Sstevel@tonic-gate 
62687c478bd9Sstevel@tonic-gate 			if (scf_canonify_fmri(argv[i], fmri, max_fmri_length)
62697c478bd9Sstevel@tonic-gate 			    <= 0) {
62707c478bd9Sstevel@tonic-gate 				/*
62717c478bd9Sstevel@tonic-gate 				 * scf_parse_fmri() should have caught this.
62727c478bd9Sstevel@tonic-gate 				 */
62737c478bd9Sstevel@tonic-gate 				abort();
62747c478bd9Sstevel@tonic-gate 			}
62757c478bd9Sstevel@tonic-gate 
62767c478bd9Sstevel@tonic-gate 			if ((ret = scf_add_match(htable, fmri, NULL,
62777c478bd9Sstevel@tonic-gate 			    &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0)
62787c478bd9Sstevel@tonic-gate 				goto error;
62797c478bd9Sstevel@tonic-gate 
62807c478bd9Sstevel@tonic-gate 			if ((pattern[i].sp_arg = strdup(argv[i])) == NULL) {
62817c478bd9Sstevel@tonic-gate 				ret = SCF_ERROR_NO_MEMORY;
62827c478bd9Sstevel@tonic-gate 				goto error;
62837c478bd9Sstevel@tonic-gate 			}
62847c478bd9Sstevel@tonic-gate 			pattern[i].sp_type = PATTERN_EXACT;
62857c478bd9Sstevel@tonic-gate 		}
62867c478bd9Sstevel@tonic-gate 
62877c478bd9Sstevel@tonic-gate 		/*
62887c478bd9Sstevel@tonic-gate 		 * We need at least a service name
62897c478bd9Sstevel@tonic-gate 		 */
62907c478bd9Sstevel@tonic-gate 		if (scope_name == NULL || svc_name == NULL)
62917c478bd9Sstevel@tonic-gate 			goto badfmri;
62927c478bd9Sstevel@tonic-gate 
62937c478bd9Sstevel@tonic-gate 		/*
62947c478bd9Sstevel@tonic-gate 		 * If we have a fully qualified instance, add it to our list of
62957c478bd9Sstevel@tonic-gate 		 * fmris to watch.
62967c478bd9Sstevel@tonic-gate 		 */
62977c478bd9Sstevel@tonic-gate 		if (inst_name != NULL) {
62987c478bd9Sstevel@tonic-gate 			if (flags & SCF_WALK_NOINSTANCE)
62997c478bd9Sstevel@tonic-gate 				goto badfmri;
63007c478bd9Sstevel@tonic-gate 
63017c478bd9Sstevel@tonic-gate 			if (scf_handle_decode_fmri(h, argv[i], NULL, NULL,
63027c478bd9Sstevel@tonic-gate 			    inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0)
63037c478bd9Sstevel@tonic-gate 				goto badfmri;
63047c478bd9Sstevel@tonic-gate 
63057c478bd9Sstevel@tonic-gate 			if (scf_canonify_fmri(argv[i], fmri, max_fmri_length)
63067c478bd9Sstevel@tonic-gate 			    <= 0)
63077c478bd9Sstevel@tonic-gate 				goto badfmri;
63087c478bd9Sstevel@tonic-gate 
63097c478bd9Sstevel@tonic-gate 			if ((ret = scf_add_match(htable, fmri, NULL,
63107c478bd9Sstevel@tonic-gate 			    &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0)
63117c478bd9Sstevel@tonic-gate 				goto error;
63127c478bd9Sstevel@tonic-gate 
63137c478bd9Sstevel@tonic-gate 			if ((pattern[i].sp_arg = strdup(argv[i])) == NULL) {
63147c478bd9Sstevel@tonic-gate 				ret = SCF_ERROR_NO_MEMORY;
63157c478bd9Sstevel@tonic-gate 				goto error;
63167c478bd9Sstevel@tonic-gate 			}
63177c478bd9Sstevel@tonic-gate 			pattern[i].sp_type = PATTERN_EXACT;
63187c478bd9Sstevel@tonic-gate 
63197c478bd9Sstevel@tonic-gate 			continue;
63207c478bd9Sstevel@tonic-gate 		}
63217c478bd9Sstevel@tonic-gate 
63227c478bd9Sstevel@tonic-gate 		if (scf_handle_decode_fmri(h, argv[i], NULL, svc,
63237c478bd9Sstevel@tonic-gate 		    NULL, NULL, NULL, SCF_DECODE_FMRI_EXACT) !=
63247c478bd9Sstevel@tonic-gate 		    SCF_SUCCESS)
63257c478bd9Sstevel@tonic-gate 			goto badfmri;
63267c478bd9Sstevel@tonic-gate 
63277c478bd9Sstevel@tonic-gate 		/*
63287c478bd9Sstevel@tonic-gate 		 * If the user allows for bare services, then simply
63297c478bd9Sstevel@tonic-gate 		 * pass this service on.
63307c478bd9Sstevel@tonic-gate 		 */
63317c478bd9Sstevel@tonic-gate 		if (flags & SCF_WALK_SERVICE) {
63327c478bd9Sstevel@tonic-gate 			if (scf_service_to_fmri(svc, fmri,
63337c478bd9Sstevel@tonic-gate 			    max_fmri_length + 1) <= 0) {
63347c478bd9Sstevel@tonic-gate 				ret = scf_error();
63357c478bd9Sstevel@tonic-gate 				goto error;
63367c478bd9Sstevel@tonic-gate 			}
63377c478bd9Sstevel@tonic-gate 
63387c478bd9Sstevel@tonic-gate 			if ((ret = scf_add_match(htable, fmri, NULL,
63397c478bd9Sstevel@tonic-gate 			    &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0)
63407c478bd9Sstevel@tonic-gate 				goto error;
63417c478bd9Sstevel@tonic-gate 
63427c478bd9Sstevel@tonic-gate 			if ((pattern[i].sp_arg = strdup(argv[i]))
63437c478bd9Sstevel@tonic-gate 			    == NULL) {
63447c478bd9Sstevel@tonic-gate 				ret = SCF_ERROR_NO_MEMORY;
63457c478bd9Sstevel@tonic-gate 				goto error;
63467c478bd9Sstevel@tonic-gate 			}
63477c478bd9Sstevel@tonic-gate 			pattern[i].sp_type = PATTERN_EXACT;
63487c478bd9Sstevel@tonic-gate 			continue;
63497c478bd9Sstevel@tonic-gate 		}
63507c478bd9Sstevel@tonic-gate 
63517c478bd9Sstevel@tonic-gate 		if (flags & SCF_WALK_NOINSTANCE)
63527c478bd9Sstevel@tonic-gate 			goto badfmri;
63537c478bd9Sstevel@tonic-gate 
63547c478bd9Sstevel@tonic-gate 		/*
63557c478bd9Sstevel@tonic-gate 		 * Otherwise, iterate over all instances in the service.
63567c478bd9Sstevel@tonic-gate 		 */
63577c478bd9Sstevel@tonic-gate 		if (scf_iter_service_instances(iter, svc) !=
63587c478bd9Sstevel@tonic-gate 		    SCF_SUCCESS) {
63597c478bd9Sstevel@tonic-gate 			ret = scf_error();
63607c478bd9Sstevel@tonic-gate 			goto error;
63617c478bd9Sstevel@tonic-gate 		}
63627c478bd9Sstevel@tonic-gate 
63637c478bd9Sstevel@tonic-gate 		for (;;) {
63647c478bd9Sstevel@tonic-gate 			ret = scf_iter_next_instance(iter, inst);
63657c478bd9Sstevel@tonic-gate 			if (ret == 0)
63667c478bd9Sstevel@tonic-gate 				break;
63677c478bd9Sstevel@tonic-gate 			if (ret != 1) {
63687c478bd9Sstevel@tonic-gate 				ret = scf_error();
63697c478bd9Sstevel@tonic-gate 				goto error;
63707c478bd9Sstevel@tonic-gate 			}
63717c478bd9Sstevel@tonic-gate 
63727c478bd9Sstevel@tonic-gate 			if (scf_instance_to_fmri(inst, fmri,
63737c478bd9Sstevel@tonic-gate 			    max_fmri_length + 1) == -1)
63747c478bd9Sstevel@tonic-gate 				goto badfmri;
63757c478bd9Sstevel@tonic-gate 
63767c478bd9Sstevel@tonic-gate 			if ((ret = scf_add_match(htable, fmri, NULL,
63777c478bd9Sstevel@tonic-gate 			    &pattern[i], flags & SCF_WALK_EXPLICIT)) != 0)
63787c478bd9Sstevel@tonic-gate 				goto error;
63797c478bd9Sstevel@tonic-gate 		}
63807c478bd9Sstevel@tonic-gate 
63817c478bd9Sstevel@tonic-gate 		if ((pattern[i].sp_arg = strdup(argv[i])) == NULL) {
63827c478bd9Sstevel@tonic-gate 			ret = SCF_ERROR_NO_MEMORY;
63837c478bd9Sstevel@tonic-gate 			goto error;
63847c478bd9Sstevel@tonic-gate 		}
63857c478bd9Sstevel@tonic-gate 		pattern[i].sp_type = PATTERN_EXACT;
63867c478bd9Sstevel@tonic-gate 
63877c478bd9Sstevel@tonic-gate 		continue;
63887c478bd9Sstevel@tonic-gate 
63897c478bd9Sstevel@tonic-gate badfmri:
63907c478bd9Sstevel@tonic-gate 
63917c478bd9Sstevel@tonic-gate 		/*
63927c478bd9Sstevel@tonic-gate 		 * If we got here because of a fatal error, bail out
63937c478bd9Sstevel@tonic-gate 		 * immediately.
63947c478bd9Sstevel@tonic-gate 		 */
63957c478bd9Sstevel@tonic-gate 		if (scf_error() == SCF_ERROR_CONNECTION_BROKEN) {
63967c478bd9Sstevel@tonic-gate 			ret = scf_error();
63977c478bd9Sstevel@tonic-gate 			goto error;
63987c478bd9Sstevel@tonic-gate 		}
63997c478bd9Sstevel@tonic-gate 
64007c478bd9Sstevel@tonic-gate 		/*
64017c478bd9Sstevel@tonic-gate 		 * At this point we failed to interpret the argument as a
64027c478bd9Sstevel@tonic-gate 		 * complete fmri, so mark it as a partial or globbed FMRI for
64037c478bd9Sstevel@tonic-gate 		 * later processing.
64047c478bd9Sstevel@tonic-gate 		 */
64057c478bd9Sstevel@tonic-gate 		if (strpbrk(argv[i], "*?[") != NULL) {
64067c478bd9Sstevel@tonic-gate 			/*
64077c478bd9Sstevel@tonic-gate 			 * Prepend svc:/ to patterns which don't begin with * or
64087c478bd9Sstevel@tonic-gate 			 * svc: or lrc:.
64097c478bd9Sstevel@tonic-gate 			 */
64107c478bd9Sstevel@tonic-gate 			pattern[i].sp_type = PATTERN_GLOB;
64117c478bd9Sstevel@tonic-gate 			if (argv[i][0] == '*' ||
64127c478bd9Sstevel@tonic-gate 			    (strlen(argv[i]) >= 4 && argv[i][3] == ':'))
64137c478bd9Sstevel@tonic-gate 				pattern[i].sp_arg = strdup(argv[i]);
64147c478bd9Sstevel@tonic-gate 			else {
64157c478bd9Sstevel@tonic-gate 				pattern[i].sp_arg = malloc(strlen(argv[i]) + 6);
64167c478bd9Sstevel@tonic-gate 				if (pattern[i].sp_arg != NULL)
64177c478bd9Sstevel@tonic-gate 					(void) snprintf(pattern[i].sp_arg,
64187c478bd9Sstevel@tonic-gate 					    strlen(argv[i]) + 6, "svc:/%s",
64197c478bd9Sstevel@tonic-gate 					    argv[i]);
64207c478bd9Sstevel@tonic-gate 			}
64217c478bd9Sstevel@tonic-gate 		} else {
64227c478bd9Sstevel@tonic-gate 			pattern[i].sp_type = PATTERN_PARTIAL;
64237c478bd9Sstevel@tonic-gate 			pattern[i].sp_arg = strdup(argv[i]);
64247c478bd9Sstevel@tonic-gate 		}
64257c478bd9Sstevel@tonic-gate 		pattern_search = 1;
64267c478bd9Sstevel@tonic-gate 		if (pattern[i].sp_arg == NULL) {
64277c478bd9Sstevel@tonic-gate 			ret = SCF_ERROR_NO_MEMORY;
64287c478bd9Sstevel@tonic-gate 			goto error;
64297c478bd9Sstevel@tonic-gate 		}
64307c478bd9Sstevel@tonic-gate 	}
64317c478bd9Sstevel@tonic-gate 
64327c478bd9Sstevel@tonic-gate 	if (pattern_search || argc == 0) {
64337c478bd9Sstevel@tonic-gate 		/*
64347c478bd9Sstevel@tonic-gate 		 * We have a set of patterns to search for.  Iterate over all
64357c478bd9Sstevel@tonic-gate 		 * instances and legacy services searching for matches.
64367c478bd9Sstevel@tonic-gate 		 */
64377c478bd9Sstevel@tonic-gate 		if (scf_handle_get_local_scope(h, scope) != 0) {
64387c478bd9Sstevel@tonic-gate 			ret = scf_error();
64397c478bd9Sstevel@tonic-gate 			goto error;
64407c478bd9Sstevel@tonic-gate 		}
64417c478bd9Sstevel@tonic-gate 
64427c478bd9Sstevel@tonic-gate 		if (scf_iter_scope_services(sciter, scope) != 0) {
64437c478bd9Sstevel@tonic-gate 			ret = scf_error();
64447c478bd9Sstevel@tonic-gate 			goto error;
64457c478bd9Sstevel@tonic-gate 		}
64467c478bd9Sstevel@tonic-gate 
64477c478bd9Sstevel@tonic-gate 		for (;;) {
64487c478bd9Sstevel@tonic-gate 			ret = scf_iter_next_service(sciter, svc);
64497c478bd9Sstevel@tonic-gate 			if (ret == 0)
64507c478bd9Sstevel@tonic-gate 				break;
64517c478bd9Sstevel@tonic-gate 			if (ret != 1) {
64527c478bd9Sstevel@tonic-gate 				ret = scf_error();
64537c478bd9Sstevel@tonic-gate 				goto error;
64547c478bd9Sstevel@tonic-gate 			}
64557c478bd9Sstevel@tonic-gate 
64567c478bd9Sstevel@tonic-gate 			if (flags & SCF_WALK_SERVICE) {
64577c478bd9Sstevel@tonic-gate 				/*
64587c478bd9Sstevel@tonic-gate 				 * If the user is requesting bare services, try
64597c478bd9Sstevel@tonic-gate 				 * to match the service first.
64607c478bd9Sstevel@tonic-gate 				 */
64617c478bd9Sstevel@tonic-gate 				if (scf_service_to_fmri(svc, fmri,
64627c478bd9Sstevel@tonic-gate 				    max_fmri_length + 1) < 0) {
64637c478bd9Sstevel@tonic-gate 					ret = scf_error();
64647c478bd9Sstevel@tonic-gate 					goto error;
64657c478bd9Sstevel@tonic-gate 				}
64667c478bd9Sstevel@tonic-gate 
64677c478bd9Sstevel@tonic-gate 				if (argc == 0) {
64687c478bd9Sstevel@tonic-gate 					info.fmri = fmri;
64697c478bd9Sstevel@tonic-gate 					info.scope = scope;
64707c478bd9Sstevel@tonic-gate 					info.svc = svc;
64717c478bd9Sstevel@tonic-gate 					info.inst = NULL;
64727c478bd9Sstevel@tonic-gate 					info.pg = NULL;
64737c478bd9Sstevel@tonic-gate 					info.prop = NULL;
64747c478bd9Sstevel@tonic-gate 					if ((ret = callback(data, &info)) != 0)
64757c478bd9Sstevel@tonic-gate 						goto error;
64767c478bd9Sstevel@tonic-gate 					continue;
64777c478bd9Sstevel@tonic-gate 				} else if ((ret = scf_pattern_match(htable,
64787c478bd9Sstevel@tonic-gate 				    fmri, NULL, argc, pattern,
64797c478bd9Sstevel@tonic-gate 				    flags & SCF_WALK_EXPLICIT)) != 0) {
64807c478bd9Sstevel@tonic-gate 					goto error;
64817c478bd9Sstevel@tonic-gate 				}
64827c478bd9Sstevel@tonic-gate 			}
64837c478bd9Sstevel@tonic-gate 
64847c478bd9Sstevel@tonic-gate 			if (flags & SCF_WALK_NOINSTANCE)
64857c478bd9Sstevel@tonic-gate 				continue;
64867c478bd9Sstevel@tonic-gate 
64877c478bd9Sstevel@tonic-gate 			/*
64887c478bd9Sstevel@tonic-gate 			 * Iterate over all instances in the service.
64897c478bd9Sstevel@tonic-gate 			 */
64907c478bd9Sstevel@tonic-gate 			if (scf_iter_service_instances(siter, svc) != 0) {
64917c478bd9Sstevel@tonic-gate 				if (scf_error() != SCF_ERROR_DELETED) {
64927c478bd9Sstevel@tonic-gate 					ret = scf_error();
64937c478bd9Sstevel@tonic-gate 					goto error;
64947c478bd9Sstevel@tonic-gate 				}
64957c478bd9Sstevel@tonic-gate 				continue;
64967c478bd9Sstevel@tonic-gate 			}
64977c478bd9Sstevel@tonic-gate 
64987c478bd9Sstevel@tonic-gate 			for (;;) {
64997c478bd9Sstevel@tonic-gate 				ret = scf_iter_next_instance(siter, inst);
65007c478bd9Sstevel@tonic-gate 				if (ret == 0)
65017c478bd9Sstevel@tonic-gate 					break;
65027c478bd9Sstevel@tonic-gate 				if (ret != 1) {
65037c478bd9Sstevel@tonic-gate 					if (scf_error() != SCF_ERROR_DELETED) {
65047c478bd9Sstevel@tonic-gate 						ret = scf_error();
65057c478bd9Sstevel@tonic-gate 						goto error;
65067c478bd9Sstevel@tonic-gate 					}
65077c478bd9Sstevel@tonic-gate 					break;
65087c478bd9Sstevel@tonic-gate 				}
65097c478bd9Sstevel@tonic-gate 
65107c478bd9Sstevel@tonic-gate 				if (scf_instance_to_fmri(inst, fmri,
65117c478bd9Sstevel@tonic-gate 				    max_fmri_length + 1) < 0) {
65127c478bd9Sstevel@tonic-gate 					ret = scf_error();
65137c478bd9Sstevel@tonic-gate 					goto error;
65147c478bd9Sstevel@tonic-gate 				}
65157c478bd9Sstevel@tonic-gate 
65167c478bd9Sstevel@tonic-gate 				/*
65177c478bd9Sstevel@tonic-gate 				 * Without arguments, execute the callback
65187c478bd9Sstevel@tonic-gate 				 * immediately.
65197c478bd9Sstevel@tonic-gate 				 */
65207c478bd9Sstevel@tonic-gate 				if (argc == 0) {
65217c478bd9Sstevel@tonic-gate 					info.fmri = fmri;
65227c478bd9Sstevel@tonic-gate 					info.scope = scope;
65237c478bd9Sstevel@tonic-gate 					info.svc = svc;
65247c478bd9Sstevel@tonic-gate 					info.inst = inst;
65257c478bd9Sstevel@tonic-gate 					info.pg = NULL;
65267c478bd9Sstevel@tonic-gate 					info.prop = NULL;
65277c478bd9Sstevel@tonic-gate 					if ((ret = callback(data, &info)) != 0)
65287c478bd9Sstevel@tonic-gate 						goto error;
65297c478bd9Sstevel@tonic-gate 				} else if ((ret = scf_pattern_match(htable,
65307c478bd9Sstevel@tonic-gate 				    fmri, NULL, argc, pattern,
65317c478bd9Sstevel@tonic-gate 				    flags & SCF_WALK_EXPLICIT)) != 0) {
65327c478bd9Sstevel@tonic-gate 					goto error;
65337c478bd9Sstevel@tonic-gate 				}
65347c478bd9Sstevel@tonic-gate 			}
65357c478bd9Sstevel@tonic-gate 		}
65367c478bd9Sstevel@tonic-gate 
65377c478bd9Sstevel@tonic-gate 		/*
65387c478bd9Sstevel@tonic-gate 		 * Search legacy services
65397c478bd9Sstevel@tonic-gate 		 */
65407c478bd9Sstevel@tonic-gate 		if ((flags & SCF_WALK_LEGACY)) {
65417c478bd9Sstevel@tonic-gate 			if (scf_scope_get_service(scope, SCF_LEGACY_SERVICE,
65427c478bd9Sstevel@tonic-gate 			    svc) != 0) {
65437c478bd9Sstevel@tonic-gate 				if (scf_error() != SCF_ERROR_NOT_FOUND) {
65447c478bd9Sstevel@tonic-gate 					ret = scf_error();
65457c478bd9Sstevel@tonic-gate 					goto error;
65467c478bd9Sstevel@tonic-gate 				}
65477c478bd9Sstevel@tonic-gate 
65487c478bd9Sstevel@tonic-gate 				goto nolegacy;
65497c478bd9Sstevel@tonic-gate 			}
65507c478bd9Sstevel@tonic-gate 
65517c478bd9Sstevel@tonic-gate 			if (scf_iter_service_pgs_typed(iter, svc,
65527c478bd9Sstevel@tonic-gate 			    SCF_GROUP_FRAMEWORK) != SCF_SUCCESS) {
65537c478bd9Sstevel@tonic-gate 				ret = scf_error();
65547c478bd9Sstevel@tonic-gate 				goto error;
65557c478bd9Sstevel@tonic-gate 			}
65567c478bd9Sstevel@tonic-gate 
65577c478bd9Sstevel@tonic-gate 			(void) strcpy(fmri, LEGACY_SCHEME);
65587c478bd9Sstevel@tonic-gate 
65597c478bd9Sstevel@tonic-gate 			for (;;) {
65607c478bd9Sstevel@tonic-gate 				ret = scf_iter_next_pg(iter, pg);
65617c478bd9Sstevel@tonic-gate 				if (ret == -1) {
65627c478bd9Sstevel@tonic-gate 					ret = scf_error();
65637c478bd9Sstevel@tonic-gate 					goto error;
65647c478bd9Sstevel@tonic-gate 				}
65657c478bd9Sstevel@tonic-gate 				if (ret == 0)
65667c478bd9Sstevel@tonic-gate 					break;
65677c478bd9Sstevel@tonic-gate 
65687c478bd9Sstevel@tonic-gate 				if (scf_pg_get_property(pg,
65697c478bd9Sstevel@tonic-gate 				    SCF_LEGACY_PROPERTY_NAME, prop) == -1) {
65707c478bd9Sstevel@tonic-gate 					ret = scf_error();
65717c478bd9Sstevel@tonic-gate 					if (ret == SCF_ERROR_DELETED ||
65727c478bd9Sstevel@tonic-gate 					    ret == SCF_ERROR_NOT_FOUND) {
65737c478bd9Sstevel@tonic-gate 						ret = 0;
65747c478bd9Sstevel@tonic-gate 						continue;
65757c478bd9Sstevel@tonic-gate 					}
65767c478bd9Sstevel@tonic-gate 					goto error;
65777c478bd9Sstevel@tonic-gate 				}
65787c478bd9Sstevel@tonic-gate 
65797c478bd9Sstevel@tonic-gate 				if (scf_property_is_type(prop, SCF_TYPE_ASTRING)
65807c478bd9Sstevel@tonic-gate 				    != SCF_SUCCESS) {
65817c478bd9Sstevel@tonic-gate 					if (scf_error() == SCF_ERROR_DELETED)
65827c478bd9Sstevel@tonic-gate 						continue;
65837c478bd9Sstevel@tonic-gate 					ret = scf_error();
65847c478bd9Sstevel@tonic-gate 					goto error;
65857c478bd9Sstevel@tonic-gate 				}
65867c478bd9Sstevel@tonic-gate 
65877c478bd9Sstevel@tonic-gate 				if (scf_property_get_value(prop, value) !=
65887c478bd9Sstevel@tonic-gate 				    SCF_SUCCESS)
65897c478bd9Sstevel@tonic-gate 					continue;
65907c478bd9Sstevel@tonic-gate 
65917c478bd9Sstevel@tonic-gate 				if (scf_value_get_astring(value,
65927c478bd9Sstevel@tonic-gate 				    fmri + sizeof (LEGACY_SCHEME) - 1,
65937c478bd9Sstevel@tonic-gate 				    max_fmri_length + 2 -
65947c478bd9Sstevel@tonic-gate 				    sizeof (LEGACY_SCHEME)) <= 0)
65957c478bd9Sstevel@tonic-gate 					continue;
65967c478bd9Sstevel@tonic-gate 
65977c478bd9Sstevel@tonic-gate 				if (scf_pg_get_name(pg, pgname,
65987c478bd9Sstevel@tonic-gate 				    max_name_length + 1) <= 0) {
65997c478bd9Sstevel@tonic-gate 					if (scf_error() == SCF_ERROR_DELETED)
66007c478bd9Sstevel@tonic-gate 						continue;
66017c478bd9Sstevel@tonic-gate 					ret = scf_error();
66027c478bd9Sstevel@tonic-gate 					goto error;
66037c478bd9Sstevel@tonic-gate 				}
66047c478bd9Sstevel@tonic-gate 
66057c478bd9Sstevel@tonic-gate 				if (argc == 0) {
66067c478bd9Sstevel@tonic-gate 					info.fmri = fmri;
66077c478bd9Sstevel@tonic-gate 					info.scope = scope;
66087c478bd9Sstevel@tonic-gate 					info.svc = NULL;
66097c478bd9Sstevel@tonic-gate 					info.inst = NULL;
66107c478bd9Sstevel@tonic-gate 					info.pg = pg;
66117c478bd9Sstevel@tonic-gate 					info.prop = NULL;
66127c478bd9Sstevel@tonic-gate 					if ((ret = callback(data, &info)) != 0)
66137c478bd9Sstevel@tonic-gate 						goto error;
66147c478bd9Sstevel@tonic-gate 				} else if ((ret = scf_pattern_match(htable,
66157c478bd9Sstevel@tonic-gate 				    fmri, pgname, argc, pattern,
66167c478bd9Sstevel@tonic-gate 				    flags & SCF_WALK_EXPLICIT)) != 0)
66177c478bd9Sstevel@tonic-gate 					goto error;
66187c478bd9Sstevel@tonic-gate 			}
66197c478bd9Sstevel@tonic-gate 
66207c478bd9Sstevel@tonic-gate 		}
66217c478bd9Sstevel@tonic-gate 	}
66227c478bd9Sstevel@tonic-gate nolegacy:
66237c478bd9Sstevel@tonic-gate 	ret = 0;
66247c478bd9Sstevel@tonic-gate 
66257c478bd9Sstevel@tonic-gate 	if (argc == 0)
66267c478bd9Sstevel@tonic-gate 		goto error;
66277c478bd9Sstevel@tonic-gate 
66287c478bd9Sstevel@tonic-gate 	/*
66297c478bd9Sstevel@tonic-gate 	 * Check all patterns, and see if we have that any that didn't match
66307c478bd9Sstevel@tonic-gate 	 * or any that matched multiple instances.  For svcprop, add up the
66317c478bd9Sstevel@tonic-gate 	 * total number of matching keys.
66327c478bd9Sstevel@tonic-gate 	 */
66337c478bd9Sstevel@tonic-gate 	info.count = 0;
66347c478bd9Sstevel@tonic-gate 	for (i = 0; i < argc; i++) {
66357c478bd9Sstevel@tonic-gate 		scf_match_t *match;
66367c478bd9Sstevel@tonic-gate 
66377c478bd9Sstevel@tonic-gate 		if (pattern[i].sp_type == PATTERN_INVALID)
66387c478bd9Sstevel@tonic-gate 			continue;
66397c478bd9Sstevel@tonic-gate 		if (pattern[i].sp_matchcount == 0) {
66407c478bd9Sstevel@tonic-gate 			scf_msg_t msgid;
66417c478bd9Sstevel@tonic-gate 			/*
66427c478bd9Sstevel@tonic-gate 			 * Provide a useful error message based on the argument
66437c478bd9Sstevel@tonic-gate 			 * and the type of entity requested.
66447c478bd9Sstevel@tonic-gate 			 */
66457c478bd9Sstevel@tonic-gate 			if (!(flags & SCF_WALK_LEGACY) &&
66467c478bd9Sstevel@tonic-gate 			    strncmp(pattern[i].sp_arg, "lrc:/", 5) == 0)
66477c478bd9Sstevel@tonic-gate 				msgid = SCF_MSG_PATTERN_LEGACY;
66487c478bd9Sstevel@tonic-gate 			else if (flags & SCF_WALK_PROPERTY)
66497c478bd9Sstevel@tonic-gate 				msgid = SCF_MSG_PATTERN_NOENTITY;
66507c478bd9Sstevel@tonic-gate 			else if (flags & SCF_WALK_NOINSTANCE)
66517c478bd9Sstevel@tonic-gate 				msgid = SCF_MSG_PATTERN_NOSERVICE;
66527c478bd9Sstevel@tonic-gate 			else if (flags & SCF_WALK_SERVICE)
66537c478bd9Sstevel@tonic-gate 				msgid = SCF_MSG_PATTERN_NOINSTSVC;
66547c478bd9Sstevel@tonic-gate 			else
66557c478bd9Sstevel@tonic-gate 				msgid = SCF_MSG_PATTERN_NOINSTANCE;
66567c478bd9Sstevel@tonic-gate 
66577c478bd9Sstevel@tonic-gate 			errfunc(scf_get_msg(msgid), pattern[i].sp_arg);
66587c478bd9Sstevel@tonic-gate 			if (err)
66597c478bd9Sstevel@tonic-gate 				*err = UU_EXIT_FATAL;
66607c478bd9Sstevel@tonic-gate 		} else if (!(flags & SCF_WALK_MULTIPLE) &&
66617c478bd9Sstevel@tonic-gate 		    pattern[i].sp_matchcount > 1) {
66627c478bd9Sstevel@tonic-gate 			size_t len, off;
66637c478bd9Sstevel@tonic-gate 			char *msg;
66647c478bd9Sstevel@tonic-gate 
66657c478bd9Sstevel@tonic-gate 			/*
66667c478bd9Sstevel@tonic-gate 			 * Construct a message with all possible FMRIs before
66677c478bd9Sstevel@tonic-gate 			 * passing off to error handling function.
66687c478bd9Sstevel@tonic-gate 			 *
66697c478bd9Sstevel@tonic-gate 			 * Note that strlen(scf_get_msg(...)) includes the
66707c478bd9Sstevel@tonic-gate 			 * length of '%s', which accounts for the terminating
66717c478bd9Sstevel@tonic-gate 			 * null byte.
66727c478bd9Sstevel@tonic-gate 			 */
66737c478bd9Sstevel@tonic-gate 			len = strlen(scf_get_msg(SCF_MSG_PATTERN_MULTIMATCH)) +
66747c478bd9Sstevel@tonic-gate 			    strlen(pattern[i].sp_arg);
66757c478bd9Sstevel@tonic-gate 			for (match = pattern[i].sp_matches; match != NULL;
66767c478bd9Sstevel@tonic-gate 			    match = match->sm_next) {
66777c478bd9Sstevel@tonic-gate 				len += strlen(match->sm_key->sk_fmri) + 2;
66787c478bd9Sstevel@tonic-gate 			}
66797c478bd9Sstevel@tonic-gate 			if ((msg = malloc(len)) == NULL) {
66807c478bd9Sstevel@tonic-gate 				ret = SCF_ERROR_NO_MEMORY;
66817c478bd9Sstevel@tonic-gate 				goto error;
66827c478bd9Sstevel@tonic-gate 			}
66837c478bd9Sstevel@tonic-gate 
66847c478bd9Sstevel@tonic-gate 			/* LINTED - format argument */
66857c478bd9Sstevel@tonic-gate 			(void) snprintf(msg, len,
66867c478bd9Sstevel@tonic-gate 			    scf_get_msg(SCF_MSG_PATTERN_MULTIMATCH),
66877c478bd9Sstevel@tonic-gate 			    pattern[i].sp_arg);
66887c478bd9Sstevel@tonic-gate 			off = strlen(msg);
66897c478bd9Sstevel@tonic-gate 			for (match = pattern[i].sp_matches; match != NULL;
66907c478bd9Sstevel@tonic-gate 			    match = match->sm_next) {
66917c478bd9Sstevel@tonic-gate 				off += snprintf(msg + off, len - off, "\t%s\n",
66927c478bd9Sstevel@tonic-gate 				    match->sm_key->sk_fmri);
66937c478bd9Sstevel@tonic-gate 			}
66947c478bd9Sstevel@tonic-gate 
66957c478bd9Sstevel@tonic-gate 			errfunc(msg);
66967c478bd9Sstevel@tonic-gate 			if (err != NULL)
66977c478bd9Sstevel@tonic-gate 				*err = UU_EXIT_FATAL;
66987c478bd9Sstevel@tonic-gate 
66997c478bd9Sstevel@tonic-gate 			free(msg);
67007c478bd9Sstevel@tonic-gate 		} else {
67017c478bd9Sstevel@tonic-gate 			for (match = pattern[i].sp_matches; match != NULL;
67027c478bd9Sstevel@tonic-gate 			    match = match->sm_next) {
67037c478bd9Sstevel@tonic-gate 				if (!match->sm_key->sk_seen)
67047c478bd9Sstevel@tonic-gate 					info.count++;
67057c478bd9Sstevel@tonic-gate 				match->sm_key->sk_seen = 1;
67067c478bd9Sstevel@tonic-gate 			}
67077c478bd9Sstevel@tonic-gate 		}
67087c478bd9Sstevel@tonic-gate 	}
67097c478bd9Sstevel@tonic-gate 
67107c478bd9Sstevel@tonic-gate 	/*
67117c478bd9Sstevel@tonic-gate 	 * Clear 'sk_seen' for all keys.
67127c478bd9Sstevel@tonic-gate 	 */
67137c478bd9Sstevel@tonic-gate 	for (i = 0; i < WALK_HTABLE_SIZE; i++) {
67147c478bd9Sstevel@tonic-gate 		scf_matchkey_t *key;
67157c478bd9Sstevel@tonic-gate 		for (key = htable[i]; key != NULL; key = key->sk_next)
67167c478bd9Sstevel@tonic-gate 			key->sk_seen = 0;
67177c478bd9Sstevel@tonic-gate 	}
67187c478bd9Sstevel@tonic-gate 
67197c478bd9Sstevel@tonic-gate 	/*
67207c478bd9Sstevel@tonic-gate 	 * Iterate over all the FMRIs in our hash table and execute the
67217c478bd9Sstevel@tonic-gate 	 * callback.
67227c478bd9Sstevel@tonic-gate 	 */
67237c478bd9Sstevel@tonic-gate 	for (i = 0; i < argc; i++) {
67247c478bd9Sstevel@tonic-gate 		scf_match_t *match;
67257c478bd9Sstevel@tonic-gate 		scf_matchkey_t *key;
67267c478bd9Sstevel@tonic-gate 
67277c478bd9Sstevel@tonic-gate 		/*
67287c478bd9Sstevel@tonic-gate 		 * Ignore patterns which didn't match anything or matched too
67297c478bd9Sstevel@tonic-gate 		 * many FMRIs.
67307c478bd9Sstevel@tonic-gate 		 */
67317c478bd9Sstevel@tonic-gate 		if (pattern[i].sp_matchcount == 0 ||
67327c478bd9Sstevel@tonic-gate 		    (!(flags & SCF_WALK_MULTIPLE) &&
67337c478bd9Sstevel@tonic-gate 		    pattern[i].sp_matchcount > 1))
67347c478bd9Sstevel@tonic-gate 			continue;
67357c478bd9Sstevel@tonic-gate 
67367c478bd9Sstevel@tonic-gate 		for (match = pattern[i].sp_matches; match != NULL;
67377c478bd9Sstevel@tonic-gate 		    match = match->sm_next) {
67387c478bd9Sstevel@tonic-gate 
67397c478bd9Sstevel@tonic-gate 			key = match->sm_key;
67407c478bd9Sstevel@tonic-gate 			if (key->sk_seen)
67417c478bd9Sstevel@tonic-gate 				continue;
67427c478bd9Sstevel@tonic-gate 
67437c478bd9Sstevel@tonic-gate 			key->sk_seen = 1;
67447c478bd9Sstevel@tonic-gate 
67457c478bd9Sstevel@tonic-gate 			if (key->sk_legacy != NULL) {
67467c478bd9Sstevel@tonic-gate 				if (scf_scope_get_service(scope,
67477c478bd9Sstevel@tonic-gate 				    "smf/legacy_run", svc) != 0) {
67487c478bd9Sstevel@tonic-gate 					ret = scf_error();
67497c478bd9Sstevel@tonic-gate 					goto error;
67507c478bd9Sstevel@tonic-gate 				}
67517c478bd9Sstevel@tonic-gate 
67527c478bd9Sstevel@tonic-gate 				if (scf_service_get_pg(svc, key->sk_legacy,
67537c478bd9Sstevel@tonic-gate 				    pg) != 0)
67547c478bd9Sstevel@tonic-gate 					continue;
67557c478bd9Sstevel@tonic-gate 
67567c478bd9Sstevel@tonic-gate 				info.fmri = key->sk_fmri;
67577c478bd9Sstevel@tonic-gate 				info.scope = scope;
67587c478bd9Sstevel@tonic-gate 				info.svc = NULL;
67597c478bd9Sstevel@tonic-gate 				info.inst = NULL;
67607c478bd9Sstevel@tonic-gate 				info.pg = pg;
67617c478bd9Sstevel@tonic-gate 				info.prop = NULL;
67627c478bd9Sstevel@tonic-gate 				if ((ret = callback(data, &info)) != 0)
67637c478bd9Sstevel@tonic-gate 					goto error;
67647c478bd9Sstevel@tonic-gate 			} else {
67657c478bd9Sstevel@tonic-gate 				if (scf_handle_decode_fmri(h, key->sk_fmri,
67667c478bd9Sstevel@tonic-gate 				    scope, svc, inst, pg, prop, 0) !=
67677c478bd9Sstevel@tonic-gate 				    SCF_SUCCESS)
67687c478bd9Sstevel@tonic-gate 					continue;
67697c478bd9Sstevel@tonic-gate 
67707c478bd9Sstevel@tonic-gate 				info.fmri = key->sk_fmri;
67717c478bd9Sstevel@tonic-gate 				info.scope = scope;
67727c478bd9Sstevel@tonic-gate 				info.svc = svc;
67737c478bd9Sstevel@tonic-gate 				if (scf_instance_get_name(inst, NULL, 0) < 0) {
67747c478bd9Sstevel@tonic-gate 					if (scf_error() ==
67757c478bd9Sstevel@tonic-gate 					    SCF_ERROR_CONNECTION_BROKEN) {
67767c478bd9Sstevel@tonic-gate 						ret = scf_error();
67777c478bd9Sstevel@tonic-gate 						goto error;
67787c478bd9Sstevel@tonic-gate 					}
67797c478bd9Sstevel@tonic-gate 					info.inst = NULL;
67807c478bd9Sstevel@tonic-gate 				} else {
67817c478bd9Sstevel@tonic-gate 					info.inst = inst;
67827c478bd9Sstevel@tonic-gate 				}
67837c478bd9Sstevel@tonic-gate 				if (scf_pg_get_name(pg, NULL, 0) < 0) {
67847c478bd9Sstevel@tonic-gate 					if (scf_error() ==
67857c478bd9Sstevel@tonic-gate 					    SCF_ERROR_CONNECTION_BROKEN) {
67867c478bd9Sstevel@tonic-gate 						ret = scf_error();
67877c478bd9Sstevel@tonic-gate 						goto error;
67887c478bd9Sstevel@tonic-gate 					}
67897c478bd9Sstevel@tonic-gate 					info.pg = NULL;
67907c478bd9Sstevel@tonic-gate 				} else {
67917c478bd9Sstevel@tonic-gate 					info.pg = pg;
67927c478bd9Sstevel@tonic-gate 				}
67937c478bd9Sstevel@tonic-gate 				if (scf_property_get_name(prop, NULL, 0) < 0) {
67947c478bd9Sstevel@tonic-gate 					if (scf_error() ==
67957c478bd9Sstevel@tonic-gate 					    SCF_ERROR_CONNECTION_BROKEN) {
67967c478bd9Sstevel@tonic-gate 						ret = scf_error();
67977c478bd9Sstevel@tonic-gate 						goto error;
67987c478bd9Sstevel@tonic-gate 					}
67997c478bd9Sstevel@tonic-gate 					info.prop = NULL;
68007c478bd9Sstevel@tonic-gate 				} else {
68017c478bd9Sstevel@tonic-gate 					info.prop = prop;
68027c478bd9Sstevel@tonic-gate 				}
68037c478bd9Sstevel@tonic-gate 
68047c478bd9Sstevel@tonic-gate 				if ((ret = callback(data, &info)) != 0)
68057c478bd9Sstevel@tonic-gate 					goto error;
68067c478bd9Sstevel@tonic-gate 			}
68077c478bd9Sstevel@tonic-gate 		}
68087c478bd9Sstevel@tonic-gate 	}
68097c478bd9Sstevel@tonic-gate 
68107c478bd9Sstevel@tonic-gate error:
68117c478bd9Sstevel@tonic-gate 	if (htable) {
68127c478bd9Sstevel@tonic-gate 		scf_matchkey_t *key, *next;
68137c478bd9Sstevel@tonic-gate 
68147c478bd9Sstevel@tonic-gate 		for (i = 0; i < WALK_HTABLE_SIZE; i++) {
68157c478bd9Sstevel@tonic-gate 
68167c478bd9Sstevel@tonic-gate 			for (key = htable[i]; key != NULL;
68177c478bd9Sstevel@tonic-gate 			    key = next) {
68187c478bd9Sstevel@tonic-gate 
68197c478bd9Sstevel@tonic-gate 				next = key->sk_next;
68207c478bd9Sstevel@tonic-gate 
68217c478bd9Sstevel@tonic-gate 				if (key->sk_fmri != NULL)
68227c478bd9Sstevel@tonic-gate 					free(key->sk_fmri);
68237c478bd9Sstevel@tonic-gate 				if (key->sk_legacy != NULL)
68247c478bd9Sstevel@tonic-gate 					free(key->sk_legacy);
68257c478bd9Sstevel@tonic-gate 				free(key);
68267c478bd9Sstevel@tonic-gate 			}
68277c478bd9Sstevel@tonic-gate 		}
68287c478bd9Sstevel@tonic-gate 		free(htable);
68297c478bd9Sstevel@tonic-gate 	}
68307c478bd9Sstevel@tonic-gate 	if (pattern != NULL) {
68317c478bd9Sstevel@tonic-gate 		for (i = 0; i < argc; i++) {
68327c478bd9Sstevel@tonic-gate 			scf_match_t *match, *next;
68337c478bd9Sstevel@tonic-gate 
68347c478bd9Sstevel@tonic-gate 			if (pattern[i].sp_arg != NULL)
68357c478bd9Sstevel@tonic-gate 				free(pattern[i].sp_arg);
68367c478bd9Sstevel@tonic-gate 
68377c478bd9Sstevel@tonic-gate 			for (match = pattern[i].sp_matches; match != NULL;
68387c478bd9Sstevel@tonic-gate 			    match = next) {
68397c478bd9Sstevel@tonic-gate 
68407c478bd9Sstevel@tonic-gate 				next = match->sm_next;
68417c478bd9Sstevel@tonic-gate 
68427c478bd9Sstevel@tonic-gate 				free(match);
68437c478bd9Sstevel@tonic-gate 			}
68447c478bd9Sstevel@tonic-gate 		}
68457c478bd9Sstevel@tonic-gate 		free(pattern);
68467c478bd9Sstevel@tonic-gate 	}
68477c478bd9Sstevel@tonic-gate 
68487c478bd9Sstevel@tonic-gate 	free(fmri);
68497c478bd9Sstevel@tonic-gate 	free(pgname);
68507c478bd9Sstevel@tonic-gate 
68517c478bd9Sstevel@tonic-gate 	scf_value_destroy(value);
68527c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
68537c478bd9Sstevel@tonic-gate 	scf_pg_destroy(pg);
68547c478bd9Sstevel@tonic-gate 	scf_scope_destroy(scope);
68557c478bd9Sstevel@tonic-gate 	scf_iter_destroy(siter);
68567c478bd9Sstevel@tonic-gate 	scf_iter_destroy(sciter);
68577c478bd9Sstevel@tonic-gate 	scf_iter_destroy(iter);
68587c478bd9Sstevel@tonic-gate 	scf_instance_destroy(inst);
68597c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
68607c478bd9Sstevel@tonic-gate 
68617c478bd9Sstevel@tonic-gate 	return (ret);
68627c478bd9Sstevel@tonic-gate }
68637c478bd9Sstevel@tonic-gate 
6864*1f6eb021SLiane Praza /*
6865*1f6eb021SLiane Praza  * scf_encode32() is an implementation of Base32 encoding as described in
6866*1f6eb021SLiane Praza  * section 6 of RFC 4648 - "The Base16, Base32, and Base64 Data
6867*1f6eb021SLiane Praza  * Encodings". See http://www.ietf.org/rfc/rfc4648.txt?number=4648.  The
6868*1f6eb021SLiane Praza  * input stream is divided into groups of 5 characters (40 bits).  Each
6869*1f6eb021SLiane Praza  * group is encoded into 8 output characters where each output character
6870*1f6eb021SLiane Praza  * represents 5 bits of input.
6871*1f6eb021SLiane Praza  *
6872*1f6eb021SLiane Praza  * If the input is not an even multiple of 5 characters, the output will be
6873*1f6eb021SLiane Praza  * padded so that the output is an even multiple of 8 characters.  The
6874*1f6eb021SLiane Praza  * standard specifies that the pad character is '='.  Unfortunately, '=' is
6875*1f6eb021SLiane Praza  * not a legal character in SMF property names.  Thus, the caller can
6876*1f6eb021SLiane Praza  * specify an alternate pad character with the pad argument.  If pad is 0,
6877*1f6eb021SLiane Praza  * scf_encode32() will use '='.  Note that use of anything other than '='
6878*1f6eb021SLiane Praza  * produces output that is not in conformance with RFC 4648.  It is
6879*1f6eb021SLiane Praza  * suitable, however, for internal use of SMF software.  When the encoded
6880*1f6eb021SLiane Praza  * data is used as part of an SMF property name, SCF_ENCODE32_PAD should be
6881*1f6eb021SLiane Praza  * used as the pad character.
6882*1f6eb021SLiane Praza  *
6883*1f6eb021SLiane Praza  * Arguments:
6884*1f6eb021SLiane Praza  *	input -		Address of the buffer to be encoded.
6885*1f6eb021SLiane Praza  *	inlen -		Number of characters at input.
6886*1f6eb021SLiane Praza  *	output -	Address of the buffer to receive the encoded data.
6887*1f6eb021SLiane Praza  *	outmax -	Size of the buffer at output.
6888*1f6eb021SLiane Praza  *	outlen -	If it is not NULL, outlen receives the number of
6889*1f6eb021SLiane Praza  *			bytes placed in output.
6890*1f6eb021SLiane Praza  *	pad -		Alternate padding character.
6891*1f6eb021SLiane Praza  *
6892*1f6eb021SLiane Praza  * Returns:
6893*1f6eb021SLiane Praza  *	0	Buffer was successfully encoded.
6894*1f6eb021SLiane Praza  *	-1	Indicates output buffer too small, or pad is one of the
6895*1f6eb021SLiane Praza  *		standard encoding characters.
6896*1f6eb021SLiane Praza  */
6897*1f6eb021SLiane Praza int
6898*1f6eb021SLiane Praza scf_encode32(const char *input, size_t inlen, char *output, size_t outmax,
6899*1f6eb021SLiane Praza     size_t *outlen, char pad)
6900*1f6eb021SLiane Praza {
6901*1f6eb021SLiane Praza 	uint_t group_size = 5;
6902*1f6eb021SLiane Praza 	uint_t i;
6903*1f6eb021SLiane Praza 	const unsigned char *in = (const unsigned char *)input;
6904*1f6eb021SLiane Praza 	size_t olen;
6905*1f6eb021SLiane Praza 	uchar_t *out = (uchar_t *)output;
6906*1f6eb021SLiane Praza 	uint_t oval;
6907*1f6eb021SLiane Praza 	uint_t pad_count;
6908*1f6eb021SLiane Praza 
6909*1f6eb021SLiane Praza 	/* Verify that there is enough room for the output. */
6910*1f6eb021SLiane Praza 	olen = ((inlen + (group_size - 1)) / group_size) * 8;
6911*1f6eb021SLiane Praza 	if (outlen)
6912*1f6eb021SLiane Praza 		*outlen = olen;
6913*1f6eb021SLiane Praza 	if (olen > outmax)
6914*1f6eb021SLiane Praza 		return (-1);
6915*1f6eb021SLiane Praza 
6916*1f6eb021SLiane Praza 	/* If caller did not provide pad character, use the default. */
6917*1f6eb021SLiane Praza 	if (pad == 0) {
6918*1f6eb021SLiane Praza 		pad = '=';
6919*1f6eb021SLiane Praza 	} else {
6920*1f6eb021SLiane Praza 		/*
6921*1f6eb021SLiane Praza 		 * Make sure that caller's pad is not one of the encoding
6922*1f6eb021SLiane Praza 		 * characters.
6923*1f6eb021SLiane Praza 		 */
6924*1f6eb021SLiane Praza 		for (i = 0; i < sizeof (base32) - 1; i++) {
6925*1f6eb021SLiane Praza 			if (pad == base32[i])
6926*1f6eb021SLiane Praza 				return (-1);
6927*1f6eb021SLiane Praza 		}
6928*1f6eb021SLiane Praza 	}
6929*1f6eb021SLiane Praza 
6930*1f6eb021SLiane Praza 	/* Process full groups capturing 5 bits per output character. */
6931*1f6eb021SLiane Praza 	for (; inlen >= group_size; in += group_size, inlen -= group_size) {
6932*1f6eb021SLiane Praza 		/*
6933*1f6eb021SLiane Praza 		 * The comments in this section number the bits in an
6934*1f6eb021SLiane Praza 		 * 8 bit byte 0 to 7.  The high order bit is bit 7 and
6935*1f6eb021SLiane Praza 		 * the low order bit is bit 0.
6936*1f6eb021SLiane Praza 		 */
6937*1f6eb021SLiane Praza 
6938*1f6eb021SLiane Praza 		/* top 5 bits (7-3) from in[0] */
6939*1f6eb021SLiane Praza 		*out++ = base32[in[0] >> 3];
6940*1f6eb021SLiane Praza 		/* bits 2-0 from in[0] and top 2 (7-6) from in[1] */
6941*1f6eb021SLiane Praza 		*out++ = base32[((in[0] << 2) & 0x1c) | (in[1] >> 6)];
6942*1f6eb021SLiane Praza 		/* 5 bits (5-1) from in[1] */
6943*1f6eb021SLiane Praza 		*out++ = base32[(in[1] >> 1) & 0x1f];
6944*1f6eb021SLiane Praza 		/* low bit (0) from in[1] and top 4 (7-4) from in[2] */
6945*1f6eb021SLiane Praza 		*out++ = base32[((in[1] << 4) & 0x10) | ((in[2] >> 4) & 0xf)];
6946*1f6eb021SLiane Praza 		/* low 4 (3-0) from in[2] and top bit (7) from in[3] */
6947*1f6eb021SLiane Praza 		*out++ = base32[((in[2] << 1) & 0x1e) | (in[3] >> 7)];
6948*1f6eb021SLiane Praza 		/* 5 bits (6-2) from in[3] */
6949*1f6eb021SLiane Praza 		*out++ = base32[(in[3] >> 2) & 0x1f];
6950*1f6eb021SLiane Praza 		/* low 2 (1-0) from in[3] and top 3 (7-5) from in[4] */
6951*1f6eb021SLiane Praza 		*out++ = base32[((in[3] << 3) & 0x18) | (in[4] >> 5)];
6952*1f6eb021SLiane Praza 		/* low 5 (4-0) from in[4] */
6953*1f6eb021SLiane Praza 		*out++ = base32[in[4] & 0x1f];
6954*1f6eb021SLiane Praza 	}
6955*1f6eb021SLiane Praza 
6956*1f6eb021SLiane Praza 	/* Take care of final input bytes. */
6957*1f6eb021SLiane Praza 	pad_count = 0;
6958*1f6eb021SLiane Praza 	if (inlen) {
6959*1f6eb021SLiane Praza 		/* top 5 bits (7-3) from in[0] */
6960*1f6eb021SLiane Praza 		*out++ = base32[in[0] >> 3];
6961*1f6eb021SLiane Praza 		/*
6962*1f6eb021SLiane Praza 		 * low 3 (2-0) from in[0] and top 2 (7-6) from in[1] if
6963*1f6eb021SLiane Praza 		 * available.
6964*1f6eb021SLiane Praza 		 */
6965*1f6eb021SLiane Praza 		oval = (in[0] << 2) & 0x1c;
6966*1f6eb021SLiane Praza 		if (inlen == 1) {
6967*1f6eb021SLiane Praza 			*out++ = base32[oval];
6968*1f6eb021SLiane Praza 			pad_count = 6;
6969*1f6eb021SLiane Praza 			goto padout;
6970*1f6eb021SLiane Praza 		}
6971*1f6eb021SLiane Praza 		oval |= in[1] >> 6;
6972*1f6eb021SLiane Praza 		*out++ = base32[oval];
6973*1f6eb021SLiane Praza 		/* 5 bits (5-1) from in[1] */
6974*1f6eb021SLiane Praza 		*out++ = base32[(in[1] >> 1) & 0x1f];
6975*1f6eb021SLiane Praza 		/*
6976*1f6eb021SLiane Praza 		 * low bit (0) from in[1] and top 4 (7-4) from in[2] if
6977*1f6eb021SLiane Praza 		 * available.
6978*1f6eb021SLiane Praza 		 */
6979*1f6eb021SLiane Praza 		oval = (in[1] << 4) & 0x10;
6980*1f6eb021SLiane Praza 		if (inlen == 2) {
6981*1f6eb021SLiane Praza 			*out++ = base32[oval];
6982*1f6eb021SLiane Praza 			pad_count = 4;
6983*1f6eb021SLiane Praza 			goto padout;
6984*1f6eb021SLiane Praza 		}
6985*1f6eb021SLiane Praza 		oval |= in[2] >> 4;
6986*1f6eb021SLiane Praza 		*out++ = base32[oval];
6987*1f6eb021SLiane Praza 		/*
6988*1f6eb021SLiane Praza 		 * low 4 (3-0) from in[2] and top 1 (7) from in[3] if
6989*1f6eb021SLiane Praza 		 * available.
6990*1f6eb021SLiane Praza 		 */
6991*1f6eb021SLiane Praza 		oval = (in[2] << 1) & 0x1e;
6992*1f6eb021SLiane Praza 		if (inlen == 3) {
6993*1f6eb021SLiane Praza 			*out++ = base32[oval];
6994*1f6eb021SLiane Praza 			pad_count = 3;
6995*1f6eb021SLiane Praza 			goto padout;
6996*1f6eb021SLiane Praza 		}
6997*1f6eb021SLiane Praza 		oval |= in[3] >> 7;
6998*1f6eb021SLiane Praza 		*out++ = base32[oval];
6999*1f6eb021SLiane Praza 		/* 5 bits (6-2) from in[3] */
7000*1f6eb021SLiane Praza 		*out++ = base32[(in[3] >> 2) & 0x1f];
7001*1f6eb021SLiane Praza 		/* low 2 bits (1-0) from in[3] */
7002*1f6eb021SLiane Praza 		*out++ = base32[(in[3] << 3) & 0x18];
7003*1f6eb021SLiane Praza 		pad_count = 1;
7004*1f6eb021SLiane Praza 	}
7005*1f6eb021SLiane Praza padout:
7006*1f6eb021SLiane Praza 	/*
7007*1f6eb021SLiane Praza 	 * Pad the output so that it is a multiple of 8 bytes.
7008*1f6eb021SLiane Praza 	 */
7009*1f6eb021SLiane Praza 	for (; pad_count > 0; pad_count--) {
7010*1f6eb021SLiane Praza 		*out++ = pad;
7011*1f6eb021SLiane Praza 	}
7012*1f6eb021SLiane Praza 
7013*1f6eb021SLiane Praza 	/*
7014*1f6eb021SLiane Praza 	 * Null terminate the output if there is enough room.
7015*1f6eb021SLiane Praza 	 */
7016*1f6eb021SLiane Praza 	if (olen < outmax)
7017*1f6eb021SLiane Praza 		*out = 0;
7018*1f6eb021SLiane Praza 
7019*1f6eb021SLiane Praza 	return (0);
7020*1f6eb021SLiane Praza }
7021*1f6eb021SLiane Praza 
7022*1f6eb021SLiane Praza /*
7023*1f6eb021SLiane Praza  * scf_decode32() is an implementation of Base32 decoding as described in
7024*1f6eb021SLiane Praza  * section 6 of RFC 4648 - "The Base16, Base32, and Base64 Data
7025*1f6eb021SLiane Praza  * Encodings". See http://www.ietf.org/rfc/rfc4648.txt?number=4648.  The
7026*1f6eb021SLiane Praza  * input stream is divided into groups of 8 encoded characters.  Each
7027*1f6eb021SLiane Praza  * encoded character represents 5 bits of data.  Thus, the 8 encoded
7028*1f6eb021SLiane Praza  * characters are used to produce 40 bits or 5 bytes of unencoded data in
7029*1f6eb021SLiane Praza  * outbuf.
7030*1f6eb021SLiane Praza  *
7031*1f6eb021SLiane Praza  * If the encoder did not have enough data to generate a mulitple of 8
7032*1f6eb021SLiane Praza  * characters of encoded data, it used a pad character to get to the 8
7033*1f6eb021SLiane Praza  * character boundry. The standard specifies that the pad character is '='.
7034*1f6eb021SLiane Praza  * Unfortunately, '=' is not a legal character in SMF property names.
7035*1f6eb021SLiane Praza  * Thus, the caller can specify an alternate pad character with the pad
7036*1f6eb021SLiane Praza  * argument.  If pad is 0, scf_decode32() will use '='.  Note that use of
7037*1f6eb021SLiane Praza  * anything other than '=' is not in conformance with RFC 4648.  It is
7038*1f6eb021SLiane Praza  * suitable, however, for internal use of SMF software.  When the encoded
7039*1f6eb021SLiane Praza  * data is used in SMF property names, SCF_ENCODE32_PAD should be used as
7040*1f6eb021SLiane Praza  * the pad character.
7041*1f6eb021SLiane Praza  *
7042*1f6eb021SLiane Praza  * Arguments:
7043*1f6eb021SLiane Praza  *	in -		Buffer of encoded characters.
7044*1f6eb021SLiane Praza  *	inlen -		Number of characters at in.
7045*1f6eb021SLiane Praza  *	outbuf -	Buffer to receive the decoded bytes.  It can be the
7046*1f6eb021SLiane Praza  *			same buffer as in.
7047*1f6eb021SLiane Praza  *	outmax -	Size of the buffer at outbuf.
7048*1f6eb021SLiane Praza  *	outlen -	If it is not NULL, outlen receives the number of
7049*1f6eb021SLiane Praza  *			bytes placed in output.
7050*1f6eb021SLiane Praza  *	pad -		Alternate padding character.
7051*1f6eb021SLiane Praza  *
7052*1f6eb021SLiane Praza  * Returns:
7053*1f6eb021SLiane Praza  *	0	Buffer was successfully decoded.
7054*1f6eb021SLiane Praza  *	-1	Indicates an invalid input character, output buffer too
7055*1f6eb021SLiane Praza  *		small, or pad is one of the standard encoding characters.
7056*1f6eb021SLiane Praza  */
7057*1f6eb021SLiane Praza int
7058*1f6eb021SLiane Praza scf_decode32(const char *in, size_t inlen, char *outbuf, size_t outmax,
7059*1f6eb021SLiane Praza     size_t *outlen, char pad)
7060*1f6eb021SLiane Praza {
7061*1f6eb021SLiane Praza 	char *bufend = outbuf + outmax;
7062*1f6eb021SLiane Praza 	char c;
7063*1f6eb021SLiane Praza 	uint_t count;
7064*1f6eb021SLiane Praza 	uint32_t g[DECODE32_GS];
7065*1f6eb021SLiane Praza 	size_t i;
7066*1f6eb021SLiane Praza 	uint_t j;
7067*1f6eb021SLiane Praza 	char *out = outbuf;
7068*1f6eb021SLiane Praza 	boolean_t pad_seen = B_FALSE;
7069*1f6eb021SLiane Praza 
7070*1f6eb021SLiane Praza 	/* If caller did not provide pad character, use the default. */
7071*1f6eb021SLiane Praza 	if (pad == 0) {
7072*1f6eb021SLiane Praza 		pad = '=';
7073*1f6eb021SLiane Praza 	} else {
7074*1f6eb021SLiane Praza 		/*
7075*1f6eb021SLiane Praza 		 * Make sure that caller's pad is not one of the encoding
7076*1f6eb021SLiane Praza 		 * characters.
7077*1f6eb021SLiane Praza 		 */
7078*1f6eb021SLiane Praza 		for (i = 0; i < sizeof (base32) - 1; i++) {
7079*1f6eb021SLiane Praza 			if (pad == base32[i])
7080*1f6eb021SLiane Praza 				return (-1);
7081*1f6eb021SLiane Praza 		}
7082*1f6eb021SLiane Praza 	}
7083*1f6eb021SLiane Praza 
7084*1f6eb021SLiane Praza 	i = 0;
7085*1f6eb021SLiane Praza 	while ((i < inlen) && (out < bufend)) {
7086*1f6eb021SLiane Praza 		/* Get a group of input characters. */
7087*1f6eb021SLiane Praza 		for (j = 0, count = 0;
7088*1f6eb021SLiane Praza 		    (j < DECODE32_GS) && (i < inlen);
7089*1f6eb021SLiane Praza 		    i++) {
7090*1f6eb021SLiane Praza 			c = in[i];
7091*1f6eb021SLiane Praza 			/*
7092*1f6eb021SLiane Praza 			 * RFC 4648 allows for the encoded data to be split
7093*1f6eb021SLiane Praza 			 * into multiple lines, so skip carriage returns
7094*1f6eb021SLiane Praza 			 * and new lines.
7095*1f6eb021SLiane Praza 			 */
7096*1f6eb021SLiane Praza 			if ((c == '\r') || (c == '\n'))
7097*1f6eb021SLiane Praza 				continue;
7098*1f6eb021SLiane Praza 			if ((pad_seen == B_TRUE) && (c != pad)) {
7099*1f6eb021SLiane Praza 				/* Group not completed by pads */
7100*1f6eb021SLiane Praza 				return (-1);
7101*1f6eb021SLiane Praza 			}
7102*1f6eb021SLiane Praza 			if ((c < 0) || (c >= sizeof (index32))) {
7103*1f6eb021SLiane Praza 				/* Illegal character. */
7104*1f6eb021SLiane Praza 				return (-1);
7105*1f6eb021SLiane Praza 			}
7106*1f6eb021SLiane Praza 			if (c == pad) {
7107*1f6eb021SLiane Praza 				pad_seen = B_TRUE;
7108*1f6eb021SLiane Praza 				continue;
7109*1f6eb021SLiane Praza 			}
7110*1f6eb021SLiane Praza 			if ((g[j++] = index32[c]) == 0xff) {
7111*1f6eb021SLiane Praza 				/* Illegal character */
7112*1f6eb021SLiane Praza 				return (-1);
7113*1f6eb021SLiane Praza 			}
7114*1f6eb021SLiane Praza 			count++;
7115*1f6eb021SLiane Praza 		}
7116*1f6eb021SLiane Praza 
7117*1f6eb021SLiane Praza 		/* Pack the group into five 8 bit bytes. */
7118*1f6eb021SLiane Praza 		if ((count >= 2) && (out < bufend)) {
7119*1f6eb021SLiane Praza 			/*
7120*1f6eb021SLiane Praza 			 * Output byte 0:
7121*1f6eb021SLiane Praza 			 *	5 bits (7-3) from g[0]
7122*1f6eb021SLiane Praza 			 *	3 bits (2-0) from g[1] (4-2)
7123*1f6eb021SLiane Praza 			 */
7124*1f6eb021SLiane Praza 			*out++ = (g[0] << 3) | ((g[1] >> 2) & 0x7);
7125*1f6eb021SLiane Praza 		}
7126*1f6eb021SLiane Praza 		if ((count >= 4) && (out < bufend)) {
7127*1f6eb021SLiane Praza 			/*
7128*1f6eb021SLiane Praza 			 * Output byte 1:
7129*1f6eb021SLiane Praza 			 *	2 bits (7-6) from g[1] (1-0)
7130*1f6eb021SLiane Praza 			 *	5 bits (5-1) from g[2] (4-0)
7131*1f6eb021SLiane Praza 			 *	1 bit (0) from g[3] (4)
7132*1f6eb021SLiane Praza 			 */
7133*1f6eb021SLiane Praza 			*out++ = (g[1] << 6) | (g[2] << 1) | \
7134*1f6eb021SLiane Praza 			    ((g[3] >> 4) & 0x1);
7135*1f6eb021SLiane Praza 		}
7136*1f6eb021SLiane Praza 		if ((count >= 5) && (out < bufend)) {
7137*1f6eb021SLiane Praza 			/*
7138*1f6eb021SLiane Praza 			 * Output byte 2:
7139*1f6eb021SLiane Praza 			 *	4 bits (7-4) from g[3] (3-0)
7140*1f6eb021SLiane Praza 			 *	4 bits (3-0) from g[4] (4-1)
7141*1f6eb021SLiane Praza 			 */
7142*1f6eb021SLiane Praza 			*out++ = (g[3] << 4) | ((g[4] >> 1) & 0xf);
7143*1f6eb021SLiane Praza 		}
7144*1f6eb021SLiane Praza 		if ((count >= 7) && (out < bufend)) {
7145*1f6eb021SLiane Praza 			/*
7146*1f6eb021SLiane Praza 			 * Output byte 3:
7147*1f6eb021SLiane Praza 			 *	1 bit (7) from g[4] (0)
7148*1f6eb021SLiane Praza 			 *	5 bits (6-2) from g[5] (4-0)
7149*1f6eb021SLiane Praza 			 *	2 bits (0-1) from g[6] (4-3)
7150*1f6eb021SLiane Praza 			 */
7151*1f6eb021SLiane Praza 			*out++ = (g[4] << 7) | (g[5] << 2) |
7152*1f6eb021SLiane Praza 			    ((g[6] >> 3) & 0x3);
7153*1f6eb021SLiane Praza 		}
7154*1f6eb021SLiane Praza 		if ((count == 8) && (out < bufend)) {
7155*1f6eb021SLiane Praza 			/*
7156*1f6eb021SLiane Praza 			 * Output byte 4;
7157*1f6eb021SLiane Praza 			 *	3 bits (7-5) from g[6] (2-0)
7158*1f6eb021SLiane Praza 			 *	5 bits (4-0) from g[7] (4-0)
7159*1f6eb021SLiane Praza 			 */
7160*1f6eb021SLiane Praza 			*out++ = (g[6] << 5) | g[7];
7161*1f6eb021SLiane Praza 		}
7162*1f6eb021SLiane Praza 	}
7163*1f6eb021SLiane Praza 	if (i < inlen) {
7164*1f6eb021SLiane Praza 		/* Did not process all input characters. */
7165*1f6eb021SLiane Praza 		return (-1);
7166*1f6eb021SLiane Praza 	}
7167*1f6eb021SLiane Praza 	if (outlen)
7168*1f6eb021SLiane Praza 		*outlen = out - outbuf;
7169*1f6eb021SLiane Praza 	/* Null terminate the output if there is room. */
7170*1f6eb021SLiane Praza 	if (out < bufend)
7171*1f6eb021SLiane Praza 		*out = 0;
7172*1f6eb021SLiane Praza 	return (0);
7173*1f6eb021SLiane Praza }
7174*1f6eb021SLiane Praza 
7175*1f6eb021SLiane Praza 
71767c478bd9Sstevel@tonic-gate /*
71777c478bd9Sstevel@tonic-gate  * _scf_request_backup:  a simple wrapper routine
71787c478bd9Sstevel@tonic-gate  */
71797c478bd9Sstevel@tonic-gate int
71807c478bd9Sstevel@tonic-gate _scf_request_backup(scf_handle_t *h, const char *name)
71817c478bd9Sstevel@tonic-gate {
71827c478bd9Sstevel@tonic-gate 	struct rep_protocol_backup_request request;
71837c478bd9Sstevel@tonic-gate 	struct rep_protocol_response response;
71847c478bd9Sstevel@tonic-gate 
71857c478bd9Sstevel@tonic-gate 	int r;
71867c478bd9Sstevel@tonic-gate 
71877c478bd9Sstevel@tonic-gate 	if (strlcpy(request.rpr_name, name, sizeof (request.rpr_name)) >=
71887c478bd9Sstevel@tonic-gate 	    sizeof (request.rpr_name))
71897c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
71907c478bd9Sstevel@tonic-gate 
71917c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_lock(&h->rh_lock);
71927c478bd9Sstevel@tonic-gate 	request.rpr_request = REP_PROTOCOL_BACKUP;
71938918dff3Sjwadams 	request.rpr_changeid = handle_next_changeid(h);
71947c478bd9Sstevel@tonic-gate 
71957c478bd9Sstevel@tonic-gate 	r = make_door_call(h, &request, sizeof (request),
71967c478bd9Sstevel@tonic-gate 	    &response, sizeof (response));
71977c478bd9Sstevel@tonic-gate 	(void) pthread_mutex_unlock(&h->rh_lock);
71987c478bd9Sstevel@tonic-gate 
71997c478bd9Sstevel@tonic-gate 	if (r < 0) {
72007c478bd9Sstevel@tonic-gate 		DOOR_ERRORS_BLOCK(r);
72017c478bd9Sstevel@tonic-gate 	}
72027c478bd9Sstevel@tonic-gate 
72037c478bd9Sstevel@tonic-gate 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
72047c478bd9Sstevel@tonic-gate 		return (scf_set_error(proto_error(response.rpr_response)));
72057c478bd9Sstevel@tonic-gate 	return (SCF_SUCCESS);
72067c478bd9Sstevel@tonic-gate }
72073eae19d9Swesolows 
7208c0889d7aSstevep /*
7209c0889d7aSstevep  * Request svc.configd daemon to switch repository database.
7210c0889d7aSstevep  *
7211c0889d7aSstevep  * Can fail:
7212c0889d7aSstevep  *
7213c0889d7aSstevep  *	_NOT_BOUND		handle is not bound
7214c0889d7aSstevep  *	_CONNECTION_BROKEN	server is not reachable
7215c0889d7aSstevep  *	_INTERNAL		file operation error
7216c0889d7aSstevep  *				the server response is too big
7217c0889d7aSstevep  *	_PERMISSION_DENIED	not enough privileges to do request
7218c0889d7aSstevep  *	_BACKEND_READONLY	backend is not writable
7219c0889d7aSstevep  *	_BACKEND_ACCESS		backend access fails
7220c0889d7aSstevep  *	_NO_RESOURCES		svc.configd is out of memory
7221c0889d7aSstevep  */
7222c0889d7aSstevep int
7223c0889d7aSstevep _scf_repository_switch(scf_handle_t *h, int scf_sw)
7224c0889d7aSstevep {
7225c0889d7aSstevep 	struct rep_protocol_switch_request request;
7226c0889d7aSstevep 	struct rep_protocol_response response;
7227c0889d7aSstevep 	int	r;
7228c0889d7aSstevep 
7229c0889d7aSstevep 	/*
7230c0889d7aSstevep 	 * Setup request protocol and make door call
7231c0889d7aSstevep 	 * Hold rh_lock lock before handle_next_changeid call
7232c0889d7aSstevep 	 */
7233c0889d7aSstevep 	(void) pthread_mutex_lock(&h->rh_lock);
7234c0889d7aSstevep 
7235c0889d7aSstevep 	request.rpr_flag = scf_sw;
7236c0889d7aSstevep 	request.rpr_request = REP_PROTOCOL_SWITCH;
7237c0889d7aSstevep 	request.rpr_changeid = handle_next_changeid(h);
7238c0889d7aSstevep 
7239c0889d7aSstevep 	r = make_door_call(h, &request, sizeof (request),
7240c0889d7aSstevep 	    &response, sizeof (response));
7241c0889d7aSstevep 
7242c0889d7aSstevep 	(void) pthread_mutex_unlock(&h->rh_lock);
7243c0889d7aSstevep 
7244c0889d7aSstevep 	if (r < 0) {
7245c0889d7aSstevep 		DOOR_ERRORS_BLOCK(r);
7246c0889d7aSstevep 	}
7247c0889d7aSstevep 
7248c0889d7aSstevep 	/*
7249c0889d7aSstevep 	 * Pass protocol error up
7250c0889d7aSstevep 	 */
7251c0889d7aSstevep 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
7252c0889d7aSstevep 		return (scf_set_error(proto_error(response.rpr_response)));
7253c0889d7aSstevep 
7254c0889d7aSstevep 	return (SCF_SUCCESS);
7255c0889d7aSstevep }
7256c0889d7aSstevep 
72573eae19d9Swesolows int
72583eae19d9Swesolows _scf_pg_is_read_protected(const scf_propertygroup_t *pg, boolean_t *out)
72593eae19d9Swesolows {
72603eae19d9Swesolows 	char buf[REP_PROTOCOL_NAME_LEN];
72613eae19d9Swesolows 	ssize_t res;
72623eae19d9Swesolows 
72633eae19d9Swesolows 	res = datael_get_name(&pg->rd_d, buf, sizeof (buf),
72643eae19d9Swesolows 	    RP_ENTITY_NAME_PGREADPROT);
72653eae19d9Swesolows 
72663eae19d9Swesolows 	if (res == -1)
72673eae19d9Swesolows 		return (-1);
72683eae19d9Swesolows 
72693eae19d9Swesolows 	if (uu_strtouint(buf, out, sizeof (*out), 0, 0, 1) == -1)
72703eae19d9Swesolows 		return (scf_set_error(SCF_ERROR_INTERNAL));
72713eae19d9Swesolows 	return (SCF_SUCCESS);
72723eae19d9Swesolows }
72735b7f77adStw 
72745b7f77adStw /*
72755b7f77adStw  * _scf_set_annotation: a wrapper to set the annotation fields for SMF
72765b7f77adStw  * security auditing.
72775b7f77adStw  *
72785b7f77adStw  * Fails with following in scf_error_key thread specific data:
72795b7f77adStw  *	_INVALID_ARGUMENT - operation or file too large
72805b7f77adStw  *	_NOT_BOUND
72815b7f77adStw  *	_CONNECTION_BROKEN
72825b7f77adStw  *	_INTERNAL
72835b7f77adStw  *	_NO_RESOURCES
72845b7f77adStw  */
72855b7f77adStw int
72865b7f77adStw _scf_set_annotation(scf_handle_t *h, const char *operation, const char *file)
72875b7f77adStw {
72885b7f77adStw 	struct rep_protocol_annotation request;
72895b7f77adStw 	struct rep_protocol_response response;
72905b7f77adStw 	size_t copied;
72915b7f77adStw 	int r;
72925b7f77adStw 
72935b7f77adStw 	request.rpr_request = REP_PROTOCOL_SET_AUDIT_ANNOTATION;
72945b7f77adStw 	copied = strlcpy(request.rpr_operation,
72955b7f77adStw 	    (operation == NULL) ? "" : operation,
72965b7f77adStw 	    sizeof (request.rpr_operation));
72975b7f77adStw 	if (copied >= sizeof (request.rpr_operation))
72985b7f77adStw 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
72995b7f77adStw 
73005b7f77adStw 	copied = strlcpy(request.rpr_file,
73015b7f77adStw 	    (file == NULL) ? "" : file,
73025b7f77adStw 	    sizeof (request.rpr_file));
73035b7f77adStw 	if (copied >= sizeof (request.rpr_operation))
73045b7f77adStw 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
73055b7f77adStw 
73065b7f77adStw 	(void) pthread_mutex_lock(&h->rh_lock);
73075b7f77adStw 	r = make_door_call(h, &request, sizeof (request),
73085b7f77adStw 	    &response, sizeof (response));
73095b7f77adStw 	(void) pthread_mutex_unlock(&h->rh_lock);
73105b7f77adStw 
73115b7f77adStw 	if (r < 0) {
73125b7f77adStw 		DOOR_ERRORS_BLOCK(r);
73135b7f77adStw 	}
73145b7f77adStw 
73155b7f77adStw 	if (response.rpr_response != REP_PROTOCOL_SUCCESS)
73165b7f77adStw 		return (scf_set_error(proto_error(response.rpr_response)));
73175b7f77adStw 	return (0);
73185b7f77adStw }
7319