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
594501b61Sskamm  * Common Development and Distribution License (the "License").
694501b61Sskamm  * 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  */
21*3eae19d9Swesolows 
227c478bd9Sstevel@tonic-gate /*
23d75e6a5dStn  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
247c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate  */
267c478bd9Sstevel@tonic-gate 
277c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
287c478bd9Sstevel@tonic-gate 
297c478bd9Sstevel@tonic-gate #include "libscf_impl.h"
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate #include <libuutil.h>
327c478bd9Sstevel@tonic-gate #include <stdio.h>
337c478bd9Sstevel@tonic-gate #include <strings.h>
347c478bd9Sstevel@tonic-gate #include <string.h>
357c478bd9Sstevel@tonic-gate #include <stdlib.h>
3694501b61Sskamm #include <sys/param.h>
3794501b61Sskamm #include <errno.h>
3894501b61Sskamm #include <libgen.h>
397c478bd9Sstevel@tonic-gate #include "midlevel_impl.h"
40d75e6a5dStn #include "lowlevel_impl.h"
417c478bd9Sstevel@tonic-gate 
427c478bd9Sstevel@tonic-gate #ifndef NDEBUG
437c478bd9Sstevel@tonic-gate #define	bad_error(func, err)	{					\
447c478bd9Sstevel@tonic-gate 	uu_warn("%s:%d: %s failed with unexpected error %d.  Aborting.\n", \
457c478bd9Sstevel@tonic-gate 	    __FILE__, __LINE__, func, err);				\
467c478bd9Sstevel@tonic-gate 	abort();							\
477c478bd9Sstevel@tonic-gate }
487c478bd9Sstevel@tonic-gate #else
497c478bd9Sstevel@tonic-gate #define	bad_error(func, err)	abort()
507c478bd9Sstevel@tonic-gate #endif
517c478bd9Sstevel@tonic-gate 
5294501b61Sskamm /* Path to speedy files area must end with a slash */
5394501b61Sskamm #define	SMF_SPEEDY_FILES_PATH		"/etc/svc/volatile/"
5494501b61Sskamm 
557c478bd9Sstevel@tonic-gate /*
567c478bd9Sstevel@tonic-gate  * Internal private function that creates and binds a handle.
577c478bd9Sstevel@tonic-gate  */
587c478bd9Sstevel@tonic-gate static scf_handle_t *
597c478bd9Sstevel@tonic-gate handle_create(void)
607c478bd9Sstevel@tonic-gate {
617c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
627c478bd9Sstevel@tonic-gate 
637c478bd9Sstevel@tonic-gate 	h = scf_handle_create(SCF_VERSION);
647c478bd9Sstevel@tonic-gate 	if (h == NULL)
657c478bd9Sstevel@tonic-gate 		return (NULL);
667c478bd9Sstevel@tonic-gate 
677c478bd9Sstevel@tonic-gate 	if (scf_handle_bind(h) == -1) {
687c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
697c478bd9Sstevel@tonic-gate 		return (NULL);
707c478bd9Sstevel@tonic-gate 	}
717c478bd9Sstevel@tonic-gate 	return (h);
727c478bd9Sstevel@tonic-gate }
737c478bd9Sstevel@tonic-gate 
74d75e6a5dStn void
75d75e6a5dStn scf_simple_handle_destroy(scf_simple_handle_t *simple_h)
76d75e6a5dStn {
77d75e6a5dStn 	if (simple_h == NULL)
78d75e6a5dStn 		return;
79d75e6a5dStn 
80d75e6a5dStn 	scf_pg_destroy(simple_h->running_pg);
81d75e6a5dStn 	scf_pg_destroy(simple_h->editing_pg);
82d75e6a5dStn 	scf_snapshot_destroy(simple_h->snap);
83d75e6a5dStn 	scf_instance_destroy(simple_h->inst);
84d75e6a5dStn 	scf_handle_destroy(simple_h->h);
85d75e6a5dStn 	uu_free(simple_h);
86d75e6a5dStn }
87d75e6a5dStn 
887c478bd9Sstevel@tonic-gate /*
897c478bd9Sstevel@tonic-gate  * Given a base service FMRI and the names of a property group and property,
907c478bd9Sstevel@tonic-gate  * assemble_fmri() merges them into a property FMRI.  Note that if the base
917c478bd9Sstevel@tonic-gate  * FMRI is NULL, assemble_fmri() gets the base FMRI from scf_myname().
927c478bd9Sstevel@tonic-gate  */
937c478bd9Sstevel@tonic-gate 
947c478bd9Sstevel@tonic-gate static char *
957c478bd9Sstevel@tonic-gate assemble_fmri(scf_handle_t *h, const char *base, const char *pg,
967c478bd9Sstevel@tonic-gate     const char *prop)
977c478bd9Sstevel@tonic-gate {
987c478bd9Sstevel@tonic-gate 	size_t	fmri_sz, pglen;
997c478bd9Sstevel@tonic-gate 	ssize_t baselen;
1007c478bd9Sstevel@tonic-gate 	char	*fmri_buf;
1017c478bd9Sstevel@tonic-gate 
1027c478bd9Sstevel@tonic-gate 	if (prop == NULL) {
1037c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
1047c478bd9Sstevel@tonic-gate 		return (NULL);
1057c478bd9Sstevel@tonic-gate 	}
1067c478bd9Sstevel@tonic-gate 
1077c478bd9Sstevel@tonic-gate 	if (pg == NULL)
1087c478bd9Sstevel@tonic-gate 		pglen = strlen(SCF_PG_APP_DEFAULT);
1097c478bd9Sstevel@tonic-gate 	else
1107c478bd9Sstevel@tonic-gate 		pglen = strlen(pg);
1117c478bd9Sstevel@tonic-gate 
1127c478bd9Sstevel@tonic-gate 	if (base == NULL) {
1137c478bd9Sstevel@tonic-gate 		if ((baselen = scf_myname(h, NULL, 0)) == -1)
1147c478bd9Sstevel@tonic-gate 			return (NULL);
1157c478bd9Sstevel@tonic-gate 	} else {
1167c478bd9Sstevel@tonic-gate 		baselen = strlen(base);
1177c478bd9Sstevel@tonic-gate 	}
1187c478bd9Sstevel@tonic-gate 
1197c478bd9Sstevel@tonic-gate 	fmri_sz = baselen + sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1 +
1207c478bd9Sstevel@tonic-gate 	    pglen + sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1 +
1217c478bd9Sstevel@tonic-gate 	    strlen(prop) + 1;
1227c478bd9Sstevel@tonic-gate 
1237c478bd9Sstevel@tonic-gate 	if ((fmri_buf = malloc(fmri_sz)) == NULL) {
1247c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1257c478bd9Sstevel@tonic-gate 		return (NULL);
1267c478bd9Sstevel@tonic-gate 	}
1277c478bd9Sstevel@tonic-gate 
1287c478bd9Sstevel@tonic-gate 	if (base == NULL) {
1297c478bd9Sstevel@tonic-gate 		if (scf_myname(h, fmri_buf, fmri_sz) == -1) {
1307c478bd9Sstevel@tonic-gate 			free(fmri_buf);
1317c478bd9Sstevel@tonic-gate 			return (NULL);
1327c478bd9Sstevel@tonic-gate 		}
1337c478bd9Sstevel@tonic-gate 	} else {
1347c478bd9Sstevel@tonic-gate 		(void) strcpy(fmri_buf, base);
1357c478bd9Sstevel@tonic-gate 	}
1367c478bd9Sstevel@tonic-gate 
1377c478bd9Sstevel@tonic-gate 	(void) strcat(fmri_buf, SCF_FMRI_PROPERTYGRP_PREFIX);
1387c478bd9Sstevel@tonic-gate 
1397c478bd9Sstevel@tonic-gate 	if (pg == NULL)
1407c478bd9Sstevel@tonic-gate 		(void) strcat(fmri_buf, SCF_PG_APP_DEFAULT);
1417c478bd9Sstevel@tonic-gate 	else
1427c478bd9Sstevel@tonic-gate 		(void) strcat(fmri_buf, pg);
1437c478bd9Sstevel@tonic-gate 
1447c478bd9Sstevel@tonic-gate 	(void) strcat(fmri_buf, SCF_FMRI_PROPERTY_PREFIX);
1457c478bd9Sstevel@tonic-gate 	(void) strcat(fmri_buf, prop);
1467c478bd9Sstevel@tonic-gate 	return (fmri_buf);
1477c478bd9Sstevel@tonic-gate }
1487c478bd9Sstevel@tonic-gate 
1497c478bd9Sstevel@tonic-gate /*
1507c478bd9Sstevel@tonic-gate  * Given a property, this function allocates and fills an scf_simple_prop_t
1517c478bd9Sstevel@tonic-gate  * with the data it contains.
1527c478bd9Sstevel@tonic-gate  */
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate static scf_simple_prop_t *
1557c478bd9Sstevel@tonic-gate fill_prop(scf_property_t *prop, const char *pgname, const char *propname,
1567c478bd9Sstevel@tonic-gate     scf_handle_t *h)
1577c478bd9Sstevel@tonic-gate {
1587c478bd9Sstevel@tonic-gate 	scf_simple_prop_t 		*ret;
1597c478bd9Sstevel@tonic-gate 	scf_iter_t 			*iter;
1607c478bd9Sstevel@tonic-gate 	scf_value_t 			*val;
1617c478bd9Sstevel@tonic-gate 	int 				iterret, i;
1627c478bd9Sstevel@tonic-gate 	ssize_t 			valsize, numvals;
1637c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val 	*vallist = NULL, *vallist_backup = NULL;
1647c478bd9Sstevel@tonic-gate 
1657c478bd9Sstevel@tonic-gate 	if ((ret = malloc(sizeof (*ret))) == NULL) {
1667c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1677c478bd9Sstevel@tonic-gate 		return (NULL);
1687c478bd9Sstevel@tonic-gate 	}
1697c478bd9Sstevel@tonic-gate 
1707c478bd9Sstevel@tonic-gate 	ret->pr_next = NULL;
1717c478bd9Sstevel@tonic-gate 	ret->pr_pg = NULL;
1727c478bd9Sstevel@tonic-gate 	ret->pr_iter = 0;
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate 	if (pgname == NULL)
1757c478bd9Sstevel@tonic-gate 		ret->pr_pgname = strdup(SCF_PG_APP_DEFAULT);
1767c478bd9Sstevel@tonic-gate 	else
1777c478bd9Sstevel@tonic-gate 		ret->pr_pgname = strdup(pgname);
1787c478bd9Sstevel@tonic-gate 
1797c478bd9Sstevel@tonic-gate 	if (ret->pr_pgname == NULL) {
1807c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1817c478bd9Sstevel@tonic-gate 		free(ret);
1827c478bd9Sstevel@tonic-gate 		return (NULL);
1837c478bd9Sstevel@tonic-gate 	}
1847c478bd9Sstevel@tonic-gate 
1857c478bd9Sstevel@tonic-gate 	if ((ret->pr_propname = strdup(propname)) == NULL) {
1867c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1877c478bd9Sstevel@tonic-gate 		free(ret->pr_pgname);
1887c478bd9Sstevel@tonic-gate 		free(ret);
1897c478bd9Sstevel@tonic-gate 		return (NULL);
1907c478bd9Sstevel@tonic-gate 	}
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate 	if (scf_property_type(prop, &ret->pr_type) == -1)
1937c478bd9Sstevel@tonic-gate 		goto error3;
1947c478bd9Sstevel@tonic-gate 
1957c478bd9Sstevel@tonic-gate 	if ((iter = scf_iter_create(h)) == NULL)
1967c478bd9Sstevel@tonic-gate 		goto error3;
1977c478bd9Sstevel@tonic-gate 	if ((val = scf_value_create(h)) == NULL) {
1987c478bd9Sstevel@tonic-gate 		scf_iter_destroy(iter);
1997c478bd9Sstevel@tonic-gate 		goto error3;
2007c478bd9Sstevel@tonic-gate 	}
2017c478bd9Sstevel@tonic-gate 
2027c478bd9Sstevel@tonic-gate 	if (scf_iter_property_values(iter, prop) == -1)
2037c478bd9Sstevel@tonic-gate 		goto error1;
2047c478bd9Sstevel@tonic-gate 
2057c478bd9Sstevel@tonic-gate 	for (numvals = 0; (iterret = scf_iter_next_value(iter, val)) == 1;
2067c478bd9Sstevel@tonic-gate 	    numvals++) {
2077c478bd9Sstevel@tonic-gate 		vallist_backup = vallist;
2087c478bd9Sstevel@tonic-gate 		if ((vallist = realloc(vallist, (numvals + 1) *
2097c478bd9Sstevel@tonic-gate 		    sizeof (*vallist))) == NULL) {
2107c478bd9Sstevel@tonic-gate 			vallist = vallist_backup;
2117c478bd9Sstevel@tonic-gate 			goto error1;
2127c478bd9Sstevel@tonic-gate 		}
2137c478bd9Sstevel@tonic-gate 
2147c478bd9Sstevel@tonic-gate 		switch (ret->pr_type) {
2157c478bd9Sstevel@tonic-gate 		case SCF_TYPE_BOOLEAN:
2167c478bd9Sstevel@tonic-gate 			if (scf_value_get_boolean(val,
2177c478bd9Sstevel@tonic-gate 			    &vallist[numvals].pv_bool) == -1)
2187c478bd9Sstevel@tonic-gate 				goto error1;
2197c478bd9Sstevel@tonic-gate 			break;
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate 		case SCF_TYPE_COUNT:
2227c478bd9Sstevel@tonic-gate 			if (scf_value_get_count(val,
2237c478bd9Sstevel@tonic-gate 			    &vallist[numvals].pv_uint) == -1)
2247c478bd9Sstevel@tonic-gate 				goto error1;
2257c478bd9Sstevel@tonic-gate 			break;
2267c478bd9Sstevel@tonic-gate 
2277c478bd9Sstevel@tonic-gate 		case SCF_TYPE_INTEGER:
2287c478bd9Sstevel@tonic-gate 			if (scf_value_get_integer(val,
2297c478bd9Sstevel@tonic-gate 			    &vallist[numvals].pv_int) == -1)
2307c478bd9Sstevel@tonic-gate 				goto error1;
2317c478bd9Sstevel@tonic-gate 			break;
2327c478bd9Sstevel@tonic-gate 
2337c478bd9Sstevel@tonic-gate 		case SCF_TYPE_TIME:
2347c478bd9Sstevel@tonic-gate 			if (scf_value_get_time(val,
2357c478bd9Sstevel@tonic-gate 			    &vallist[numvals].pv_time.t_sec,
2367c478bd9Sstevel@tonic-gate 			    &vallist[numvals].pv_time.t_nsec) == -1)
2377c478bd9Sstevel@tonic-gate 				goto error1;
2387c478bd9Sstevel@tonic-gate 			break;
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate 		case SCF_TYPE_ASTRING:
2417c478bd9Sstevel@tonic-gate 			vallist[numvals].pv_str = NULL;
2427c478bd9Sstevel@tonic-gate 			if ((valsize = scf_value_get_astring(val, NULL, 0)) ==
2437c478bd9Sstevel@tonic-gate 			    -1)
2447c478bd9Sstevel@tonic-gate 				goto error1;
2457c478bd9Sstevel@tonic-gate 			if ((vallist[numvals].pv_str = malloc(valsize+1)) ==
2467c478bd9Sstevel@tonic-gate 			    NULL) {
2477c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
2487c478bd9Sstevel@tonic-gate 				goto error1;
2497c478bd9Sstevel@tonic-gate 			}
2507c478bd9Sstevel@tonic-gate 			if (scf_value_get_astring(val,
2517c478bd9Sstevel@tonic-gate 			    vallist[numvals].pv_str, valsize+1) == -1) {
2527c478bd9Sstevel@tonic-gate 				free(vallist[numvals].pv_str);
2537c478bd9Sstevel@tonic-gate 				goto error1;
2547c478bd9Sstevel@tonic-gate 			}
2557c478bd9Sstevel@tonic-gate 			break;
2567c478bd9Sstevel@tonic-gate 
2577c478bd9Sstevel@tonic-gate 		case SCF_TYPE_USTRING:
2587c478bd9Sstevel@tonic-gate 		case SCF_TYPE_HOST:
2597c478bd9Sstevel@tonic-gate 		case SCF_TYPE_HOSTNAME:
2607c478bd9Sstevel@tonic-gate 		case SCF_TYPE_NET_ADDR_V4:
2617c478bd9Sstevel@tonic-gate 		case SCF_TYPE_NET_ADDR_V6:
2627c478bd9Sstevel@tonic-gate 		case SCF_TYPE_URI:
2637c478bd9Sstevel@tonic-gate 		case SCF_TYPE_FMRI:
2647c478bd9Sstevel@tonic-gate 			vallist[numvals].pv_str = NULL;
2657c478bd9Sstevel@tonic-gate 			if ((valsize = scf_value_get_ustring(val, NULL, 0)) ==
2667c478bd9Sstevel@tonic-gate 			    -1)
2677c478bd9Sstevel@tonic-gate 				goto error1;
2687c478bd9Sstevel@tonic-gate 			if ((vallist[numvals].pv_str = malloc(valsize+1)) ==
2697c478bd9Sstevel@tonic-gate 			    NULL) {
2707c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
2717c478bd9Sstevel@tonic-gate 				goto error1;
2727c478bd9Sstevel@tonic-gate 			}
2737c478bd9Sstevel@tonic-gate 			if (scf_value_get_ustring(val,
2747c478bd9Sstevel@tonic-gate 			    vallist[numvals].pv_str, valsize+1) == -1) {
2757c478bd9Sstevel@tonic-gate 				free(vallist[numvals].pv_str);
2767c478bd9Sstevel@tonic-gate 				goto error1;
2777c478bd9Sstevel@tonic-gate 			}
2787c478bd9Sstevel@tonic-gate 			break;
2797c478bd9Sstevel@tonic-gate 
2807c478bd9Sstevel@tonic-gate 		case SCF_TYPE_OPAQUE:
2817c478bd9Sstevel@tonic-gate 			vallist[numvals].pv_opaque.o_value = NULL;
2827c478bd9Sstevel@tonic-gate 			if ((valsize = scf_value_get_opaque(val, NULL, 0)) ==
2837c478bd9Sstevel@tonic-gate 			    -1)
2847c478bd9Sstevel@tonic-gate 				goto error1;
2857c478bd9Sstevel@tonic-gate 			if ((vallist[numvals].pv_opaque.o_value =
2867c478bd9Sstevel@tonic-gate 			    malloc(valsize)) == NULL) {
2877c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
2887c478bd9Sstevel@tonic-gate 				goto error1;
2897c478bd9Sstevel@tonic-gate 			}
2907c478bd9Sstevel@tonic-gate 			vallist[numvals].pv_opaque.o_size = valsize;
2917c478bd9Sstevel@tonic-gate 			if (scf_value_get_opaque(val,
2927c478bd9Sstevel@tonic-gate 			    vallist[numvals].pv_opaque.o_value,
2937c478bd9Sstevel@tonic-gate 			    valsize) == -1) {
2947c478bd9Sstevel@tonic-gate 				free(vallist[numvals].pv_opaque.o_value);
2957c478bd9Sstevel@tonic-gate 				goto error1;
2967c478bd9Sstevel@tonic-gate 			}
2977c478bd9Sstevel@tonic-gate 			break;
2987c478bd9Sstevel@tonic-gate 
2997c478bd9Sstevel@tonic-gate 		default:
3007c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
3017c478bd9Sstevel@tonic-gate 			goto error1;
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate 		}
3047c478bd9Sstevel@tonic-gate 	}
3057c478bd9Sstevel@tonic-gate 
3067c478bd9Sstevel@tonic-gate 	if (iterret == -1) {
307*3eae19d9Swesolows 		int err = scf_error();
308*3eae19d9Swesolows 		if (err != SCF_ERROR_CONNECTION_BROKEN &&
309*3eae19d9Swesolows 		    err != SCF_ERROR_PERMISSION_DENIED)
3107c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
3117c478bd9Sstevel@tonic-gate 		goto error1;
3127c478bd9Sstevel@tonic-gate 	}
3137c478bd9Sstevel@tonic-gate 
3147c478bd9Sstevel@tonic-gate 	ret->pr_vallist = vallist;
3157c478bd9Sstevel@tonic-gate 	ret->pr_numvalues = numvals;
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate 	scf_iter_destroy(iter);
3187c478bd9Sstevel@tonic-gate 	(void) scf_value_destroy(val);
3197c478bd9Sstevel@tonic-gate 
3207c478bd9Sstevel@tonic-gate 	return (ret);
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate 	/*
3237c478bd9Sstevel@tonic-gate 	 * Exit point for a successful call.  Below this line are exit points
3247c478bd9Sstevel@tonic-gate 	 * for failures at various stages during the function.
3257c478bd9Sstevel@tonic-gate 	 */
3267c478bd9Sstevel@tonic-gate 
3277c478bd9Sstevel@tonic-gate error1:
3287c478bd9Sstevel@tonic-gate 	if (vallist == NULL)
3297c478bd9Sstevel@tonic-gate 		goto error2;
3307c478bd9Sstevel@tonic-gate 
3317c478bd9Sstevel@tonic-gate 	switch (ret->pr_type) {
3327c478bd9Sstevel@tonic-gate 	case SCF_TYPE_ASTRING:
3337c478bd9Sstevel@tonic-gate 	case SCF_TYPE_USTRING:
3347c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOST:
3357c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOSTNAME:
3367c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V4:
3377c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V6:
3387c478bd9Sstevel@tonic-gate 	case SCF_TYPE_URI:
3397c478bd9Sstevel@tonic-gate 	case SCF_TYPE_FMRI: {
3407c478bd9Sstevel@tonic-gate 		for (i = 0; i < numvals; i++) {
3417c478bd9Sstevel@tonic-gate 			free(vallist[i].pv_str);
3427c478bd9Sstevel@tonic-gate 		}
3437c478bd9Sstevel@tonic-gate 		break;
3447c478bd9Sstevel@tonic-gate 	}
3457c478bd9Sstevel@tonic-gate 	case SCF_TYPE_OPAQUE: {
3467c478bd9Sstevel@tonic-gate 		for (i = 0; i < numvals; i++) {
3477c478bd9Sstevel@tonic-gate 			free(vallist[i].pv_opaque.o_value);
3487c478bd9Sstevel@tonic-gate 		}
3497c478bd9Sstevel@tonic-gate 		break;
3507c478bd9Sstevel@tonic-gate 	}
3517c478bd9Sstevel@tonic-gate 	default:
3527c478bd9Sstevel@tonic-gate 		break;
3537c478bd9Sstevel@tonic-gate 	}
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 	free(vallist);
3567c478bd9Sstevel@tonic-gate 
3577c478bd9Sstevel@tonic-gate error2:
3587c478bd9Sstevel@tonic-gate 	scf_iter_destroy(iter);
3597c478bd9Sstevel@tonic-gate 	(void) scf_value_destroy(val);
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate error3:
3627c478bd9Sstevel@tonic-gate 	free(ret->pr_pgname);
3637c478bd9Sstevel@tonic-gate 	free(ret->pr_propname);
3647c478bd9Sstevel@tonic-gate 	free(ret);
3657c478bd9Sstevel@tonic-gate 	return (NULL);
3667c478bd9Sstevel@tonic-gate }
3677c478bd9Sstevel@tonic-gate 
3687c478bd9Sstevel@tonic-gate /*
3697c478bd9Sstevel@tonic-gate  * insert_app_props iterates over a property iterator, getting all the
3707c478bd9Sstevel@tonic-gate  * properties from a property group, and adding or overwriting them into
3717c478bd9Sstevel@tonic-gate  * a simple_app_props_t.  This is used by scf_simple_app_props_get to provide
3727c478bd9Sstevel@tonic-gate  * service/instance composition while filling the app_props_t.
3737c478bd9Sstevel@tonic-gate  * insert_app_props iterates over a single property group.
3747c478bd9Sstevel@tonic-gate  */
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate static int
3777c478bd9Sstevel@tonic-gate insert_app_props(scf_iter_t *propiter, char *pgname, char *propname, struct
3787c478bd9Sstevel@tonic-gate     scf_simple_pg *thispg, scf_property_t *prop, size_t namelen,
3797c478bd9Sstevel@tonic-gate     scf_handle_t *h)
3807c478bd9Sstevel@tonic-gate {
3817c478bd9Sstevel@tonic-gate 	scf_simple_prop_t	*thisprop, *prevprop, *newprop;
3827c478bd9Sstevel@tonic-gate 	uint8_t			found;
3837c478bd9Sstevel@tonic-gate 	int			propiter_ret;
3847c478bd9Sstevel@tonic-gate 
3857c478bd9Sstevel@tonic-gate 	while ((propiter_ret = scf_iter_next_property(propiter, prop)) == 1) {
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate 		if (scf_property_get_name(prop, propname, namelen) < 0) {
3887c478bd9Sstevel@tonic-gate 			if (scf_error() == SCF_ERROR_NOT_SET)
3897c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
3907c478bd9Sstevel@tonic-gate 			return (-1);
3917c478bd9Sstevel@tonic-gate 		}
3927c478bd9Sstevel@tonic-gate 
3937c478bd9Sstevel@tonic-gate 		thisprop = thispg->pg_proplist;
3947c478bd9Sstevel@tonic-gate 		prevprop = thispg->pg_proplist;
3957c478bd9Sstevel@tonic-gate 		found = 0;
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate 		while ((thisprop != NULL) && (!found)) {
3987c478bd9Sstevel@tonic-gate 			if (strcmp(thisprop->pr_propname, propname) == 0) {
3997c478bd9Sstevel@tonic-gate 				found = 1;
4007c478bd9Sstevel@tonic-gate 				if ((newprop = fill_prop(prop, pgname,
4017c478bd9Sstevel@tonic-gate 				    propname, h)) == NULL)
4027c478bd9Sstevel@tonic-gate 					return (-1);
4037c478bd9Sstevel@tonic-gate 
4047c478bd9Sstevel@tonic-gate 				if (thisprop == thispg->pg_proplist)
4057c478bd9Sstevel@tonic-gate 					thispg->pg_proplist = newprop;
4067c478bd9Sstevel@tonic-gate 				else
4077c478bd9Sstevel@tonic-gate 					prevprop->pr_next = newprop;
4087c478bd9Sstevel@tonic-gate 
4097c478bd9Sstevel@tonic-gate 				newprop->pr_pg = thispg;
4107c478bd9Sstevel@tonic-gate 				newprop->pr_next = thisprop->pr_next;
4117c478bd9Sstevel@tonic-gate 				scf_simple_prop_free(thisprop);
4127c478bd9Sstevel@tonic-gate 				thisprop = NULL;
4137c478bd9Sstevel@tonic-gate 			} else {
4147c478bd9Sstevel@tonic-gate 				if (thisprop != thispg->pg_proplist)
4157c478bd9Sstevel@tonic-gate 					prevprop = prevprop->pr_next;
4167c478bd9Sstevel@tonic-gate 				thisprop = thisprop->pr_next;
4177c478bd9Sstevel@tonic-gate 			}
4187c478bd9Sstevel@tonic-gate 		}
4197c478bd9Sstevel@tonic-gate 
4207c478bd9Sstevel@tonic-gate 		if (!found) {
4217c478bd9Sstevel@tonic-gate 			if ((newprop = fill_prop(prop, pgname, propname, h)) ==
4227c478bd9Sstevel@tonic-gate 			    NULL)
4237c478bd9Sstevel@tonic-gate 				return (-1);
4247c478bd9Sstevel@tonic-gate 
4257c478bd9Sstevel@tonic-gate 			if (thispg->pg_proplist == NULL)
4267c478bd9Sstevel@tonic-gate 				thispg->pg_proplist = newprop;
4277c478bd9Sstevel@tonic-gate 			else
4287c478bd9Sstevel@tonic-gate 				prevprop->pr_next = newprop;
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate 			newprop->pr_pg = thispg;
4317c478bd9Sstevel@tonic-gate 		}
4327c478bd9Sstevel@tonic-gate 	}
4337c478bd9Sstevel@tonic-gate 
4347c478bd9Sstevel@tonic-gate 	if (propiter_ret == -1) {
4357c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
4367c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
4377c478bd9Sstevel@tonic-gate 		return (-1);
4387c478bd9Sstevel@tonic-gate 	}
4397c478bd9Sstevel@tonic-gate 
4407c478bd9Sstevel@tonic-gate 	return (0);
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate 
4437c478bd9Sstevel@tonic-gate 
4447c478bd9Sstevel@tonic-gate /*
4457c478bd9Sstevel@tonic-gate  * Sets up e in tx to set pname's values.  Returns 0 on success or -1 on
4467c478bd9Sstevel@tonic-gate  * failure, with scf_error() set to
4477c478bd9Sstevel@tonic-gate  *   SCF_ERROR_HANDLE_MISMATCH - tx & e are derived from different handles
4487c478bd9Sstevel@tonic-gate  *   SCF_ERROR_INVALID_ARGUMENT - pname or ty are invalid
4497c478bd9Sstevel@tonic-gate  *   SCF_ERROR_NOT_BOUND - handle is not bound
4507c478bd9Sstevel@tonic-gate  *   SCF_ERROR_CONNECTION_BROKEN - connection was broken
4517c478bd9Sstevel@tonic-gate  *   SCF_ERROR_NOT_SET - tx has not been started
4527c478bd9Sstevel@tonic-gate  *   SCF_ERROR_DELETED - the pg tx was started on was deleted
4537c478bd9Sstevel@tonic-gate  */
4547c478bd9Sstevel@tonic-gate static int
4557c478bd9Sstevel@tonic-gate transaction_property_set(scf_transaction_t *tx, scf_transaction_entry_t *e,
4567c478bd9Sstevel@tonic-gate     const char *pname, scf_type_t ty)
4577c478bd9Sstevel@tonic-gate {
4587c478bd9Sstevel@tonic-gate 	for (;;) {
4597c478bd9Sstevel@tonic-gate 		if (scf_transaction_property_change_type(tx, e, pname, ty) == 0)
4607c478bd9Sstevel@tonic-gate 			return (0);
4617c478bd9Sstevel@tonic-gate 
4627c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
4637c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
4647c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
4657c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_BOUND:
4667c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
4677c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_SET:
4687c478bd9Sstevel@tonic-gate 		case SCF_ERROR_DELETED:
4697c478bd9Sstevel@tonic-gate 		default:
4707c478bd9Sstevel@tonic-gate 			return (-1);
4717c478bd9Sstevel@tonic-gate 
4727c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
4737c478bd9Sstevel@tonic-gate 			break;
4747c478bd9Sstevel@tonic-gate 		}
4757c478bd9Sstevel@tonic-gate 
4767c478bd9Sstevel@tonic-gate 		if (scf_transaction_property_new(tx, e, pname, ty) == 0)
4777c478bd9Sstevel@tonic-gate 			return (0);
4787c478bd9Sstevel@tonic-gate 
4797c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
4807c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
4817c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
4827c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_BOUND:
4837c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
4847c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_SET:
4857c478bd9Sstevel@tonic-gate 		case SCF_ERROR_DELETED:
4867c478bd9Sstevel@tonic-gate 		default:
4877c478bd9Sstevel@tonic-gate 			return (-1);
4887c478bd9Sstevel@tonic-gate 
4897c478bd9Sstevel@tonic-gate 		case SCF_ERROR_EXISTS:
4907c478bd9Sstevel@tonic-gate 			break;
4917c478bd9Sstevel@tonic-gate 		}
4927c478bd9Sstevel@tonic-gate 	}
4937c478bd9Sstevel@tonic-gate }
4947c478bd9Sstevel@tonic-gate 
4957c478bd9Sstevel@tonic-gate static int
4967c478bd9Sstevel@tonic-gate get_inst_enabled(const scf_instance_t *inst, const char *pgname)
4977c478bd9Sstevel@tonic-gate {
4987c478bd9Sstevel@tonic-gate 	scf_propertygroup_t 	*gpg = NULL;
4997c478bd9Sstevel@tonic-gate 	scf_property_t 		*eprop = NULL;
5007c478bd9Sstevel@tonic-gate 	scf_value_t 		*v = NULL;
5017c478bd9Sstevel@tonic-gate 	scf_handle_t		*h = NULL;
5027c478bd9Sstevel@tonic-gate 	uint8_t			enabled;
5037c478bd9Sstevel@tonic-gate 	int			ret = -1;
5047c478bd9Sstevel@tonic-gate 
5057c478bd9Sstevel@tonic-gate 	if ((h = scf_instance_handle(inst)) == NULL)
5067c478bd9Sstevel@tonic-gate 		return (-1);
5077c478bd9Sstevel@tonic-gate 
5087c478bd9Sstevel@tonic-gate 	if ((gpg = scf_pg_create(h)) == NULL ||
5097c478bd9Sstevel@tonic-gate 	    (eprop = scf_property_create(h)) == NULL ||
5107c478bd9Sstevel@tonic-gate 	    (v = scf_value_create(h)) == NULL)
5117c478bd9Sstevel@tonic-gate 		goto out;
5127c478bd9Sstevel@tonic-gate 
5137c478bd9Sstevel@tonic-gate 	if (scf_instance_get_pg(inst, pgname, gpg) ||
5147c478bd9Sstevel@tonic-gate 	    scf_pg_get_property(gpg, SCF_PROPERTY_ENABLED, eprop) ||
5157c478bd9Sstevel@tonic-gate 	    scf_property_get_value(eprop, v) ||
5167c478bd9Sstevel@tonic-gate 	    scf_value_get_boolean(v, &enabled))
5177c478bd9Sstevel@tonic-gate 		goto out;
5187c478bd9Sstevel@tonic-gate 	ret = enabled;
5197c478bd9Sstevel@tonic-gate 
5207c478bd9Sstevel@tonic-gate out:
5217c478bd9Sstevel@tonic-gate 	scf_pg_destroy(gpg);
5227c478bd9Sstevel@tonic-gate 	scf_property_destroy(eprop);
5237c478bd9Sstevel@tonic-gate 	scf_value_destroy(v);
5247c478bd9Sstevel@tonic-gate 	return (ret);
5257c478bd9Sstevel@tonic-gate }
5267c478bd9Sstevel@tonic-gate 
5277c478bd9Sstevel@tonic-gate /*
5287c478bd9Sstevel@tonic-gate  * set_inst_enabled() is a "master" enable/disable call that takes the
5297c478bd9Sstevel@tonic-gate  * instance and the desired state for the enabled bit in the instance's
5307c478bd9Sstevel@tonic-gate  * named property group.  If the group doesn't exist, it's created with the
5317c478bd9Sstevel@tonic-gate  * given flags.  Called by smf_{dis,en}able_instance().
5327c478bd9Sstevel@tonic-gate  */
5337c478bd9Sstevel@tonic-gate static int
5347c478bd9Sstevel@tonic-gate set_inst_enabled(const scf_instance_t *inst, uint8_t desired,
5357c478bd9Sstevel@tonic-gate     const char *pgname, uint32_t pgflags)
5367c478bd9Sstevel@tonic-gate {
5377c478bd9Sstevel@tonic-gate 	scf_transaction_t 	*tx = NULL;
5387c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *ent = NULL;
5397c478bd9Sstevel@tonic-gate 	scf_propertygroup_t 	*gpg = NULL;
5407c478bd9Sstevel@tonic-gate 	scf_property_t 		*eprop = NULL;
5417c478bd9Sstevel@tonic-gate 	scf_value_t 		*v = NULL;
5427c478bd9Sstevel@tonic-gate 	scf_handle_t		*h = NULL;
5437c478bd9Sstevel@tonic-gate 	int 			ret = -1;
5447c478bd9Sstevel@tonic-gate 	int			committed;
5457c478bd9Sstevel@tonic-gate 	uint8_t			b;
5467c478bd9Sstevel@tonic-gate 
5477c478bd9Sstevel@tonic-gate 	if ((h = scf_instance_handle(inst)) == NULL)
5487c478bd9Sstevel@tonic-gate 		return (-1);
5497c478bd9Sstevel@tonic-gate 
5507c478bd9Sstevel@tonic-gate 	if ((gpg = scf_pg_create(h)) == NULL ||
5517c478bd9Sstevel@tonic-gate 	    (eprop = scf_property_create(h)) == NULL ||
5527c478bd9Sstevel@tonic-gate 	    (v = scf_value_create(h)) == NULL ||
5537c478bd9Sstevel@tonic-gate 	    (tx = scf_transaction_create(h)) == NULL ||
5547c478bd9Sstevel@tonic-gate 	    (ent = scf_entry_create(h)) == NULL)
5557c478bd9Sstevel@tonic-gate 		goto out;
5567c478bd9Sstevel@tonic-gate 
557fee38f6fStn general_pg_get:
558fee38f6fStn 	if (scf_instance_get_pg(inst, SCF_PG_GENERAL, gpg) == -1) {
5597c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_NOT_FOUND)
5607c478bd9Sstevel@tonic-gate 			goto out;
5617c478bd9Sstevel@tonic-gate 
562fee38f6fStn 		if (scf_instance_add_pg(inst, SCF_PG_GENERAL,
563fee38f6fStn 		    SCF_GROUP_FRAMEWORK, SCF_PG_GENERAL_FLAGS, gpg) == -1) {
5647c478bd9Sstevel@tonic-gate 			if (scf_error() != SCF_ERROR_EXISTS)
5657c478bd9Sstevel@tonic-gate 				goto out;
566fee38f6fStn 			goto general_pg_get;
5677c478bd9Sstevel@tonic-gate 		}
5687c478bd9Sstevel@tonic-gate 	}
569fee38f6fStn 
570fee38f6fStn 	if (strcmp(pgname, SCF_PG_GENERAL) != 0) {
571fee38f6fStn get:
572fee38f6fStn 		if (scf_instance_get_pg(inst, pgname, gpg) == -1) {
573fee38f6fStn 			if (scf_error() != SCF_ERROR_NOT_FOUND)
574fee38f6fStn 				goto out;
575fee38f6fStn 
576fee38f6fStn 			if (scf_instance_add_pg(inst, pgname,
577fee38f6fStn 			    SCF_GROUP_FRAMEWORK, pgflags, gpg) == -1) {
578fee38f6fStn 				if (scf_error() != SCF_ERROR_EXISTS)
579fee38f6fStn 					goto out;
580fee38f6fStn 				goto get;
581fee38f6fStn 			}
582fee38f6fStn 		}
583fee38f6fStn 	}
584fee38f6fStn 
5857c478bd9Sstevel@tonic-gate 	if (scf_pg_get_property(gpg, SCF_PROPERTY_ENABLED, eprop) == -1) {
5867c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_NOT_FOUND)
5877c478bd9Sstevel@tonic-gate 			goto out;
5887c478bd9Sstevel@tonic-gate 		else
5897c478bd9Sstevel@tonic-gate 			goto set;
5907c478bd9Sstevel@tonic-gate 	}
5917c478bd9Sstevel@tonic-gate 
5927c478bd9Sstevel@tonic-gate 	/*
5937c478bd9Sstevel@tonic-gate 	 * If it's already set the way we want, forgo the transaction.
5947c478bd9Sstevel@tonic-gate 	 */
5957c478bd9Sstevel@tonic-gate 	if (scf_property_get_value(eprop, v) == -1) {
5967c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
5977c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONSTRAINT_VIOLATED:
5987c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
5997c478bd9Sstevel@tonic-gate 			/* Misconfigured, so set anyway. */
6007c478bd9Sstevel@tonic-gate 			goto set;
6017c478bd9Sstevel@tonic-gate 
6027c478bd9Sstevel@tonic-gate 		default:
6037c478bd9Sstevel@tonic-gate 			goto out;
6047c478bd9Sstevel@tonic-gate 		}
6057c478bd9Sstevel@tonic-gate 	}
6067c478bd9Sstevel@tonic-gate 	if (scf_value_get_boolean(v, &b) == -1) {
6077c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
6087c478bd9Sstevel@tonic-gate 			goto out;
6097c478bd9Sstevel@tonic-gate 		goto set;
6107c478bd9Sstevel@tonic-gate 	}
6117c478bd9Sstevel@tonic-gate 	if (b == desired) {
6127c478bd9Sstevel@tonic-gate 		ret = 0;
6137c478bd9Sstevel@tonic-gate 		goto out;
6147c478bd9Sstevel@tonic-gate 	}
6157c478bd9Sstevel@tonic-gate 
6167c478bd9Sstevel@tonic-gate set:
6177c478bd9Sstevel@tonic-gate 	do {
6187c478bd9Sstevel@tonic-gate 		if (scf_transaction_start(tx, gpg) == -1)
6197c478bd9Sstevel@tonic-gate 			goto out;
6207c478bd9Sstevel@tonic-gate 
6217c478bd9Sstevel@tonic-gate 		if (transaction_property_set(tx, ent, SCF_PROPERTY_ENABLED,
6227c478bd9Sstevel@tonic-gate 		    SCF_TYPE_BOOLEAN) != 0) {
6237c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
6247c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
6257c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
6267c478bd9Sstevel@tonic-gate 			default:
6277c478bd9Sstevel@tonic-gate 				goto out;
6287c478bd9Sstevel@tonic-gate 
6297c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
6307c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
6317c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
6327c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
6337c478bd9Sstevel@tonic-gate 				bad_error("transaction_property_set",
6347c478bd9Sstevel@tonic-gate 				    scf_error());
6357c478bd9Sstevel@tonic-gate 			}
6367c478bd9Sstevel@tonic-gate 		}
6377c478bd9Sstevel@tonic-gate 
6387c478bd9Sstevel@tonic-gate 		scf_value_set_boolean(v, desired);
6397c478bd9Sstevel@tonic-gate 		if (scf_entry_add_value(ent, v) == -1)
6407c478bd9Sstevel@tonic-gate 			goto out;
6417c478bd9Sstevel@tonic-gate 
6427c478bd9Sstevel@tonic-gate 		committed = scf_transaction_commit(tx);
6437c478bd9Sstevel@tonic-gate 		if (committed == -1)
6447c478bd9Sstevel@tonic-gate 			goto out;
6457c478bd9Sstevel@tonic-gate 
6467c478bd9Sstevel@tonic-gate 		scf_transaction_reset(tx);
6477c478bd9Sstevel@tonic-gate 
6487c478bd9Sstevel@tonic-gate 		if (committed == 0) { /* out-of-sync */
6497c478bd9Sstevel@tonic-gate 			if (scf_pg_update(gpg) == -1)
6507c478bd9Sstevel@tonic-gate 				goto out;
6517c478bd9Sstevel@tonic-gate 		}
6527c478bd9Sstevel@tonic-gate 	} while (committed == 0);
6537c478bd9Sstevel@tonic-gate 
6547c478bd9Sstevel@tonic-gate 	ret = 0;
6557c478bd9Sstevel@tonic-gate 
6567c478bd9Sstevel@tonic-gate out:
6577c478bd9Sstevel@tonic-gate 	scf_value_destroy(v);
6587c478bd9Sstevel@tonic-gate 	scf_entry_destroy(ent);
6597c478bd9Sstevel@tonic-gate 	scf_transaction_destroy(tx);
6607c478bd9Sstevel@tonic-gate 	scf_property_destroy(eprop);
6617c478bd9Sstevel@tonic-gate 	scf_pg_destroy(gpg);
6627c478bd9Sstevel@tonic-gate 
6637c478bd9Sstevel@tonic-gate 	return (ret);
6647c478bd9Sstevel@tonic-gate }
6657c478bd9Sstevel@tonic-gate 
6667c478bd9Sstevel@tonic-gate static int
6677c478bd9Sstevel@tonic-gate delete_inst_enabled(const scf_instance_t *inst, const char *pgname)
6687c478bd9Sstevel@tonic-gate {
6697c478bd9Sstevel@tonic-gate 	scf_transaction_t 	*tx = NULL;
6707c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t *ent = NULL;
6717c478bd9Sstevel@tonic-gate 	scf_propertygroup_t 	*gpg = NULL;
6727c478bd9Sstevel@tonic-gate 	scf_handle_t		*h = NULL;
6737c478bd9Sstevel@tonic-gate 	int			ret = -1;
6747c478bd9Sstevel@tonic-gate 	int			committed;
6757c478bd9Sstevel@tonic-gate 
6767c478bd9Sstevel@tonic-gate 	if ((h = scf_instance_handle(inst)) == NULL)
6777c478bd9Sstevel@tonic-gate 		return (-1);
6787c478bd9Sstevel@tonic-gate 
6797c478bd9Sstevel@tonic-gate 	if ((gpg = scf_pg_create(h)) == NULL ||
6807c478bd9Sstevel@tonic-gate 	    (tx = scf_transaction_create(h)) == NULL ||
6817c478bd9Sstevel@tonic-gate 	    (ent = scf_entry_create(h)) == NULL)
6827c478bd9Sstevel@tonic-gate 		goto out;
6837c478bd9Sstevel@tonic-gate 
6847c478bd9Sstevel@tonic-gate 	if (scf_instance_get_pg(inst, pgname, gpg) != 0)
6857c478bd9Sstevel@tonic-gate 		goto error;
6867c478bd9Sstevel@tonic-gate 	do {
6877c478bd9Sstevel@tonic-gate 		if (scf_transaction_start(tx, gpg) == -1 ||
6887c478bd9Sstevel@tonic-gate 		    scf_transaction_property_delete(tx, ent,
6897c478bd9Sstevel@tonic-gate 		    SCF_PROPERTY_ENABLED) == -1 ||
6907c478bd9Sstevel@tonic-gate 		    (committed = scf_transaction_commit(tx)) == -1)
6917c478bd9Sstevel@tonic-gate 			goto error;
6927c478bd9Sstevel@tonic-gate 
6937c478bd9Sstevel@tonic-gate 		scf_transaction_reset(tx);
6947c478bd9Sstevel@tonic-gate 
6957c478bd9Sstevel@tonic-gate 		if (committed == 0 && scf_pg_update(gpg) == -1)
6967c478bd9Sstevel@tonic-gate 			goto error;
6977c478bd9Sstevel@tonic-gate 	} while (committed == 0);
6987c478bd9Sstevel@tonic-gate 
6997c478bd9Sstevel@tonic-gate 	ret = 0;
7007c478bd9Sstevel@tonic-gate 	goto out;
7017c478bd9Sstevel@tonic-gate 
7027c478bd9Sstevel@tonic-gate error:
7037c478bd9Sstevel@tonic-gate 	switch (scf_error()) {
7047c478bd9Sstevel@tonic-gate 	case SCF_ERROR_DELETED:
7057c478bd9Sstevel@tonic-gate 	case SCF_ERROR_NOT_FOUND:
7067c478bd9Sstevel@tonic-gate 		/* success */
7077c478bd9Sstevel@tonic-gate 		ret = 0;
7087c478bd9Sstevel@tonic-gate 	}
7097c478bd9Sstevel@tonic-gate 
7107c478bd9Sstevel@tonic-gate out:
7117c478bd9Sstevel@tonic-gate 	scf_entry_destroy(ent);
7127c478bd9Sstevel@tonic-gate 	scf_transaction_destroy(tx);
7137c478bd9Sstevel@tonic-gate 	scf_pg_destroy(gpg);
7147c478bd9Sstevel@tonic-gate 
7157c478bd9Sstevel@tonic-gate 	return (ret);
7167c478bd9Sstevel@tonic-gate }
7177c478bd9Sstevel@tonic-gate 
7187c478bd9Sstevel@tonic-gate /*
7197c478bd9Sstevel@tonic-gate  * Returns 0 on success or -1 on failure.  On failure leaves scf_error() set to
7207c478bd9Sstevel@tonic-gate  *   SCF_ERROR_HANDLE_DESTROYED - inst's handle has been destroyed
7217c478bd9Sstevel@tonic-gate  *   SCF_ERROR_NOT_BOUND - inst's handle is not bound
7227c478bd9Sstevel@tonic-gate  *   SCF_ERROR_CONNECTION_BROKEN - the repository connection was broken
7237c478bd9Sstevel@tonic-gate  *   SCF_ERROR_NOT_SET - inst is not set
7247c478bd9Sstevel@tonic-gate  *   SCF_ERROR_DELETED - inst was deleted
7257c478bd9Sstevel@tonic-gate  *   SCF_ERROR_PERMISSION_DENIED
7267c478bd9Sstevel@tonic-gate  *   SCF_ERROR_BACKEND_ACCESS
7277c478bd9Sstevel@tonic-gate  *   SCF_ERROR_BACKEND_READONLY
7287c478bd9Sstevel@tonic-gate  */
7297c478bd9Sstevel@tonic-gate static int
7307c478bd9Sstevel@tonic-gate set_inst_action_inst(scf_instance_t *inst, const char *action)
7317c478bd9Sstevel@tonic-gate {
7327c478bd9Sstevel@tonic-gate 	scf_handle_t			*h;
7337c478bd9Sstevel@tonic-gate 	scf_transaction_t		*tx = NULL;
7347c478bd9Sstevel@tonic-gate 	scf_transaction_entry_t		*ent = NULL;
7357c478bd9Sstevel@tonic-gate 	scf_propertygroup_t		*pg = NULL;
7367c478bd9Sstevel@tonic-gate 	scf_property_t			*prop = NULL;
7377c478bd9Sstevel@tonic-gate 	scf_value_t			*v = NULL;
7387c478bd9Sstevel@tonic-gate 	int				trans, ret = -1;
7397c478bd9Sstevel@tonic-gate 	int64_t				t;
7407c478bd9Sstevel@tonic-gate 	hrtime_t			timestamp;
7417c478bd9Sstevel@tonic-gate 
7427c478bd9Sstevel@tonic-gate 	if ((h = scf_instance_handle(inst)) == NULL ||
7437c478bd9Sstevel@tonic-gate 	    (pg = scf_pg_create(h)) == NULL ||
7447c478bd9Sstevel@tonic-gate 	    (prop = scf_property_create(h)) == NULL ||
7457c478bd9Sstevel@tonic-gate 	    (v = scf_value_create(h)) == NULL ||
7467c478bd9Sstevel@tonic-gate 	    (tx = scf_transaction_create(h)) == NULL ||
7477c478bd9Sstevel@tonic-gate 	    (ent = scf_entry_create(h)) == NULL)
7487c478bd9Sstevel@tonic-gate 		goto out;
7497c478bd9Sstevel@tonic-gate 
7507c478bd9Sstevel@tonic-gate get:
7517c478bd9Sstevel@tonic-gate 	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER_ACTIONS, pg) == -1) {
7527c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
7537c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_BOUND:
7547c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONNECTION_BROKEN:
7557c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_SET:
7567c478bd9Sstevel@tonic-gate 		case SCF_ERROR_DELETED:
7577c478bd9Sstevel@tonic-gate 		default:
7587c478bd9Sstevel@tonic-gate 			goto out;
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
7617c478bd9Sstevel@tonic-gate 			break;
7627c478bd9Sstevel@tonic-gate 
7637c478bd9Sstevel@tonic-gate 		case SCF_ERROR_HANDLE_MISMATCH:
7647c478bd9Sstevel@tonic-gate 		case SCF_ERROR_INVALID_ARGUMENT:
7657c478bd9Sstevel@tonic-gate 			bad_error("scf_instance_get_pg", scf_error());
7667c478bd9Sstevel@tonic-gate 		}
7677c478bd9Sstevel@tonic-gate 
7687c478bd9Sstevel@tonic-gate 		/* Try creating the restarter_actions property group. */
7697c478bd9Sstevel@tonic-gate add:
7707c478bd9Sstevel@tonic-gate 		if (scf_instance_add_pg(inst, SCF_PG_RESTARTER_ACTIONS,
7717c478bd9Sstevel@tonic-gate 		    SCF_PG_RESTARTER_ACTIONS_TYPE,
7727c478bd9Sstevel@tonic-gate 		    SCF_PG_RESTARTER_ACTIONS_FLAGS, pg) == -1) {
7737c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
7747c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
7757c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
7767c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
7777c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
7787c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
7797c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
7807c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_READONLY:
7817c478bd9Sstevel@tonic-gate 			default:
7827c478bd9Sstevel@tonic-gate 				goto out;
7837c478bd9Sstevel@tonic-gate 
7847c478bd9Sstevel@tonic-gate 			case SCF_ERROR_EXISTS:
7857c478bd9Sstevel@tonic-gate 				goto get;
7867c478bd9Sstevel@tonic-gate 
7877c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
7887c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
7897c478bd9Sstevel@tonic-gate 				bad_error("scf_instance_add_pg", scf_error());
7907c478bd9Sstevel@tonic-gate 			}
7917c478bd9Sstevel@tonic-gate 		}
7927c478bd9Sstevel@tonic-gate 	}
7937c478bd9Sstevel@tonic-gate 
7947c478bd9Sstevel@tonic-gate 	for (;;) {
7957c478bd9Sstevel@tonic-gate 		timestamp = gethrtime();
7967c478bd9Sstevel@tonic-gate 
7977c478bd9Sstevel@tonic-gate 		if (scf_pg_get_property(pg, action, prop) != 0) {
7987c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
7997c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
8007c478bd9Sstevel@tonic-gate 			default:
8017c478bd9Sstevel@tonic-gate 				goto out;
8027c478bd9Sstevel@tonic-gate 
8037c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
8047c478bd9Sstevel@tonic-gate 				goto add;
8057c478bd9Sstevel@tonic-gate 
8067c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_FOUND:
8077c478bd9Sstevel@tonic-gate 				break;
8087c478bd9Sstevel@tonic-gate 
8097c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
8107c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
8117c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
8127c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
8137c478bd9Sstevel@tonic-gate 				bad_error("scf_pg_get_property", scf_error());
8147c478bd9Sstevel@tonic-gate 			}
8157c478bd9Sstevel@tonic-gate 		} else if (scf_property_get_value(prop, v) != 0) {
8167c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
8177c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
8187c478bd9Sstevel@tonic-gate 			default:
8197c478bd9Sstevel@tonic-gate 				goto out;
8207c478bd9Sstevel@tonic-gate 
8217c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
8227c478bd9Sstevel@tonic-gate 				goto add;
8237c478bd9Sstevel@tonic-gate 
8247c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONSTRAINT_VIOLATED:
8257c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_FOUND:
8267c478bd9Sstevel@tonic-gate 				break;
8277c478bd9Sstevel@tonic-gate 
8287c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
8297c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
8307c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
8317c478bd9Sstevel@tonic-gate 				bad_error("scf_property_get_value",
8327c478bd9Sstevel@tonic-gate 				    scf_error());
8337c478bd9Sstevel@tonic-gate 			}
8347c478bd9Sstevel@tonic-gate 		} else if (scf_value_get_integer(v, &t) != 0) {
8357c478bd9Sstevel@tonic-gate 			bad_error("scf_value_get_integer", scf_error());
8367c478bd9Sstevel@tonic-gate 		} else if (t > timestamp) {
8377c478bd9Sstevel@tonic-gate 			break;
8387c478bd9Sstevel@tonic-gate 		}
8397c478bd9Sstevel@tonic-gate 
8407c478bd9Sstevel@tonic-gate 		if (scf_transaction_start(tx, pg) == -1) {
8417c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
8427c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
8437c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
8447c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
8457c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
8467c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_READONLY:
8477c478bd9Sstevel@tonic-gate 			default:
8487c478bd9Sstevel@tonic-gate 				goto out;
8497c478bd9Sstevel@tonic-gate 
8507c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
8517c478bd9Sstevel@tonic-gate 				goto add;
8527c478bd9Sstevel@tonic-gate 
8537c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
8547c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
8557c478bd9Sstevel@tonic-gate 			case SCF_ERROR_IN_USE:
8567c478bd9Sstevel@tonic-gate 				bad_error("scf_transaction_start", scf_error());
8577c478bd9Sstevel@tonic-gate 			}
8587c478bd9Sstevel@tonic-gate 		}
8597c478bd9Sstevel@tonic-gate 
8607c478bd9Sstevel@tonic-gate 		if (transaction_property_set(tx, ent, action,
8617c478bd9Sstevel@tonic-gate 		    SCF_TYPE_INTEGER) != 0) {
8627c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
8637c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
8647c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
8657c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
8667c478bd9Sstevel@tonic-gate 			default:
8677c478bd9Sstevel@tonic-gate 				goto out;
8687c478bd9Sstevel@tonic-gate 
8697c478bd9Sstevel@tonic-gate 			case SCF_ERROR_HANDLE_MISMATCH:
8707c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
8717c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
8727c478bd9Sstevel@tonic-gate 				bad_error("transaction_property_set",
8737c478bd9Sstevel@tonic-gate 				    scf_error());
8747c478bd9Sstevel@tonic-gate 			}
8757c478bd9Sstevel@tonic-gate 		}
8767c478bd9Sstevel@tonic-gate 
8777c478bd9Sstevel@tonic-gate 		scf_value_set_integer(v, timestamp);
8787c478bd9Sstevel@tonic-gate 		if (scf_entry_add_value(ent, v) == -1)
8797c478bd9Sstevel@tonic-gate 			bad_error("scf_entry_add_value", scf_error());
8807c478bd9Sstevel@tonic-gate 
8817c478bd9Sstevel@tonic-gate 		trans = scf_transaction_commit(tx);
8827c478bd9Sstevel@tonic-gate 		if (trans == 1)
8837c478bd9Sstevel@tonic-gate 			break;
8847c478bd9Sstevel@tonic-gate 
8857c478bd9Sstevel@tonic-gate 		if (trans != 0) {
8867c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
8877c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
8887c478bd9Sstevel@tonic-gate 			case SCF_ERROR_PERMISSION_DENIED:
8897c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_ACCESS:
8907c478bd9Sstevel@tonic-gate 			case SCF_ERROR_BACKEND_READONLY:
8917c478bd9Sstevel@tonic-gate 			default:
8927c478bd9Sstevel@tonic-gate 				goto out;
8937c478bd9Sstevel@tonic-gate 
8947c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
8957c478bd9Sstevel@tonic-gate 				scf_transaction_reset(tx);
8967c478bd9Sstevel@tonic-gate 				goto add;
8977c478bd9Sstevel@tonic-gate 
8987c478bd9Sstevel@tonic-gate 			case SCF_ERROR_INVALID_ARGUMENT:
8997c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
9007c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
9017c478bd9Sstevel@tonic-gate 				bad_error("scf_transaction_commit",
9027c478bd9Sstevel@tonic-gate 				    scf_error());
9037c478bd9Sstevel@tonic-gate 			}
9047c478bd9Sstevel@tonic-gate 		}
9057c478bd9Sstevel@tonic-gate 
9067c478bd9Sstevel@tonic-gate 		scf_transaction_reset(tx);
9077c478bd9Sstevel@tonic-gate 		if (scf_pg_update(pg) != 0) {
9087c478bd9Sstevel@tonic-gate 			switch (scf_error()) {
9097c478bd9Sstevel@tonic-gate 			case SCF_ERROR_CONNECTION_BROKEN:
9107c478bd9Sstevel@tonic-gate 			default:
9117c478bd9Sstevel@tonic-gate 				goto out;
9127c478bd9Sstevel@tonic-gate 
9137c478bd9Sstevel@tonic-gate 			case SCF_ERROR_DELETED:
9147c478bd9Sstevel@tonic-gate 				goto add;
9157c478bd9Sstevel@tonic-gate 
9167c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_SET:
9177c478bd9Sstevel@tonic-gate 			case SCF_ERROR_NOT_BOUND:
9187c478bd9Sstevel@tonic-gate 				bad_error("scf_pg_update", scf_error());
9197c478bd9Sstevel@tonic-gate 			}
9207c478bd9Sstevel@tonic-gate 		}
9217c478bd9Sstevel@tonic-gate 	}
9227c478bd9Sstevel@tonic-gate 
9237c478bd9Sstevel@tonic-gate 	ret = 0;
9247c478bd9Sstevel@tonic-gate 
9257c478bd9Sstevel@tonic-gate out:
9267c478bd9Sstevel@tonic-gate 	scf_value_destroy(v);
9277c478bd9Sstevel@tonic-gate 	scf_entry_destroy(ent);
9287c478bd9Sstevel@tonic-gate 	scf_transaction_destroy(tx);
9297c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
9307c478bd9Sstevel@tonic-gate 	scf_pg_destroy(pg);
9317c478bd9Sstevel@tonic-gate 	return (ret);
9327c478bd9Sstevel@tonic-gate }
9337c478bd9Sstevel@tonic-gate 
9347c478bd9Sstevel@tonic-gate static int
9357c478bd9Sstevel@tonic-gate set_inst_action(const char *fmri, const char *action)
9367c478bd9Sstevel@tonic-gate {
9377c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
9387c478bd9Sstevel@tonic-gate 	scf_instance_t *inst;
9397c478bd9Sstevel@tonic-gate 	int ret = -1;
9407c478bd9Sstevel@tonic-gate 
9417c478bd9Sstevel@tonic-gate 	h = handle_create();
9427c478bd9Sstevel@tonic-gate 	if (h == NULL)
9437c478bd9Sstevel@tonic-gate 		return (-1);
9447c478bd9Sstevel@tonic-gate 
9457c478bd9Sstevel@tonic-gate 	inst = scf_instance_create(h);
9467c478bd9Sstevel@tonic-gate 
9477c478bd9Sstevel@tonic-gate 	if (inst != NULL) {
9487c478bd9Sstevel@tonic-gate 		if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
9497c478bd9Sstevel@tonic-gate 		    NULL, SCF_DECODE_FMRI_EXACT) == 0)
9507c478bd9Sstevel@tonic-gate 			ret = set_inst_action_inst(inst, action);
9517c478bd9Sstevel@tonic-gate 		else if (scf_error() == SCF_ERROR_CONSTRAINT_VIOLATED)
9527c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
9537c478bd9Sstevel@tonic-gate 
9547c478bd9Sstevel@tonic-gate 		scf_instance_destroy(inst);
9557c478bd9Sstevel@tonic-gate 	}
9567c478bd9Sstevel@tonic-gate 
9577c478bd9Sstevel@tonic-gate 	scf_handle_destroy(h);
9587c478bd9Sstevel@tonic-gate 
9597c478bd9Sstevel@tonic-gate 	return (ret);
9607c478bd9Sstevel@tonic-gate }
9617c478bd9Sstevel@tonic-gate 
9627c478bd9Sstevel@tonic-gate 
9637c478bd9Sstevel@tonic-gate /*
9647c478bd9Sstevel@tonic-gate  * get_inst_state() gets the state string from an instance, and returns
9657c478bd9Sstevel@tonic-gate  * the SCF_STATE_* constant that coincides with the instance's current state.
9667c478bd9Sstevel@tonic-gate  */
9677c478bd9Sstevel@tonic-gate 
9687c478bd9Sstevel@tonic-gate static int
9697c478bd9Sstevel@tonic-gate get_inst_state(scf_instance_t *inst, scf_handle_t *h)
9707c478bd9Sstevel@tonic-gate {
9717c478bd9Sstevel@tonic-gate 	scf_propertygroup_t	*pg = NULL;
9727c478bd9Sstevel@tonic-gate 	scf_property_t		*prop = NULL;
9737c478bd9Sstevel@tonic-gate 	scf_value_t		*val = NULL;
9747c478bd9Sstevel@tonic-gate 	char			state[MAX_SCF_STATE_STRING_SZ];
9757c478bd9Sstevel@tonic-gate 	int			ret = -1;
9767c478bd9Sstevel@tonic-gate 
9777c478bd9Sstevel@tonic-gate 	if (((pg = scf_pg_create(h)) == NULL) ||
9787c478bd9Sstevel@tonic-gate 	    ((prop = scf_property_create(h)) == NULL) ||
9797c478bd9Sstevel@tonic-gate 	    ((val = scf_value_create(h)) == NULL))
9807c478bd9Sstevel@tonic-gate 		goto out;
9817c478bd9Sstevel@tonic-gate 
9827c478bd9Sstevel@tonic-gate 	/* Pull the state property from the instance */
9837c478bd9Sstevel@tonic-gate 
9847c478bd9Sstevel@tonic-gate 	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) == -1 ||
9857c478bd9Sstevel@tonic-gate 	    scf_pg_get_property(pg, SCF_PROPERTY_STATE, prop) == -1 ||
9867c478bd9Sstevel@tonic-gate 	    scf_property_get_value(prop, val) == -1) {
9877c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
9887c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
9897c478bd9Sstevel@tonic-gate 		goto out;
9907c478bd9Sstevel@tonic-gate 	}
9917c478bd9Sstevel@tonic-gate 
9927c478bd9Sstevel@tonic-gate 	if (scf_value_get_astring(val, state, sizeof (state)) <= 0) {
9937c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INTERNAL);
9947c478bd9Sstevel@tonic-gate 		goto out;
9957c478bd9Sstevel@tonic-gate 	}
9967c478bd9Sstevel@tonic-gate 
9977c478bd9Sstevel@tonic-gate 	if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) {
9987c478bd9Sstevel@tonic-gate 		ret = SCF_STATE_UNINIT;
9997c478bd9Sstevel@tonic-gate 	} else if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
10007c478bd9Sstevel@tonic-gate 		ret = SCF_STATE_MAINT;
10017c478bd9Sstevel@tonic-gate 	} else if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0) {
10027c478bd9Sstevel@tonic-gate 		ret = SCF_STATE_OFFLINE;
10037c478bd9Sstevel@tonic-gate 	} else if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) {
10047c478bd9Sstevel@tonic-gate 		ret = SCF_STATE_DISABLED;
10057c478bd9Sstevel@tonic-gate 	} else if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) {
10067c478bd9Sstevel@tonic-gate 		ret = SCF_STATE_ONLINE;
10077c478bd9Sstevel@tonic-gate 	} else if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) {
10087c478bd9Sstevel@tonic-gate 		ret = SCF_STATE_DEGRADED;
10097c478bd9Sstevel@tonic-gate 	}
10107c478bd9Sstevel@tonic-gate 
10117c478bd9Sstevel@tonic-gate out:
10127c478bd9Sstevel@tonic-gate 	scf_pg_destroy(pg);
10137c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
10147c478bd9Sstevel@tonic-gate 	(void) scf_value_destroy(val);
10157c478bd9Sstevel@tonic-gate 
10167c478bd9Sstevel@tonic-gate 	return (ret);
10177c478bd9Sstevel@tonic-gate }
10187c478bd9Sstevel@tonic-gate 
10197c478bd9Sstevel@tonic-gate /*
10207c478bd9Sstevel@tonic-gate  * Sets an instance to be enabled or disabled after reboot, using the
10217c478bd9Sstevel@tonic-gate  * temporary (overriding) general_ovr property group to reflect the
10227c478bd9Sstevel@tonic-gate  * present state, if it is different.
10237c478bd9Sstevel@tonic-gate  */
10247c478bd9Sstevel@tonic-gate static int
10257c478bd9Sstevel@tonic-gate set_inst_enabled_atboot(scf_instance_t *inst, uint8_t desired)
10267c478bd9Sstevel@tonic-gate {
10277c478bd9Sstevel@tonic-gate 	int enabled;
10287c478bd9Sstevel@tonic-gate 	int persistent;
10297c478bd9Sstevel@tonic-gate 	int ret = -1;
10307c478bd9Sstevel@tonic-gate 
10317c478bd9Sstevel@tonic-gate 	if ((persistent = get_inst_enabled(inst, SCF_PG_GENERAL)) < 0) {
10327c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_NOT_FOUND)
10337c478bd9Sstevel@tonic-gate 			goto out;
10347c478bd9Sstevel@tonic-gate 		persistent = B_FALSE;
10357c478bd9Sstevel@tonic-gate 	}
10367c478bd9Sstevel@tonic-gate 	if ((enabled = get_inst_enabled(inst, SCF_PG_GENERAL_OVR)) < 0) {
10377c478bd9Sstevel@tonic-gate 		enabled = persistent;
10387c478bd9Sstevel@tonic-gate 		if (persistent != desired) {
10397c478bd9Sstevel@tonic-gate 			/*
10407c478bd9Sstevel@tonic-gate 			 * Temporarily store the present enabled state.
10417c478bd9Sstevel@tonic-gate 			 */
10427c478bd9Sstevel@tonic-gate 			if (set_inst_enabled(inst, persistent,
10437c478bd9Sstevel@tonic-gate 			    SCF_PG_GENERAL_OVR, SCF_PG_GENERAL_OVR_FLAGS))
10447c478bd9Sstevel@tonic-gate 				goto out;
10457c478bd9Sstevel@tonic-gate 		}
10467c478bd9Sstevel@tonic-gate 	}
10477c478bd9Sstevel@tonic-gate 	if (persistent != desired)
10487c478bd9Sstevel@tonic-gate 		if (set_inst_enabled(inst, desired, SCF_PG_GENERAL,
10497c478bd9Sstevel@tonic-gate 		    SCF_PG_GENERAL_FLAGS))
10507c478bd9Sstevel@tonic-gate 			goto out;
10517c478bd9Sstevel@tonic-gate 	if (enabled == desired)
10527c478bd9Sstevel@tonic-gate 		ret = delete_inst_enabled(inst, SCF_PG_GENERAL_OVR);
10537c478bd9Sstevel@tonic-gate 	else
10547c478bd9Sstevel@tonic-gate 		ret = 0;
10557c478bd9Sstevel@tonic-gate 
10567c478bd9Sstevel@tonic-gate out:
10577c478bd9Sstevel@tonic-gate 	return (ret);
10587c478bd9Sstevel@tonic-gate }
10597c478bd9Sstevel@tonic-gate 
10607c478bd9Sstevel@tonic-gate static int
10617c478bd9Sstevel@tonic-gate set_inst_enabled_flags(const char *fmri, int flags, uint8_t desired)
10627c478bd9Sstevel@tonic-gate {
10637c478bd9Sstevel@tonic-gate 	int ret = -1;
10647c478bd9Sstevel@tonic-gate 	scf_handle_t *h;
10657c478bd9Sstevel@tonic-gate 	scf_instance_t *inst;
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate 	if (flags & ~(SMF_TEMPORARY | SMF_AT_NEXT_BOOT) ||
10687c478bd9Sstevel@tonic-gate 	    flags & SMF_TEMPORARY && flags & SMF_AT_NEXT_BOOT) {
10697c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
10707c478bd9Sstevel@tonic-gate 		return (ret);
10717c478bd9Sstevel@tonic-gate 	}
10727c478bd9Sstevel@tonic-gate 
10737c478bd9Sstevel@tonic-gate 	if ((h = handle_create()) == NULL)
10747c478bd9Sstevel@tonic-gate 		return (ret);
10757c478bd9Sstevel@tonic-gate 
10767c478bd9Sstevel@tonic-gate 	if ((inst = scf_instance_create(h)) == NULL) {
10777c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
10787c478bd9Sstevel@tonic-gate 		return (ret);
10797c478bd9Sstevel@tonic-gate 	}
10807c478bd9Sstevel@tonic-gate 
10817c478bd9Sstevel@tonic-gate 	if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL, NULL,
10827c478bd9Sstevel@tonic-gate 	    SCF_DECODE_FMRI_EXACT) == -1) {
10837c478bd9Sstevel@tonic-gate 		if (scf_error() == SCF_ERROR_CONSTRAINT_VIOLATED)
10847c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
10857c478bd9Sstevel@tonic-gate 		goto out;
10867c478bd9Sstevel@tonic-gate 	}
10877c478bd9Sstevel@tonic-gate 
10887c478bd9Sstevel@tonic-gate 	if (flags & SMF_AT_NEXT_BOOT) {
10897c478bd9Sstevel@tonic-gate 		ret = set_inst_enabled_atboot(inst, desired);
10907c478bd9Sstevel@tonic-gate 	} else {
10917c478bd9Sstevel@tonic-gate 		if (set_inst_enabled(inst, desired, flags & SMF_TEMPORARY ?
10927c478bd9Sstevel@tonic-gate 		    SCF_PG_GENERAL_OVR : SCF_PG_GENERAL, flags & SMF_TEMPORARY ?
10937c478bd9Sstevel@tonic-gate 		    SCF_PG_GENERAL_OVR_FLAGS : SCF_PG_GENERAL_FLAGS))
10947c478bd9Sstevel@tonic-gate 			goto out;
10957c478bd9Sstevel@tonic-gate 
10967c478bd9Sstevel@tonic-gate 		/*
10977c478bd9Sstevel@tonic-gate 		 * Make the persistent value effective by deleting the
10987c478bd9Sstevel@tonic-gate 		 * temporary one.
10997c478bd9Sstevel@tonic-gate 		 */
11007c478bd9Sstevel@tonic-gate 		if (flags & SMF_TEMPORARY)
11017c478bd9Sstevel@tonic-gate 			ret = 0;
11027c478bd9Sstevel@tonic-gate 		else
11037c478bd9Sstevel@tonic-gate 			ret = delete_inst_enabled(inst, SCF_PG_GENERAL_OVR);
11047c478bd9Sstevel@tonic-gate 	}
11057c478bd9Sstevel@tonic-gate 
11067c478bd9Sstevel@tonic-gate out:
11077c478bd9Sstevel@tonic-gate 	scf_instance_destroy(inst);
11087c478bd9Sstevel@tonic-gate 	scf_handle_destroy(h);
11097c478bd9Sstevel@tonic-gate 	return (ret);
11107c478bd9Sstevel@tonic-gate }
11117c478bd9Sstevel@tonic-gate 
1112d75e6a5dStn /*
1113d75e6a5dStn  * Create and return a pg from the instance associated with the given handle.
1114d75e6a5dStn  * This function is only called in scf_transaction_setup and
1115d75e6a5dStn  * scf_transaction_restart where the h->rh_instance pointer is properly filled
1116d75e6a5dStn  * in by scf_general_setup_pg().
1117d75e6a5dStn  */
1118d75e6a5dStn static scf_propertygroup_t *
1119d75e6a5dStn get_instance_pg(scf_simple_handle_t *simple_h)
1120d75e6a5dStn {
1121d75e6a5dStn 	scf_propertygroup_t	*ret_pg = scf_pg_create(simple_h->h);
1122d75e6a5dStn 	char			*pg_name;
1123d75e6a5dStn 	ssize_t			namelen;
1124d75e6a5dStn 
1125d75e6a5dStn 	if (ret_pg == NULL) {
1126d75e6a5dStn 		return (NULL);
1127d75e6a5dStn 	}
1128d75e6a5dStn 
1129d75e6a5dStn 	if ((namelen = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH)) == -1) {
1130d75e6a5dStn 		if (scf_error() == SCF_ERROR_NOT_SET) {
1131d75e6a5dStn 			(void) scf_set_error(SCF_ERROR_INTERNAL);
1132d75e6a5dStn 		}
1133d75e6a5dStn 		return (NULL);
1134d75e6a5dStn 	}
1135d75e6a5dStn 
1136d75e6a5dStn 	if ((pg_name = malloc(namelen)) == NULL) {
1137d75e6a5dStn 		if (scf_error() == SCF_ERROR_NOT_SET) {
1138d75e6a5dStn 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1139d75e6a5dStn 		}
1140d75e6a5dStn 		return (NULL);
1141d75e6a5dStn 	}
1142d75e6a5dStn 
1143d75e6a5dStn 	if (scf_pg_get_name(simple_h->running_pg, pg_name, namelen) < 0) {
1144d75e6a5dStn 		if (scf_error() == SCF_ERROR_NOT_SET) {
1145d75e6a5dStn 			(void) scf_set_error(SCF_ERROR_INTERNAL);
1146d75e6a5dStn 		}
1147d75e6a5dStn 		return (NULL);
1148d75e6a5dStn 	}
1149d75e6a5dStn 
1150d75e6a5dStn 	/* Get pg from instance */
1151d75e6a5dStn 	if (scf_instance_get_pg(simple_h->inst, pg_name, ret_pg) == -1) {
1152d75e6a5dStn 		return (NULL);
1153d75e6a5dStn 	}
1154d75e6a5dStn 
1155d75e6a5dStn 	return (ret_pg);
1156d75e6a5dStn }
1157d75e6a5dStn 
11587c478bd9Sstevel@tonic-gate int
11597c478bd9Sstevel@tonic-gate smf_enable_instance(const char *fmri, int flags)
11607c478bd9Sstevel@tonic-gate {
11617c478bd9Sstevel@tonic-gate 	return (set_inst_enabled_flags(fmri, flags, B_TRUE));
11627c478bd9Sstevel@tonic-gate }
11637c478bd9Sstevel@tonic-gate 
11647c478bd9Sstevel@tonic-gate int
11657c478bd9Sstevel@tonic-gate smf_disable_instance(const char *fmri, int flags)
11667c478bd9Sstevel@tonic-gate {
11677c478bd9Sstevel@tonic-gate 	return (set_inst_enabled_flags(fmri, flags, B_FALSE));
11687c478bd9Sstevel@tonic-gate }
11697c478bd9Sstevel@tonic-gate 
11707c478bd9Sstevel@tonic-gate int
11717c478bd9Sstevel@tonic-gate _smf_refresh_instance_i(scf_instance_t *inst)
11727c478bd9Sstevel@tonic-gate {
11737c478bd9Sstevel@tonic-gate 	return (set_inst_action_inst(inst, SCF_PROPERTY_REFRESH));
11747c478bd9Sstevel@tonic-gate }
11757c478bd9Sstevel@tonic-gate 
11767c478bd9Sstevel@tonic-gate int
11777c478bd9Sstevel@tonic-gate smf_refresh_instance(const char *instance)
11787c478bd9Sstevel@tonic-gate {
11797c478bd9Sstevel@tonic-gate 	return (set_inst_action(instance, SCF_PROPERTY_REFRESH));
11807c478bd9Sstevel@tonic-gate }
11817c478bd9Sstevel@tonic-gate 
11827c478bd9Sstevel@tonic-gate int
11837c478bd9Sstevel@tonic-gate smf_restart_instance(const char *instance)
11847c478bd9Sstevel@tonic-gate {
11857c478bd9Sstevel@tonic-gate 	return (set_inst_action(instance, SCF_PROPERTY_RESTART));
11867c478bd9Sstevel@tonic-gate }
11877c478bd9Sstevel@tonic-gate 
11887c478bd9Sstevel@tonic-gate int
11897c478bd9Sstevel@tonic-gate smf_maintain_instance(const char *instance, int flags)
11907c478bd9Sstevel@tonic-gate {
11917c478bd9Sstevel@tonic-gate 	if (flags & SMF_TEMPORARY)
11927c478bd9Sstevel@tonic-gate 		return (set_inst_action(instance,
11937c478bd9Sstevel@tonic-gate 		    (flags & SMF_IMMEDIATE) ?
11947c478bd9Sstevel@tonic-gate 		    SCF_PROPERTY_MAINT_ON_IMMTEMP :
11957c478bd9Sstevel@tonic-gate 		    SCF_PROPERTY_MAINT_ON_TEMPORARY));
11967c478bd9Sstevel@tonic-gate 	else
11977c478bd9Sstevel@tonic-gate 		return (set_inst_action(instance,
11987c478bd9Sstevel@tonic-gate 		    (flags & SMF_IMMEDIATE) ?
11997c478bd9Sstevel@tonic-gate 		    SCF_PROPERTY_MAINT_ON_IMMEDIATE :
12007c478bd9Sstevel@tonic-gate 		    SCF_PROPERTY_MAINT_ON));
12017c478bd9Sstevel@tonic-gate }
12027c478bd9Sstevel@tonic-gate 
12037c478bd9Sstevel@tonic-gate int
12047c478bd9Sstevel@tonic-gate smf_degrade_instance(const char *instance, int flags)
12057c478bd9Sstevel@tonic-gate {
12067c478bd9Sstevel@tonic-gate 	scf_simple_prop_t		*prop;
12077c478bd9Sstevel@tonic-gate 	const char			*state_str;
12087c478bd9Sstevel@tonic-gate 
12097c478bd9Sstevel@tonic-gate 	if (flags & SMF_TEMPORARY)
12107c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
12117c478bd9Sstevel@tonic-gate 
12127c478bd9Sstevel@tonic-gate 	if ((prop = scf_simple_prop_get(NULL, instance, SCF_PG_RESTARTER,
12137c478bd9Sstevel@tonic-gate 	    SCF_PROPERTY_STATE)) == NULL)
12147c478bd9Sstevel@tonic-gate 		return (SCF_FAILED);
12157c478bd9Sstevel@tonic-gate 
12167c478bd9Sstevel@tonic-gate 	if ((state_str = scf_simple_prop_next_astring(prop)) == NULL) {
12177c478bd9Sstevel@tonic-gate 		scf_simple_prop_free(prop);
12187c478bd9Sstevel@tonic-gate 		return (SCF_FAILED);
12197c478bd9Sstevel@tonic-gate 	}
12207c478bd9Sstevel@tonic-gate 
12217c478bd9Sstevel@tonic-gate 	if (strcmp(state_str, SCF_STATE_STRING_ONLINE) != 0) {
12227c478bd9Sstevel@tonic-gate 		scf_simple_prop_free(prop);
12237c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
12247c478bd9Sstevel@tonic-gate 	}
12257c478bd9Sstevel@tonic-gate 	scf_simple_prop_free(prop);
12267c478bd9Sstevel@tonic-gate 
12277c478bd9Sstevel@tonic-gate 	return (set_inst_action(instance, (flags & SMF_IMMEDIATE) ?
12287c478bd9Sstevel@tonic-gate 	    SCF_PROPERTY_DEGRADE_IMMEDIATE : SCF_PROPERTY_DEGRADED));
12297c478bd9Sstevel@tonic-gate }
12307c478bd9Sstevel@tonic-gate 
12317c478bd9Sstevel@tonic-gate int
12327c478bd9Sstevel@tonic-gate smf_restore_instance(const char *instance)
12337c478bd9Sstevel@tonic-gate {
12347c478bd9Sstevel@tonic-gate 	scf_simple_prop_t		*prop;
12357c478bd9Sstevel@tonic-gate 	const char			*state_str;
12367c478bd9Sstevel@tonic-gate 	int				ret;
12377c478bd9Sstevel@tonic-gate 
12387c478bd9Sstevel@tonic-gate 	if ((prop = scf_simple_prop_get(NULL, instance, SCF_PG_RESTARTER,
12397c478bd9Sstevel@tonic-gate 	    SCF_PROPERTY_STATE)) == NULL)
12407c478bd9Sstevel@tonic-gate 		return (SCF_FAILED);
12417c478bd9Sstevel@tonic-gate 
12427c478bd9Sstevel@tonic-gate 	if ((state_str = scf_simple_prop_next_astring(prop)) == NULL) {
12437c478bd9Sstevel@tonic-gate 		scf_simple_prop_free(prop);
12447c478bd9Sstevel@tonic-gate 		return (SCF_FAILED);
12457c478bd9Sstevel@tonic-gate 	}
12467c478bd9Sstevel@tonic-gate 
12477c478bd9Sstevel@tonic-gate 	if (strcmp(state_str, SCF_STATE_STRING_MAINT) == 0) {
12487c478bd9Sstevel@tonic-gate 		ret = set_inst_action(instance, SCF_PROPERTY_MAINT_OFF);
12497c478bd9Sstevel@tonic-gate 	} else if (strcmp(state_str, SCF_STATE_STRING_DEGRADED) == 0) {
12507c478bd9Sstevel@tonic-gate 		ret = set_inst_action(instance, SCF_PROPERTY_RESTORE);
12517c478bd9Sstevel@tonic-gate 	} else {
12527c478bd9Sstevel@tonic-gate 		ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED);
12537c478bd9Sstevel@tonic-gate 	}
12547c478bd9Sstevel@tonic-gate 
12557c478bd9Sstevel@tonic-gate 	scf_simple_prop_free(prop);
12567c478bd9Sstevel@tonic-gate 	return (ret);
12577c478bd9Sstevel@tonic-gate }
12587c478bd9Sstevel@tonic-gate 
12597c478bd9Sstevel@tonic-gate char *
12607c478bd9Sstevel@tonic-gate smf_get_state(const char *instance)
12617c478bd9Sstevel@tonic-gate {
12627c478bd9Sstevel@tonic-gate 	scf_simple_prop_t		*prop;
12637c478bd9Sstevel@tonic-gate 	const char			*state_str;
12647c478bd9Sstevel@tonic-gate 	char				*ret;
12657c478bd9Sstevel@tonic-gate 
12667c478bd9Sstevel@tonic-gate 	if ((prop = scf_simple_prop_get(NULL, instance, SCF_PG_RESTARTER,
12677c478bd9Sstevel@tonic-gate 	    SCF_PROPERTY_STATE)) == NULL)
12687c478bd9Sstevel@tonic-gate 		return (NULL);
12697c478bd9Sstevel@tonic-gate 
12707c478bd9Sstevel@tonic-gate 	if ((state_str = scf_simple_prop_next_astring(prop)) == NULL) {
12717c478bd9Sstevel@tonic-gate 		scf_simple_prop_free(prop);
12727c478bd9Sstevel@tonic-gate 		return (NULL);
12737c478bd9Sstevel@tonic-gate 	}
12747c478bd9Sstevel@tonic-gate 
12757c478bd9Sstevel@tonic-gate 	if ((ret = strdup(state_str)) == NULL)
12767c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
12777c478bd9Sstevel@tonic-gate 
12787c478bd9Sstevel@tonic-gate 	scf_simple_prop_free(prop);
12797c478bd9Sstevel@tonic-gate 	return (ret);
12807c478bd9Sstevel@tonic-gate }
12817c478bd9Sstevel@tonic-gate 
1282d75e6a5dStn /*
1283d75e6a5dStn  * scf_general_pg_setup(fmri, pg_name)
1284d75e6a5dStn  * Create a scf_simple_handle_t and fill in the instance, snapshot, and
1285d75e6a5dStn  * property group fields associated with the given fmri and property group
1286d75e6a5dStn  * name.
1287d75e6a5dStn  * Returns:
1288d75e6a5dStn  *      Handle  on success
1289d75e6a5dStn  *      Null  on error with scf_error set to:
1290d75e6a5dStn  *              SCF_ERROR_HANDLE_MISMATCH,
1291d75e6a5dStn  *              SCF_ERROR_INVALID_ARGUMENT,
1292d75e6a5dStn  *              SCF_ERROR_CONSTRAINT_VIOLATED,
1293d75e6a5dStn  *              SCF_ERROR_NOT_FOUND,
1294d75e6a5dStn  *              SCF_ERROR_NOT_SET,
1295d75e6a5dStn  *              SCF_ERROR_DELETED,
1296d75e6a5dStn  *              SCF_ERROR_NOT_BOUND,
1297d75e6a5dStn  *              SCF_ERROR_CONNECTION_BROKEN,
1298d75e6a5dStn  *              SCF_ERROR_INTERNAL,
1299d75e6a5dStn  *              SCF_ERROR_NO_RESOURCES,
1300d75e6a5dStn  *              SCF_ERROR_BACKEND_ACCESS
1301d75e6a5dStn  */
1302d75e6a5dStn scf_simple_handle_t *
1303d75e6a5dStn scf_general_pg_setup(const char *fmri, const char *pg_name)
1304d75e6a5dStn {
1305d75e6a5dStn 	scf_simple_handle_t	*ret;
1306d75e6a5dStn 
1307d75e6a5dStn 	ret = uu_zalloc(sizeof (*ret));
1308d75e6a5dStn 	if (ret == NULL) {
1309d75e6a5dStn 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1310d75e6a5dStn 		return (NULL);
1311d75e6a5dStn 	} else {
1312d75e6a5dStn 
1313d75e6a5dStn 		ret->h = handle_create();
1314d75e6a5dStn 		ret->inst = scf_instance_create(ret->h);
1315d75e6a5dStn 		ret->snap = scf_snapshot_create(ret->h);
1316d75e6a5dStn 		ret->running_pg = scf_pg_create(ret->h);
1317d75e6a5dStn 	}
1318d75e6a5dStn 
1319d75e6a5dStn 	if ((ret->h == NULL) || (ret->inst == NULL) ||
1320d75e6a5dStn 	    (ret->snap == NULL) || (ret->running_pg == NULL)) {
1321d75e6a5dStn 		goto out;
1322d75e6a5dStn 	}
1323d75e6a5dStn 
1324d75e6a5dStn 	if (scf_handle_decode_fmri(ret->h, fmri, NULL, NULL, ret->inst,
1325d75e6a5dStn 	    NULL, NULL, NULL) == -1) {
1326d75e6a5dStn 		goto out;
1327d75e6a5dStn 	}
1328d75e6a5dStn 
1329d75e6a5dStn 	if ((scf_instance_get_snapshot(ret->inst, "running", ret->snap))
1330d75e6a5dStn 	    != 0) {
1331d75e6a5dStn 		goto out;
1332d75e6a5dStn 	}
1333d75e6a5dStn 
1334d75e6a5dStn 	if (scf_instance_get_pg_composed(ret->inst, ret->snap, pg_name,
1335d75e6a5dStn 	    ret->running_pg) != 0) {
1336d75e6a5dStn 		goto out;
1337d75e6a5dStn 	}
1338d75e6a5dStn 
1339d75e6a5dStn 	return (ret);
1340d75e6a5dStn 
1341d75e6a5dStn out:
1342d75e6a5dStn 	scf_simple_handle_destroy(ret);
1343d75e6a5dStn 	return (NULL);
1344d75e6a5dStn }
1345d75e6a5dStn 
1346d75e6a5dStn /*
1347d75e6a5dStn  * scf_transaction_setup(h)
1348d75e6a5dStn  * creates and starts the transaction
1349d75e6a5dStn  * Returns:
1350d75e6a5dStn  *      transaction  on success
1351d75e6a5dStn  *      NULL on failure with scf_error set to:
1352d75e6a5dStn  *      SCF_ERROR_NO_MEMORY,
1353d75e6a5dStn  *	SCF_ERROR_INVALID_ARGUMENT,
1354d75e6a5dStn  *      SCF_ERROR_HANDLE_DESTROYED,
1355d75e6a5dStn  *	SCF_ERROR_INTERNAL,
1356d75e6a5dStn  *	SCF_ERROR_NO_RESOURCES,
1357d75e6a5dStn  *      SCF_ERROR_NOT_BOUND,
1358d75e6a5dStn  *	SCF_ERROR_CONNECTION_BROKEN,
1359d75e6a5dStn  *      SCF_ERROR_NOT_SET,
1360d75e6a5dStn  *	SCF_ERROR_DELETED,
1361d75e6a5dStn  *	SCF_ERROR_CONSTRAINT_VIOLATED,
1362d75e6a5dStn  *      SCF_ERROR_HANDLE_MISMATCH,
1363d75e6a5dStn  *	SCF_ERROR_BACKEND_ACCESS,
1364d75e6a5dStn  *	SCF_ERROR_IN_USE
1365d75e6a5dStn  */
1366d75e6a5dStn scf_transaction_t *
1367d75e6a5dStn scf_transaction_setup(scf_simple_handle_t *simple_h)
1368d75e6a5dStn {
1369d75e6a5dStn 	scf_transaction_t	*tx = NULL;
1370d75e6a5dStn 
1371d75e6a5dStn 	if ((tx = scf_transaction_create(simple_h->h)) == NULL) {
1372d75e6a5dStn 		return (NULL);
1373d75e6a5dStn 	}
1374d75e6a5dStn 
1375d75e6a5dStn 	if ((simple_h->editing_pg = get_instance_pg(simple_h)) == NULL) {
1376d75e6a5dStn 		return (NULL);
1377d75e6a5dStn 	}
1378d75e6a5dStn 
1379d75e6a5dStn 	if (scf_transaction_start(tx, simple_h->editing_pg) == -1) {
1380d75e6a5dStn 		scf_pg_destroy(simple_h->editing_pg);
1381d75e6a5dStn 		simple_h->editing_pg = NULL;
1382d75e6a5dStn 		return (NULL);
1383d75e6a5dStn 	}
1384d75e6a5dStn 
1385d75e6a5dStn 	return (tx);
1386d75e6a5dStn }
1387d75e6a5dStn 
1388d75e6a5dStn int
1389d75e6a5dStn scf_transaction_restart(scf_simple_handle_t *simple_h, scf_transaction_t *tx)
1390d75e6a5dStn {
1391d75e6a5dStn 	scf_transaction_reset(tx);
1392d75e6a5dStn 
1393d75e6a5dStn 	if (scf_pg_update(simple_h->editing_pg) == -1) {
1394d75e6a5dStn 		return (SCF_FAILED);
1395d75e6a5dStn 	}
1396d75e6a5dStn 
1397d75e6a5dStn 	if (scf_transaction_start(tx, simple_h->editing_pg) == -1) {
1398d75e6a5dStn 		return (SCF_FAILED);
1399d75e6a5dStn 	}
1400d75e6a5dStn 
1401d75e6a5dStn 	return (SCF_SUCCESS);
1402d75e6a5dStn }
1403d75e6a5dStn 
1404d75e6a5dStn /*
1405d75e6a5dStn  * scf_read_count_property(scf_simple_handle_t *simple_h, char *prop_name,
1406d75e6a5dStn  * uint64_t *ret_count)
1407d75e6a5dStn  *
1408d75e6a5dStn  * For the given property name, return the count value.
1409d75e6a5dStn  * RETURNS:
1410d75e6a5dStn  *	SCF_SUCCESS
1411d75e6a5dStn  *	SCF_FAILED on failure with scf_error() set to:
1412d75e6a5dStn  *		SCF_ERROR_HANDLE_DESTROYED
1413d75e6a5dStn  *		SCF_ERROR_INTERNAL
1414d75e6a5dStn  *		SCF_ERROR_NO_RESOURCES
1415d75e6a5dStn  *		SCF_ERROR_NO_MEMORY
1416d75e6a5dStn  *		SCF_ERROR_HANDLE_MISMATCH
1417d75e6a5dStn  *		SCF_ERROR_INVALID_ARGUMENT
1418d75e6a5dStn  *		SCF_ERROR_NOT_BOUND
1419d75e6a5dStn  *		SCF_ERROR_CONNECTION_BROKEN
1420d75e6a5dStn  *		SCF_ERROR_NOT_SET
1421d75e6a5dStn  *		SCF_ERROR_DELETED
1422d75e6a5dStn  *		SCF_ERROR_BACKEND_ACCESS
1423d75e6a5dStn  *		SCF_ERROR_CONSTRAINT_VIOLATED
1424d75e6a5dStn  *		SCF_ERROR_TYPE_MISMATCH
1425d75e6a5dStn  */
1426d75e6a5dStn int
1427d75e6a5dStn scf_read_count_property(
1428d75e6a5dStn 	scf_simple_handle_t	*simple_h,
1429d75e6a5dStn 	char			*prop_name,
1430d75e6a5dStn 	uint64_t		*ret_count)
1431d75e6a5dStn {
1432d75e6a5dStn 	scf_property_t		*prop = scf_property_create(simple_h->h);
1433d75e6a5dStn 	scf_value_t		*val = scf_value_create(simple_h->h);
1434d75e6a5dStn 	int			ret = SCF_FAILED;
1435d75e6a5dStn 
1436d75e6a5dStn 	if ((val == NULL) || (prop == NULL)) {
1437d75e6a5dStn 		goto out;
1438d75e6a5dStn 	}
1439d75e6a5dStn 
1440d75e6a5dStn 	/*
1441d75e6a5dStn 	 * Get the property struct that goes with this property group and
1442d75e6a5dStn 	 * property name.
1443d75e6a5dStn 	 */
1444d75e6a5dStn 	if (scf_pg_get_property(simple_h->running_pg, prop_name, prop) != 0) {
1445d75e6a5dStn 		goto out;
1446d75e6a5dStn 	}
1447d75e6a5dStn 
1448d75e6a5dStn 	/* Get the value structure */
1449d75e6a5dStn 	if (scf_property_get_value(prop, val) == -1) {
1450d75e6a5dStn 		goto out;
1451d75e6a5dStn 	}
1452d75e6a5dStn 
1453d75e6a5dStn 	/*
1454d75e6a5dStn 	 * Now get the count value.
1455d75e6a5dStn 	 */
1456d75e6a5dStn 	if (scf_value_get_count(val, ret_count) == -1) {
1457d75e6a5dStn 		goto out;
1458d75e6a5dStn 	}
1459d75e6a5dStn 
1460d75e6a5dStn 	ret = SCF_SUCCESS;
1461d75e6a5dStn 
1462d75e6a5dStn out:
1463d75e6a5dStn 	scf_property_destroy(prop);
1464d75e6a5dStn 	scf_value_destroy(val);
1465d75e6a5dStn 	return (ret);
1466d75e6a5dStn }
1467d75e6a5dStn 
1468d75e6a5dStn /*
1469d75e6a5dStn  * scf_trans_add_count_property(trans, propname, count, create_flag)
1470d75e6a5dStn  *
1471d75e6a5dStn  * Set a count property transaction entry into the pending SMF transaction.
1472d75e6a5dStn  * The transaction is created and committed outside of this function.
1473d75e6a5dStn  * Returns:
1474d75e6a5dStn  *	SCF_SUCCESS
1475d75e6a5dStn  *	SCF_FAILED on failure with scf_error() set to:
1476d75e6a5dStn  *			SCF_ERROR_HANDLE_DESTROYED,
1477d75e6a5dStn  *			SCF_ERROR_INVALID_ARGUMENT,
1478d75e6a5dStn  *			SCF_ERROR_NO_MEMORY,
1479d75e6a5dStn  *			SCF_ERROR_HANDLE_MISMATCH,
1480d75e6a5dStn  *			SCF_ERROR_NOT_SET,
1481d75e6a5dStn  *			SCF_ERROR_IN_USE,
1482d75e6a5dStn  *			SCF_ERROR_NOT_FOUND,
1483d75e6a5dStn  *			SCF_ERROR_EXISTS,
1484d75e6a5dStn  *			SCF_ERROR_TYPE_MISMATCH,
1485d75e6a5dStn  *			SCF_ERROR_NOT_BOUND,
1486d75e6a5dStn  *			SCF_ERROR_CONNECTION_BROKEN,
1487d75e6a5dStn  *			SCF_ERROR_INTERNAL,
1488d75e6a5dStn  *			SCF_ERROR_DELETED,
1489d75e6a5dStn  *			SCF_ERROR_NO_RESOURCES,
1490d75e6a5dStn  *			SCF_ERROR_BACKEND_ACCESS
1491d75e6a5dStn  */
1492d75e6a5dStn int
1493d75e6a5dStn scf_set_count_property(
1494d75e6a5dStn 	scf_transaction_t	*trans,
1495d75e6a5dStn 	char			*propname,
1496d75e6a5dStn 	uint64_t		count,
1497d75e6a5dStn 	boolean_t		create_flag)
1498d75e6a5dStn {
1499d75e6a5dStn 	scf_handle_t		*handle = scf_transaction_handle(trans);
1500d75e6a5dStn 	scf_value_t		*value = scf_value_create(handle);
1501d75e6a5dStn 	scf_transaction_entry_t	*entry = scf_entry_create(handle);
1502d75e6a5dStn 
1503d75e6a5dStn 	if ((value == NULL) || (entry == NULL)) {
1504d75e6a5dStn 		return (SCF_FAILED);
1505d75e6a5dStn 	}
1506d75e6a5dStn 
1507d75e6a5dStn 	/*
1508d75e6a5dStn 	 * Property must be set in transaction and won't take
1509d75e6a5dStn 	 * effect until the transaction is committed.
1510d75e6a5dStn 	 *
1511d75e6a5dStn 	 * Attempt to change the current value. However, create new property
1512d75e6a5dStn 	 * if it doesn't exist and the create flag is set.
1513d75e6a5dStn 	 */
1514d75e6a5dStn 	if (scf_transaction_property_change(trans, entry, propname,
1515d75e6a5dStn 	    SCF_TYPE_COUNT) == 0) {
1516d75e6a5dStn 		scf_value_set_count(value, count);
1517d75e6a5dStn 		if (scf_entry_add_value(entry, value) == 0) {
1518d75e6a5dStn 			return (SCF_SUCCESS);
1519d75e6a5dStn 		}
1520d75e6a5dStn 	} else {
1521d75e6a5dStn 		if ((create_flag == B_TRUE) &&
1522d75e6a5dStn 		    (scf_error() == SCF_ERROR_NOT_FOUND)) {
1523d75e6a5dStn 			if (scf_transaction_property_new(trans, entry, propname,
1524d75e6a5dStn 			    SCF_TYPE_COUNT) == 0) {
1525d75e6a5dStn 				scf_value_set_count(value, count);
1526d75e6a5dStn 				if (scf_entry_add_value(entry, value) == 0) {
1527d75e6a5dStn 					return (SCF_SUCCESS);
1528d75e6a5dStn 				}
1529d75e6a5dStn 			}
1530d75e6a5dStn 		}
1531d75e6a5dStn 	}
1532d75e6a5dStn 
1533d75e6a5dStn 	/*
1534d75e6a5dStn 	 * cleanup if there were any errors that didn't leave these
1535d75e6a5dStn 	 * values where they would be cleaned up later.
1536d75e6a5dStn 	 */
1537d75e6a5dStn 	if (value != NULL)
1538d75e6a5dStn 		scf_value_destroy(value);
1539d75e6a5dStn 	if (entry != NULL)
1540d75e6a5dStn 		scf_entry_destroy(entry);
1541d75e6a5dStn 	return (SCF_FAILED);
1542d75e6a5dStn }
1543d75e6a5dStn 
15447c478bd9Sstevel@tonic-gate int
15457c478bd9Sstevel@tonic-gate scf_simple_walk_instances(uint_t state_flags, void *private,
15467c478bd9Sstevel@tonic-gate     int (*inst_callback)(scf_handle_t *, scf_instance_t *, void *))
15477c478bd9Sstevel@tonic-gate {
15487c478bd9Sstevel@tonic-gate 	scf_scope_t 		*scope = NULL;
15497c478bd9Sstevel@tonic-gate 	scf_service_t		*svc = NULL;
15507c478bd9Sstevel@tonic-gate 	scf_instance_t		*inst = NULL;
15517c478bd9Sstevel@tonic-gate 	scf_iter_t		*svc_iter = NULL, *inst_iter = NULL;
15527c478bd9Sstevel@tonic-gate 	scf_handle_t		*h = NULL;
15537c478bd9Sstevel@tonic-gate 	int			ret = SCF_FAILED;
15547c478bd9Sstevel@tonic-gate 	int			svc_iter_ret, inst_iter_ret;
15557c478bd9Sstevel@tonic-gate 	int			inst_state;
15567c478bd9Sstevel@tonic-gate 
15577c478bd9Sstevel@tonic-gate 	if ((h = handle_create()) == NULL)
15587c478bd9Sstevel@tonic-gate 		return (ret);
15597c478bd9Sstevel@tonic-gate 
15607c478bd9Sstevel@tonic-gate 	if (((scope = scf_scope_create(h)) == NULL) ||
15617c478bd9Sstevel@tonic-gate 	    ((svc = scf_service_create(h)) == NULL) ||
15627c478bd9Sstevel@tonic-gate 	    ((inst = scf_instance_create(h)) == NULL) ||
15637c478bd9Sstevel@tonic-gate 	    ((svc_iter = scf_iter_create(h)) == NULL) ||
15647c478bd9Sstevel@tonic-gate 	    ((inst_iter = scf_iter_create(h)) == NULL))
15657c478bd9Sstevel@tonic-gate 		goto out;
15667c478bd9Sstevel@tonic-gate 
15677c478bd9Sstevel@tonic-gate 	/*
15687c478bd9Sstevel@tonic-gate 	 * Get the local scope, and set up nested iteration through every
15697c478bd9Sstevel@tonic-gate 	 * local service, and every instance of every service.
15707c478bd9Sstevel@tonic-gate 	 */
15717c478bd9Sstevel@tonic-gate 
15727c478bd9Sstevel@tonic-gate 	if ((scf_handle_get_local_scope(h, scope) != SCF_SUCCESS) ||
15737c478bd9Sstevel@tonic-gate 	    (scf_iter_scope_services(svc_iter, scope) != SCF_SUCCESS))
15747c478bd9Sstevel@tonic-gate 		goto out;
15757c478bd9Sstevel@tonic-gate 
15767c478bd9Sstevel@tonic-gate 	while ((svc_iter_ret = scf_iter_next_service(svc_iter, svc)) > 0) {
15777c478bd9Sstevel@tonic-gate 
15787c478bd9Sstevel@tonic-gate 		if ((scf_iter_service_instances(inst_iter, svc)) !=
15797c478bd9Sstevel@tonic-gate 		    SCF_SUCCESS)
15807c478bd9Sstevel@tonic-gate 			goto out;
15817c478bd9Sstevel@tonic-gate 
15827c478bd9Sstevel@tonic-gate 		while ((inst_iter_ret =
15837c478bd9Sstevel@tonic-gate 		    scf_iter_next_instance(inst_iter, inst)) > 0) {
15847c478bd9Sstevel@tonic-gate 			/*
15857c478bd9Sstevel@tonic-gate 			 * If get_inst_state fails from an internal error,
15867c478bd9Sstevel@tonic-gate 			 * IE, being unable to get the property group or
15877c478bd9Sstevel@tonic-gate 			 * property containing the state of the instance,
15887c478bd9Sstevel@tonic-gate 			 * we continue instead of failing, as this might just
15897c478bd9Sstevel@tonic-gate 			 * be an improperly configured instance.
15907c478bd9Sstevel@tonic-gate 			 */
15917c478bd9Sstevel@tonic-gate 			if ((inst_state = get_inst_state(inst, h)) == -1) {
15927c478bd9Sstevel@tonic-gate 				if (scf_error() == SCF_ERROR_INTERNAL) {
15937c478bd9Sstevel@tonic-gate 					continue;
15947c478bd9Sstevel@tonic-gate 				} else {
15957c478bd9Sstevel@tonic-gate 					goto out;
15967c478bd9Sstevel@tonic-gate 				}
15977c478bd9Sstevel@tonic-gate 			}
15987c478bd9Sstevel@tonic-gate 
15997c478bd9Sstevel@tonic-gate 			if ((uint_t)inst_state & state_flags) {
16007c478bd9Sstevel@tonic-gate 				if (inst_callback(h, inst, private) !=
16017c478bd9Sstevel@tonic-gate 				    SCF_SUCCESS) {
16027c478bd9Sstevel@tonic-gate 					(void) scf_set_error(
16037c478bd9Sstevel@tonic-gate 					    SCF_ERROR_CALLBACK_FAILED);
16047c478bd9Sstevel@tonic-gate 					goto out;
16057c478bd9Sstevel@tonic-gate 				}
16067c478bd9Sstevel@tonic-gate 			}
16077c478bd9Sstevel@tonic-gate 		}
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate 		if (inst_iter_ret == -1)
16107c478bd9Sstevel@tonic-gate 			goto out;
16117c478bd9Sstevel@tonic-gate 		scf_iter_reset(inst_iter);
16127c478bd9Sstevel@tonic-gate 	}
16137c478bd9Sstevel@tonic-gate 
16147c478bd9Sstevel@tonic-gate 	if (svc_iter_ret != -1)
16157c478bd9Sstevel@tonic-gate 		ret = SCF_SUCCESS;
16167c478bd9Sstevel@tonic-gate 
16177c478bd9Sstevel@tonic-gate out:
16187c478bd9Sstevel@tonic-gate 	scf_scope_destroy(scope);
16197c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
16207c478bd9Sstevel@tonic-gate 	scf_instance_destroy(inst);
16217c478bd9Sstevel@tonic-gate 	scf_iter_destroy(svc_iter);
16227c478bd9Sstevel@tonic-gate 	scf_iter_destroy(inst_iter);
16237c478bd9Sstevel@tonic-gate 	scf_handle_destroy(h);
16247c478bd9Sstevel@tonic-gate 
16257c478bd9Sstevel@tonic-gate 	return (ret);
16267c478bd9Sstevel@tonic-gate }
16277c478bd9Sstevel@tonic-gate 
16287c478bd9Sstevel@tonic-gate 
16297c478bd9Sstevel@tonic-gate scf_simple_prop_t *
16307c478bd9Sstevel@tonic-gate scf_simple_prop_get(scf_handle_t *hin, const char *instance, const char *pgname,
16317c478bd9Sstevel@tonic-gate 			const char *propname)
16327c478bd9Sstevel@tonic-gate {
16337c478bd9Sstevel@tonic-gate 	char 			*fmri_buf, *svcfmri = NULL;
16347c478bd9Sstevel@tonic-gate 	ssize_t 		fmri_sz;
16357c478bd9Sstevel@tonic-gate 	scf_property_t 		*prop = NULL;
16367c478bd9Sstevel@tonic-gate 	scf_service_t 		*svc = NULL;
16377c478bd9Sstevel@tonic-gate 	scf_simple_prop_t 	*ret;
16387c478bd9Sstevel@tonic-gate 	scf_handle_t		*h = NULL;
16397c478bd9Sstevel@tonic-gate 	boolean_t		local_h = B_TRUE;
16407c478bd9Sstevel@tonic-gate 
16417c478bd9Sstevel@tonic-gate 	/* If the user passed in a handle, use it. */
16427c478bd9Sstevel@tonic-gate 	if (hin != NULL) {
16437c478bd9Sstevel@tonic-gate 		h = hin;
16447c478bd9Sstevel@tonic-gate 		local_h = B_FALSE;
16457c478bd9Sstevel@tonic-gate 	}
16467c478bd9Sstevel@tonic-gate 
16477c478bd9Sstevel@tonic-gate 	if (local_h && ((h = handle_create()) == NULL))
16487c478bd9Sstevel@tonic-gate 		return (NULL);
16497c478bd9Sstevel@tonic-gate 
16507c478bd9Sstevel@tonic-gate 	if ((fmri_buf = assemble_fmri(h, instance, pgname, propname)) == NULL) {
16517c478bd9Sstevel@tonic-gate 		if (local_h)
16527c478bd9Sstevel@tonic-gate 			scf_handle_destroy(h);
16537c478bd9Sstevel@tonic-gate 		return (NULL);
16547c478bd9Sstevel@tonic-gate 	}
16557c478bd9Sstevel@tonic-gate 
16567c478bd9Sstevel@tonic-gate 	if ((svc = scf_service_create(h)) == NULL ||
16577c478bd9Sstevel@tonic-gate 	    (prop = scf_property_create(h)) == NULL)
16587c478bd9Sstevel@tonic-gate 		goto error1;
16597c478bd9Sstevel@tonic-gate 	if (scf_handle_decode_fmri(h, fmri_buf, NULL, NULL, NULL, NULL, prop,
16607c478bd9Sstevel@tonic-gate 	    SCF_DECODE_FMRI_REQUIRE_INSTANCE) == -1) {
16617c478bd9Sstevel@tonic-gate 		switch (scf_error()) {
16627c478bd9Sstevel@tonic-gate 		/*
16637c478bd9Sstevel@tonic-gate 		 * If the property isn't found in the instance, we grab the
16647c478bd9Sstevel@tonic-gate 		 * underlying service, create an FMRI out of it, and then
16657c478bd9Sstevel@tonic-gate 		 * query the datastore again at the service level for the
16667c478bd9Sstevel@tonic-gate 		 * property.
16677c478bd9Sstevel@tonic-gate 		 */
16687c478bd9Sstevel@tonic-gate 		case SCF_ERROR_NOT_FOUND:
16697c478bd9Sstevel@tonic-gate 			if (scf_handle_decode_fmri(h, fmri_buf, NULL, svc,
16707c478bd9Sstevel@tonic-gate 			    NULL, NULL, NULL, SCF_DECODE_FMRI_TRUNCATE) == -1)
16717c478bd9Sstevel@tonic-gate 				goto error1;
16727c478bd9Sstevel@tonic-gate 			if ((fmri_sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH)) ==
16737c478bd9Sstevel@tonic-gate 			    -1) {
16747c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
16757c478bd9Sstevel@tonic-gate 				goto error1;
16767c478bd9Sstevel@tonic-gate 			}
16777c478bd9Sstevel@tonic-gate 			if (scf_service_to_fmri(svc, fmri_buf, fmri_sz) == -1)
16787c478bd9Sstevel@tonic-gate 				goto error1;
16797c478bd9Sstevel@tonic-gate 			if ((svcfmri = assemble_fmri(h, fmri_buf, pgname,
16807c478bd9Sstevel@tonic-gate 			    propname)) == NULL)
16817c478bd9Sstevel@tonic-gate 				goto error1;
16827c478bd9Sstevel@tonic-gate 			if (scf_handle_decode_fmri(h, svcfmri, NULL, NULL,
16837c478bd9Sstevel@tonic-gate 			    NULL, NULL, prop, 0) == -1) {
16847c478bd9Sstevel@tonic-gate 				free(svcfmri);
16857c478bd9Sstevel@tonic-gate 				goto error1;
16867c478bd9Sstevel@tonic-gate 			}
16877c478bd9Sstevel@tonic-gate 			free(svcfmri);
16887c478bd9Sstevel@tonic-gate 			break;
16897c478bd9Sstevel@tonic-gate 		case SCF_ERROR_CONSTRAINT_VIOLATED:
16907c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
16917c478bd9Sstevel@tonic-gate 		default:
16927c478bd9Sstevel@tonic-gate 			goto error1;
16937c478bd9Sstevel@tonic-gate 		}
16947c478bd9Sstevel@tonic-gate 	}
16957c478bd9Sstevel@tonic-gate 	/*
16967c478bd9Sstevel@tonic-gate 	 * At this point, we've successfully pulled the property from the
16977c478bd9Sstevel@tonic-gate 	 * datastore, and simply need to copy its innards into an
16987c478bd9Sstevel@tonic-gate 	 * scf_simple_prop_t.
16997c478bd9Sstevel@tonic-gate 	 */
17007c478bd9Sstevel@tonic-gate 	if ((ret = fill_prop(prop, pgname, propname, h)) == NULL)
17017c478bd9Sstevel@tonic-gate 		goto error1;
17027c478bd9Sstevel@tonic-gate 
17037c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
17047c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
17057c478bd9Sstevel@tonic-gate 	free(fmri_buf);
17067c478bd9Sstevel@tonic-gate 	if (local_h)
17077c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
17087c478bd9Sstevel@tonic-gate 	return (ret);
17097c478bd9Sstevel@tonic-gate 
17107c478bd9Sstevel@tonic-gate 	/*
17117c478bd9Sstevel@tonic-gate 	 * Exit point for a successful call.  Below this line are exit points
17127c478bd9Sstevel@tonic-gate 	 * for failures at various stages during the function.
17137c478bd9Sstevel@tonic-gate 	 */
17147c478bd9Sstevel@tonic-gate 
17157c478bd9Sstevel@tonic-gate error1:
17167c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
17177c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
17187c478bd9Sstevel@tonic-gate error2:
17197c478bd9Sstevel@tonic-gate 	free(fmri_buf);
17207c478bd9Sstevel@tonic-gate 	if (local_h)
17217c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
17227c478bd9Sstevel@tonic-gate 	return (NULL);
17237c478bd9Sstevel@tonic-gate }
17247c478bd9Sstevel@tonic-gate 
17257c478bd9Sstevel@tonic-gate 
17267c478bd9Sstevel@tonic-gate void
17277c478bd9Sstevel@tonic-gate scf_simple_prop_free(scf_simple_prop_t *prop)
17287c478bd9Sstevel@tonic-gate {
17297c478bd9Sstevel@tonic-gate 	int i;
17307c478bd9Sstevel@tonic-gate 
17317c478bd9Sstevel@tonic-gate 	if (prop == NULL)
17327c478bd9Sstevel@tonic-gate 		return;
17337c478bd9Sstevel@tonic-gate 
17347c478bd9Sstevel@tonic-gate 	free(prop->pr_propname);
17357c478bd9Sstevel@tonic-gate 	free(prop->pr_pgname);
17367c478bd9Sstevel@tonic-gate 	switch (prop->pr_type) {
17377c478bd9Sstevel@tonic-gate 	case SCF_TYPE_OPAQUE: {
17387c478bd9Sstevel@tonic-gate 		for (i = 0; i < prop->pr_numvalues; i++) {
17397c478bd9Sstevel@tonic-gate 			free(prop->pr_vallist[i].pv_opaque.o_value);
17407c478bd9Sstevel@tonic-gate 		}
17417c478bd9Sstevel@tonic-gate 		break;
17427c478bd9Sstevel@tonic-gate 	}
17437c478bd9Sstevel@tonic-gate 	case SCF_TYPE_ASTRING:
17447c478bd9Sstevel@tonic-gate 	case SCF_TYPE_USTRING:
17457c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOST:
17467c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOSTNAME:
17477c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V4:
17487c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V6:
17497c478bd9Sstevel@tonic-gate 	case SCF_TYPE_URI:
17507c478bd9Sstevel@tonic-gate 	case SCF_TYPE_FMRI: {
17517c478bd9Sstevel@tonic-gate 		for (i = 0; i < prop->pr_numvalues; i++) {
17527c478bd9Sstevel@tonic-gate 			free(prop->pr_vallist[i].pv_str);
17537c478bd9Sstevel@tonic-gate 		}
17547c478bd9Sstevel@tonic-gate 		break;
17557c478bd9Sstevel@tonic-gate 	}
17567c478bd9Sstevel@tonic-gate 	default:
17577c478bd9Sstevel@tonic-gate 		break;
17587c478bd9Sstevel@tonic-gate 	}
17597c478bd9Sstevel@tonic-gate 	free(prop->pr_vallist);
17607c478bd9Sstevel@tonic-gate 	free(prop);
17617c478bd9Sstevel@tonic-gate }
17627c478bd9Sstevel@tonic-gate 
17637c478bd9Sstevel@tonic-gate 
17647c478bd9Sstevel@tonic-gate scf_simple_app_props_t *
17657c478bd9Sstevel@tonic-gate scf_simple_app_props_get(scf_handle_t *hin, const char *inst_fmri)
17667c478bd9Sstevel@tonic-gate {
17677c478bd9Sstevel@tonic-gate 	scf_instance_t 		*inst = NULL;
17687c478bd9Sstevel@tonic-gate 	scf_service_t 		*svc = NULL;
17697c478bd9Sstevel@tonic-gate 	scf_propertygroup_t 	*pg = NULL;
17707c478bd9Sstevel@tonic-gate 	scf_property_t 		*prop = NULL;
17717c478bd9Sstevel@tonic-gate 	scf_simple_app_props_t	*ret = NULL;
17727c478bd9Sstevel@tonic-gate 	scf_iter_t		*pgiter = NULL, *propiter = NULL;
17737c478bd9Sstevel@tonic-gate 	struct scf_simple_pg	*thispg = NULL, *nextpg;
17747c478bd9Sstevel@tonic-gate 	scf_simple_prop_t	*thisprop, *nextprop;
17757c478bd9Sstevel@tonic-gate 	scf_handle_t		*h = NULL;
17767c478bd9Sstevel@tonic-gate 	int			pgiter_ret, propiter_ret;
17777c478bd9Sstevel@tonic-gate 	ssize_t			namelen;
17787c478bd9Sstevel@tonic-gate 	char 			*propname = NULL, *pgname = NULL, *sys_fmri;
17797c478bd9Sstevel@tonic-gate 	uint8_t			found;
17807c478bd9Sstevel@tonic-gate 	boolean_t		local_h = B_TRUE;
17817c478bd9Sstevel@tonic-gate 
17827c478bd9Sstevel@tonic-gate 	/* If the user passed in a handle, use it. */
17837c478bd9Sstevel@tonic-gate 	if (hin != NULL) {
17847c478bd9Sstevel@tonic-gate 		h = hin;
17857c478bd9Sstevel@tonic-gate 		local_h = B_FALSE;
17867c478bd9Sstevel@tonic-gate 	}
17877c478bd9Sstevel@tonic-gate 
17887c478bd9Sstevel@tonic-gate 	if (local_h && ((h = handle_create()) == NULL))
17897c478bd9Sstevel@tonic-gate 		return (NULL);
17907c478bd9Sstevel@tonic-gate 
17917c478bd9Sstevel@tonic-gate 	if (inst_fmri == NULL) {
17927c478bd9Sstevel@tonic-gate 		if ((namelen = scf_myname(h, NULL, 0)) == -1) {
17937c478bd9Sstevel@tonic-gate 			if (local_h)
17947c478bd9Sstevel@tonic-gate 				scf_handle_destroy(h);
17957c478bd9Sstevel@tonic-gate 			return (NULL);
17967c478bd9Sstevel@tonic-gate 		}
17977c478bd9Sstevel@tonic-gate 		if ((sys_fmri = malloc(namelen + 1)) == NULL) {
17987c478bd9Sstevel@tonic-gate 			if (local_h)
17997c478bd9Sstevel@tonic-gate 				scf_handle_destroy(h);
18007c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
18017c478bd9Sstevel@tonic-gate 			return (NULL);
18027c478bd9Sstevel@tonic-gate 		}
18037c478bd9Sstevel@tonic-gate 		if (scf_myname(h, sys_fmri, namelen + 1) == -1) {
18047c478bd9Sstevel@tonic-gate 			if (local_h)
18057c478bd9Sstevel@tonic-gate 				scf_handle_destroy(h);
18067c478bd9Sstevel@tonic-gate 			free(sys_fmri);
18077c478bd9Sstevel@tonic-gate 			return (NULL);
18087c478bd9Sstevel@tonic-gate 		}
18097c478bd9Sstevel@tonic-gate 	} else {
1810*3eae19d9Swesolows 		if ((sys_fmri = strdup(inst_fmri)) == NULL) {
1811*3eae19d9Swesolows 			if (local_h)
1812*3eae19d9Swesolows 				scf_handle_destroy(h);
1813*3eae19d9Swesolows 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1814*3eae19d9Swesolows 			return (NULL);
1815*3eae19d9Swesolows 		}
18167c478bd9Sstevel@tonic-gate 	}
18177c478bd9Sstevel@tonic-gate 
18187c478bd9Sstevel@tonic-gate 	if ((namelen = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH)) == -1) {
18197c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_INTERNAL);
18207c478bd9Sstevel@tonic-gate 		return (NULL);
18217c478bd9Sstevel@tonic-gate 	}
18227c478bd9Sstevel@tonic-gate 
18237c478bd9Sstevel@tonic-gate 	if ((inst = scf_instance_create(h)) == NULL ||
18247c478bd9Sstevel@tonic-gate 	    (svc = scf_service_create(h)) == NULL ||
18257c478bd9Sstevel@tonic-gate 	    (pgiter = scf_iter_create(h)) == NULL ||
18267c478bd9Sstevel@tonic-gate 	    (propiter = scf_iter_create(h)) == NULL ||
18277c478bd9Sstevel@tonic-gate 	    (pg = scf_pg_create(h)) == NULL ||
18287c478bd9Sstevel@tonic-gate 	    (prop = scf_property_create(h)) == NULL)
18297c478bd9Sstevel@tonic-gate 		goto error2;
18307c478bd9Sstevel@tonic-gate 
18317c478bd9Sstevel@tonic-gate 	if (scf_handle_decode_fmri(h, sys_fmri, NULL, svc, inst, NULL, NULL,
18327c478bd9Sstevel@tonic-gate 	    SCF_DECODE_FMRI_REQUIRE_INSTANCE) == -1) {
18337c478bd9Sstevel@tonic-gate 		if (scf_error() == SCF_ERROR_CONSTRAINT_VIOLATED)
18347c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
18357c478bd9Sstevel@tonic-gate 		goto error2;
18367c478bd9Sstevel@tonic-gate 	}
18377c478bd9Sstevel@tonic-gate 
18387c478bd9Sstevel@tonic-gate 	if ((ret = malloc(sizeof (*ret))) == NULL ||
18397c478bd9Sstevel@tonic-gate 	    (thispg = malloc(sizeof (*thispg))) == NULL ||
18407c478bd9Sstevel@tonic-gate 	    (propname = malloc(namelen)) == NULL ||
18417c478bd9Sstevel@tonic-gate 	    (pgname = malloc(namelen)) == NULL) {
18427c478bd9Sstevel@tonic-gate 		free(thispg);
18437c478bd9Sstevel@tonic-gate 		free(ret);
18447c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
18457c478bd9Sstevel@tonic-gate 		goto error2;
18467c478bd9Sstevel@tonic-gate 	}
18477c478bd9Sstevel@tonic-gate 
18487c478bd9Sstevel@tonic-gate 	ret->ap_fmri = sys_fmri;
18497c478bd9Sstevel@tonic-gate 	thispg->pg_name = NULL;
18507c478bd9Sstevel@tonic-gate 	thispg->pg_proplist = NULL;
18517c478bd9Sstevel@tonic-gate 	thispg->pg_next = NULL;
18527c478bd9Sstevel@tonic-gate 	ret->ap_pglist = thispg;
18537c478bd9Sstevel@tonic-gate 
18547c478bd9Sstevel@tonic-gate 	if (scf_iter_service_pgs_typed(pgiter, svc, SCF_GROUP_APPLICATION) !=
18557c478bd9Sstevel@tonic-gate 	    0) {
18567c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
18577c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
18587c478bd9Sstevel@tonic-gate 		goto error1;
18597c478bd9Sstevel@tonic-gate 	}
18607c478bd9Sstevel@tonic-gate 
18617c478bd9Sstevel@tonic-gate 	while ((pgiter_ret = scf_iter_next_pg(pgiter, pg)) == 1) {
18627c478bd9Sstevel@tonic-gate 		if (thispg->pg_name != NULL) {
18637c478bd9Sstevel@tonic-gate 			if ((nextpg = malloc(sizeof (*nextpg))) == NULL) {
18647c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
18657c478bd9Sstevel@tonic-gate 				goto error1;
18667c478bd9Sstevel@tonic-gate 			}
1867*3eae19d9Swesolows 			nextpg->pg_name = NULL;
1868*3eae19d9Swesolows 			nextpg->pg_next = NULL;
1869*3eae19d9Swesolows 			nextpg->pg_proplist = NULL;
18707c478bd9Sstevel@tonic-gate 			thispg->pg_next = nextpg;
18717c478bd9Sstevel@tonic-gate 			thispg = nextpg;
18727c478bd9Sstevel@tonic-gate 		} else {
18737c478bd9Sstevel@tonic-gate 			/* This is the first iteration */
18747c478bd9Sstevel@tonic-gate 			nextpg = thispg;
18757c478bd9Sstevel@tonic-gate 		}
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate 		if ((nextpg->pg_name = malloc(namelen)) == NULL) {
18787c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
18797c478bd9Sstevel@tonic-gate 			goto error1;
18807c478bd9Sstevel@tonic-gate 		}
18817c478bd9Sstevel@tonic-gate 
18827c478bd9Sstevel@tonic-gate 		if (scf_pg_get_name(pg, nextpg->pg_name, namelen) < 0) {
18837c478bd9Sstevel@tonic-gate 			if (scf_error() == SCF_ERROR_NOT_SET)
18847c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
18857c478bd9Sstevel@tonic-gate 			goto error1;
18867c478bd9Sstevel@tonic-gate 		}
18877c478bd9Sstevel@tonic-gate 
18887c478bd9Sstevel@tonic-gate 		thisprop = NULL;
18897c478bd9Sstevel@tonic-gate 
18907c478bd9Sstevel@tonic-gate 		scf_iter_reset(propiter);
18917c478bd9Sstevel@tonic-gate 
18927c478bd9Sstevel@tonic-gate 		if (scf_iter_pg_properties(propiter, pg) != 0) {
18937c478bd9Sstevel@tonic-gate 			if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
18947c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
18957c478bd9Sstevel@tonic-gate 			goto error1;
18967c478bd9Sstevel@tonic-gate 		}
18977c478bd9Sstevel@tonic-gate 
18987c478bd9Sstevel@tonic-gate 		while ((propiter_ret = scf_iter_next_property(propiter, prop))
18997c478bd9Sstevel@tonic-gate 		    == 1) {
19007c478bd9Sstevel@tonic-gate 			if (scf_property_get_name(prop, propname, namelen) <
19017c478bd9Sstevel@tonic-gate 			    0) {
19027c478bd9Sstevel@tonic-gate 				if (scf_error() == SCF_ERROR_NOT_SET)
19037c478bd9Sstevel@tonic-gate 					(void) scf_set_error(
19047c478bd9Sstevel@tonic-gate 					    SCF_ERROR_INTERNAL);
19057c478bd9Sstevel@tonic-gate 				goto error1;
19067c478bd9Sstevel@tonic-gate 			}
19077c478bd9Sstevel@tonic-gate 			if (thisprop != NULL) {
19087c478bd9Sstevel@tonic-gate 				if ((nextprop = fill_prop(prop,
19097c478bd9Sstevel@tonic-gate 				    nextpg->pg_name, propname, h)) == NULL)
19107c478bd9Sstevel@tonic-gate 					goto error1;
19117c478bd9Sstevel@tonic-gate 				thisprop->pr_next = nextprop;
19127c478bd9Sstevel@tonic-gate 				thisprop = nextprop;
19137c478bd9Sstevel@tonic-gate 			} else {
19147c478bd9Sstevel@tonic-gate 				/* This is the first iteration */
19157c478bd9Sstevel@tonic-gate 				if ((thisprop = fill_prop(prop,
19167c478bd9Sstevel@tonic-gate 				    nextpg->pg_name, propname, h)) == NULL)
19177c478bd9Sstevel@tonic-gate 					goto error1;
19187c478bd9Sstevel@tonic-gate 				nextpg->pg_proplist = thisprop;
19197c478bd9Sstevel@tonic-gate 				nextprop = thisprop;
19207c478bd9Sstevel@tonic-gate 			}
19217c478bd9Sstevel@tonic-gate 			nextprop->pr_pg = nextpg;
19227c478bd9Sstevel@tonic-gate 			nextprop->pr_next = NULL;
19237c478bd9Sstevel@tonic-gate 		}
19247c478bd9Sstevel@tonic-gate 
19257c478bd9Sstevel@tonic-gate 		if (propiter_ret == -1) {
19267c478bd9Sstevel@tonic-gate 			if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
19277c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
19287c478bd9Sstevel@tonic-gate 			goto error1;
19297c478bd9Sstevel@tonic-gate 		}
19307c478bd9Sstevel@tonic-gate 	}
19317c478bd9Sstevel@tonic-gate 
19327c478bd9Sstevel@tonic-gate 	if (pgiter_ret == -1) {
19337c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
19347c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
19357c478bd9Sstevel@tonic-gate 		goto error1;
19367c478bd9Sstevel@tonic-gate 	}
19377c478bd9Sstevel@tonic-gate 
19387c478bd9Sstevel@tonic-gate 	/*
19397c478bd9Sstevel@tonic-gate 	 * At this point, we've filled the scf_simple_app_props_t with all the
19407c478bd9Sstevel@tonic-gate 	 * properties at the service level.  Now we iterate over all the
19417c478bd9Sstevel@tonic-gate 	 * properties at the instance level, overwriting any duplicate
19427c478bd9Sstevel@tonic-gate 	 * properties, in order to provide service/instance composition.
19437c478bd9Sstevel@tonic-gate 	 */
19447c478bd9Sstevel@tonic-gate 
19457c478bd9Sstevel@tonic-gate 	scf_iter_reset(pgiter);
19467c478bd9Sstevel@tonic-gate 	scf_iter_reset(propiter);
19477c478bd9Sstevel@tonic-gate 
19487c478bd9Sstevel@tonic-gate 	if (scf_iter_instance_pgs_typed(pgiter, inst, SCF_GROUP_APPLICATION)
19497c478bd9Sstevel@tonic-gate 	    != 0) {
19507c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
19517c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
19527c478bd9Sstevel@tonic-gate 		goto error1;
19537c478bd9Sstevel@tonic-gate 	}
19547c478bd9Sstevel@tonic-gate 
19557c478bd9Sstevel@tonic-gate 	while ((pgiter_ret = scf_iter_next_pg(pgiter, pg)) == 1) {
19567c478bd9Sstevel@tonic-gate 
19577c478bd9Sstevel@tonic-gate 		thispg = ret->ap_pglist;
19587c478bd9Sstevel@tonic-gate 		found = 0;
19597c478bd9Sstevel@tonic-gate 
19607c478bd9Sstevel@tonic-gate 		/*
19617c478bd9Sstevel@tonic-gate 		 * Find either the end of the list, so we can append the
19627c478bd9Sstevel@tonic-gate 		 * property group, or an existing property group that matches
19637c478bd9Sstevel@tonic-gate 		 * it, so we can insert/overwrite its properties.
19647c478bd9Sstevel@tonic-gate 		 */
19657c478bd9Sstevel@tonic-gate 
19667c478bd9Sstevel@tonic-gate 		if (scf_pg_get_name(pg, pgname, namelen) < 0) {
19677c478bd9Sstevel@tonic-gate 			if (scf_error() == SCF_ERROR_NOT_SET)
19687c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
19697c478bd9Sstevel@tonic-gate 			goto error1;
19707c478bd9Sstevel@tonic-gate 		}
19717c478bd9Sstevel@tonic-gate 
19727c478bd9Sstevel@tonic-gate 		while ((thispg != NULL) && (thispg->pg_name != NULL)) {
19737c478bd9Sstevel@tonic-gate 			if (strcmp(thispg->pg_name, pgname) == 0) {
19747c478bd9Sstevel@tonic-gate 				found = 1;
19757c478bd9Sstevel@tonic-gate 				break;
19767c478bd9Sstevel@tonic-gate 			}
19777c478bd9Sstevel@tonic-gate 			if (thispg->pg_next == NULL)
19787c478bd9Sstevel@tonic-gate 				break;
19797c478bd9Sstevel@tonic-gate 
19807c478bd9Sstevel@tonic-gate 			thispg = thispg->pg_next;
19817c478bd9Sstevel@tonic-gate 		}
19827c478bd9Sstevel@tonic-gate 
19837c478bd9Sstevel@tonic-gate 		scf_iter_reset(propiter);
19847c478bd9Sstevel@tonic-gate 
19857c478bd9Sstevel@tonic-gate 		if (scf_iter_pg_properties(propiter, pg) != 0) {
19867c478bd9Sstevel@tonic-gate 			if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
19877c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_INTERNAL);
19887c478bd9Sstevel@tonic-gate 			goto error1;
19897c478bd9Sstevel@tonic-gate 		}
19907c478bd9Sstevel@tonic-gate 
19917c478bd9Sstevel@tonic-gate 		if (found) {
19927c478bd9Sstevel@tonic-gate 			/*
19937c478bd9Sstevel@tonic-gate 			 * insert_app_props inserts or overwrites the
19947c478bd9Sstevel@tonic-gate 			 * properties in thispg.
19957c478bd9Sstevel@tonic-gate 			 */
19967c478bd9Sstevel@tonic-gate 
19977c478bd9Sstevel@tonic-gate 			if (insert_app_props(propiter, pgname, propname,
19987c478bd9Sstevel@tonic-gate 			    thispg, prop, namelen, h) == -1)
19997c478bd9Sstevel@tonic-gate 				goto error1;
20007c478bd9Sstevel@tonic-gate 
20017c478bd9Sstevel@tonic-gate 		} else {
20027c478bd9Sstevel@tonic-gate 			/*
20037c478bd9Sstevel@tonic-gate 			 * If the property group wasn't found, we're adding
20047c478bd9Sstevel@tonic-gate 			 * a newly allocated property group to the end of the
20057c478bd9Sstevel@tonic-gate 			 * list.
20067c478bd9Sstevel@tonic-gate 			 */
20077c478bd9Sstevel@tonic-gate 
20087c478bd9Sstevel@tonic-gate 			if ((nextpg = malloc(sizeof (*nextpg))) == NULL) {
20097c478bd9Sstevel@tonic-gate 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
20107c478bd9Sstevel@tonic-gate 				goto error1;
20117c478bd9Sstevel@tonic-gate 			}
20127c478bd9Sstevel@tonic-gate 			nextpg->pg_next = NULL;
20137c478bd9Sstevel@tonic-gate 			nextpg->pg_proplist = NULL;
20147c478bd9Sstevel@tonic-gate 			thisprop = NULL;
20157c478bd9Sstevel@tonic-gate 
20167c478bd9Sstevel@tonic-gate 			if ((nextpg->pg_name = strdup(pgname)) == NULL) {
2017*3eae19d9Swesolows 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
20187c478bd9Sstevel@tonic-gate 				free(nextpg);
20197c478bd9Sstevel@tonic-gate 				goto error1;
20207c478bd9Sstevel@tonic-gate 			}
20217c478bd9Sstevel@tonic-gate 
20227c478bd9Sstevel@tonic-gate 			if (thispg->pg_name == NULL) {
20237c478bd9Sstevel@tonic-gate 				free(thispg);
20247c478bd9Sstevel@tonic-gate 				ret->ap_pglist = nextpg;
20257c478bd9Sstevel@tonic-gate 			} else {
20267c478bd9Sstevel@tonic-gate 				thispg->pg_next = nextpg;
20277c478bd9Sstevel@tonic-gate 			}
20287c478bd9Sstevel@tonic-gate 
20297c478bd9Sstevel@tonic-gate 			while ((propiter_ret =
20307c478bd9Sstevel@tonic-gate 			    scf_iter_next_property(propiter, prop)) == 1) {
20317c478bd9Sstevel@tonic-gate 				if (scf_property_get_name(prop, propname,
20327c478bd9Sstevel@tonic-gate 				    namelen) < 0) {
20337c478bd9Sstevel@tonic-gate 					if (scf_error() == SCF_ERROR_NOT_SET)
20347c478bd9Sstevel@tonic-gate 						(void) scf_set_error(
20357c478bd9Sstevel@tonic-gate 						    SCF_ERROR_INTERNAL);
20367c478bd9Sstevel@tonic-gate 					goto error1;
20377c478bd9Sstevel@tonic-gate 				}
20387c478bd9Sstevel@tonic-gate 				if (thisprop != NULL) {
20397c478bd9Sstevel@tonic-gate 					if ((nextprop = fill_prop(prop,
20407c478bd9Sstevel@tonic-gate 					    pgname, propname, h)) ==
20417c478bd9Sstevel@tonic-gate 					    NULL)
20427c478bd9Sstevel@tonic-gate 						goto error1;
20437c478bd9Sstevel@tonic-gate 					thisprop->pr_next = nextprop;
20447c478bd9Sstevel@tonic-gate 					thisprop = nextprop;
20457c478bd9Sstevel@tonic-gate 				} else {
20467c478bd9Sstevel@tonic-gate 					/* This is the first iteration */
20477c478bd9Sstevel@tonic-gate 					if ((thisprop = fill_prop(prop,
20487c478bd9Sstevel@tonic-gate 					    pgname, propname, h)) ==
20497c478bd9Sstevel@tonic-gate 					    NULL)
20507c478bd9Sstevel@tonic-gate 						goto error1;
20517c478bd9Sstevel@tonic-gate 					nextpg->pg_proplist = thisprop;
20527c478bd9Sstevel@tonic-gate 					nextprop = thisprop;
20537c478bd9Sstevel@tonic-gate 				}
20547c478bd9Sstevel@tonic-gate 				nextprop->pr_pg = nextpg;
20557c478bd9Sstevel@tonic-gate 				nextprop->pr_next = NULL;
20567c478bd9Sstevel@tonic-gate 			}
20577c478bd9Sstevel@tonic-gate 
20587c478bd9Sstevel@tonic-gate 			if (propiter_ret == -1) {
20597c478bd9Sstevel@tonic-gate 				if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
20607c478bd9Sstevel@tonic-gate 					(void) scf_set_error(
20617c478bd9Sstevel@tonic-gate 					    SCF_ERROR_INTERNAL);
20627c478bd9Sstevel@tonic-gate 				goto error1;
20637c478bd9Sstevel@tonic-gate 			}
20647c478bd9Sstevel@tonic-gate 		}
20657c478bd9Sstevel@tonic-gate 
20667c478bd9Sstevel@tonic-gate 	}
20677c478bd9Sstevel@tonic-gate 
20687c478bd9Sstevel@tonic-gate 	if (pgiter_ret == -1) {
20697c478bd9Sstevel@tonic-gate 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
20707c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_INTERNAL);
20717c478bd9Sstevel@tonic-gate 		goto error1;
20727c478bd9Sstevel@tonic-gate 	}
20737c478bd9Sstevel@tonic-gate 
20747c478bd9Sstevel@tonic-gate 	scf_iter_destroy(pgiter);
20757c478bd9Sstevel@tonic-gate 	scf_iter_destroy(propiter);
20767c478bd9Sstevel@tonic-gate 	scf_pg_destroy(pg);
20777c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
20787c478bd9Sstevel@tonic-gate 	scf_instance_destroy(inst);
20797c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
20807c478bd9Sstevel@tonic-gate 	free(propname);
20817c478bd9Sstevel@tonic-gate 	free(pgname);
20827c478bd9Sstevel@tonic-gate 	if (local_h)
20837c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
20847c478bd9Sstevel@tonic-gate 
20857c478bd9Sstevel@tonic-gate 	if (ret->ap_pglist->pg_name == NULL)
20867c478bd9Sstevel@tonic-gate 		return (NULL);
20877c478bd9Sstevel@tonic-gate 
20887c478bd9Sstevel@tonic-gate 	return (ret);
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 	/*
20917c478bd9Sstevel@tonic-gate 	 * Exit point for a successful call.  Below this line are exit points
20927c478bd9Sstevel@tonic-gate 	 * for failures at various stages during the function.
20937c478bd9Sstevel@tonic-gate 	 */
20947c478bd9Sstevel@tonic-gate 
20957c478bd9Sstevel@tonic-gate error1:
20967c478bd9Sstevel@tonic-gate 	scf_simple_app_props_free(ret);
20977c478bd9Sstevel@tonic-gate 
20987c478bd9Sstevel@tonic-gate error2:
20997c478bd9Sstevel@tonic-gate 	scf_iter_destroy(pgiter);
21007c478bd9Sstevel@tonic-gate 	scf_iter_destroy(propiter);
21017c478bd9Sstevel@tonic-gate 	scf_pg_destroy(pg);
21027c478bd9Sstevel@tonic-gate 	scf_property_destroy(prop);
21037c478bd9Sstevel@tonic-gate 	scf_instance_destroy(inst);
21047c478bd9Sstevel@tonic-gate 	scf_service_destroy(svc);
21057c478bd9Sstevel@tonic-gate 	free(propname);
21067c478bd9Sstevel@tonic-gate 	free(pgname);
21077c478bd9Sstevel@tonic-gate 	if (local_h)
21087c478bd9Sstevel@tonic-gate 		scf_handle_destroy(h);
21097c478bd9Sstevel@tonic-gate 	return (NULL);
21107c478bd9Sstevel@tonic-gate }
21117c478bd9Sstevel@tonic-gate 
21127c478bd9Sstevel@tonic-gate 
21137c478bd9Sstevel@tonic-gate void
21147c478bd9Sstevel@tonic-gate scf_simple_app_props_free(scf_simple_app_props_t *propblock)
21157c478bd9Sstevel@tonic-gate {
21167c478bd9Sstevel@tonic-gate 	struct scf_simple_pg 	*pgthis, *pgnext;
21177c478bd9Sstevel@tonic-gate 	scf_simple_prop_t 	*propthis, *propnext;
21187c478bd9Sstevel@tonic-gate 
21197c478bd9Sstevel@tonic-gate 	if ((propblock == NULL) || (propblock->ap_pglist == NULL))
21207c478bd9Sstevel@tonic-gate 		return;
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 	for (pgthis = propblock->ap_pglist; pgthis != NULL; pgthis = pgnext) {
21237c478bd9Sstevel@tonic-gate 		pgnext = pgthis->pg_next;
21247c478bd9Sstevel@tonic-gate 
21257c478bd9Sstevel@tonic-gate 		propthis = pgthis->pg_proplist;
21267c478bd9Sstevel@tonic-gate 
21277c478bd9Sstevel@tonic-gate 		while (propthis != NULL) {
21287c478bd9Sstevel@tonic-gate 			propnext = propthis->pr_next;
21297c478bd9Sstevel@tonic-gate 			scf_simple_prop_free(propthis);
21307c478bd9Sstevel@tonic-gate 			propthis = propnext;
21317c478bd9Sstevel@tonic-gate 		}
21327c478bd9Sstevel@tonic-gate 
21337c478bd9Sstevel@tonic-gate 		free(pgthis->pg_name);
21347c478bd9Sstevel@tonic-gate 		free(pgthis);
21357c478bd9Sstevel@tonic-gate 	}
21367c478bd9Sstevel@tonic-gate 
21377c478bd9Sstevel@tonic-gate 	free(propblock->ap_fmri);
21387c478bd9Sstevel@tonic-gate 	free(propblock);
21397c478bd9Sstevel@tonic-gate }
21407c478bd9Sstevel@tonic-gate 
21417c478bd9Sstevel@tonic-gate const scf_simple_prop_t *
21427c478bd9Sstevel@tonic-gate scf_simple_app_props_next(const scf_simple_app_props_t *propblock,
21437c478bd9Sstevel@tonic-gate     scf_simple_prop_t *last)
21447c478bd9Sstevel@tonic-gate {
21457c478bd9Sstevel@tonic-gate 	struct scf_simple_pg 	*this;
21467c478bd9Sstevel@tonic-gate 
21477c478bd9Sstevel@tonic-gate 	if (propblock == NULL) {
21487c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_SET);
21497c478bd9Sstevel@tonic-gate 		return (NULL);
21507c478bd9Sstevel@tonic-gate 	}
21517c478bd9Sstevel@tonic-gate 
21527c478bd9Sstevel@tonic-gate 	this = propblock->ap_pglist;
21537c478bd9Sstevel@tonic-gate 
21547c478bd9Sstevel@tonic-gate 	/*
21557c478bd9Sstevel@tonic-gate 	 * We're looking for the first property in this block if last is
21567c478bd9Sstevel@tonic-gate 	 * NULL
21577c478bd9Sstevel@tonic-gate 	 */
21587c478bd9Sstevel@tonic-gate 
21597c478bd9Sstevel@tonic-gate 	if (last == NULL) {
21607c478bd9Sstevel@tonic-gate 		/* An empty pglist is legal, it just means no properties */
21617c478bd9Sstevel@tonic-gate 		if (this == NULL) {
21627c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_NONE);
21637c478bd9Sstevel@tonic-gate 			return (NULL);
21647c478bd9Sstevel@tonic-gate 		}
21657c478bd9Sstevel@tonic-gate 		/*
21667c478bd9Sstevel@tonic-gate 		 * Walk until we find a pg with a property in it, or we run
21677c478bd9Sstevel@tonic-gate 		 * out of property groups.
21687c478bd9Sstevel@tonic-gate 		 */
21697c478bd9Sstevel@tonic-gate 		while ((this->pg_proplist == NULL) && (this->pg_next != NULL))
21707c478bd9Sstevel@tonic-gate 			this = this->pg_next;
21717c478bd9Sstevel@tonic-gate 
21727c478bd9Sstevel@tonic-gate 		if (this->pg_proplist == NULL) {
21737c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_NONE);
21747c478bd9Sstevel@tonic-gate 			return (NULL);
21757c478bd9Sstevel@tonic-gate 		}
21767c478bd9Sstevel@tonic-gate 
21777c478bd9Sstevel@tonic-gate 		return (this->pg_proplist);
21787c478bd9Sstevel@tonic-gate 
21797c478bd9Sstevel@tonic-gate 	}
21807c478bd9Sstevel@tonic-gate 	/*
21817c478bd9Sstevel@tonic-gate 	 * If last isn't NULL, then return the next prop in the property group,
21827c478bd9Sstevel@tonic-gate 	 * or walk the property groups until we find another property, or
21837c478bd9Sstevel@tonic-gate 	 * run out of property groups.
21847c478bd9Sstevel@tonic-gate 	 */
21857c478bd9Sstevel@tonic-gate 	if (last->pr_next != NULL)
21867c478bd9Sstevel@tonic-gate 		return (last->pr_next);
21877c478bd9Sstevel@tonic-gate 
21887c478bd9Sstevel@tonic-gate 	if (last->pr_pg->pg_next == NULL) {
21897c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NONE);
21907c478bd9Sstevel@tonic-gate 		return (NULL);
21917c478bd9Sstevel@tonic-gate 	}
21927c478bd9Sstevel@tonic-gate 
21937c478bd9Sstevel@tonic-gate 	this = last->pr_pg->pg_next;
21947c478bd9Sstevel@tonic-gate 
21957c478bd9Sstevel@tonic-gate 	while ((this->pg_proplist == NULL) && (this->pg_next != NULL))
21967c478bd9Sstevel@tonic-gate 		this = this->pg_next;
21977c478bd9Sstevel@tonic-gate 
21987c478bd9Sstevel@tonic-gate 	if (this->pg_proplist == NULL) {
21997c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NONE);
22007c478bd9Sstevel@tonic-gate 		return (NULL);
22017c478bd9Sstevel@tonic-gate 	}
22027c478bd9Sstevel@tonic-gate 
22037c478bd9Sstevel@tonic-gate 	return (this->pg_proplist);
22047c478bd9Sstevel@tonic-gate }
22057c478bd9Sstevel@tonic-gate 
22067c478bd9Sstevel@tonic-gate const scf_simple_prop_t *
22077c478bd9Sstevel@tonic-gate scf_simple_app_props_search(const scf_simple_app_props_t *propblock,
22087c478bd9Sstevel@tonic-gate     const char *pgname, const char *propname)
22097c478bd9Sstevel@tonic-gate {
22107c478bd9Sstevel@tonic-gate 	struct scf_simple_pg 	*pg;
22117c478bd9Sstevel@tonic-gate 	scf_simple_prop_t 	*prop;
22127c478bd9Sstevel@tonic-gate 
22137c478bd9Sstevel@tonic-gate 	if ((propblock == NULL) || (propname == NULL)) {
22147c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_SET);
22157c478bd9Sstevel@tonic-gate 		return (NULL);
22167c478bd9Sstevel@tonic-gate 	}
22177c478bd9Sstevel@tonic-gate 
22187c478bd9Sstevel@tonic-gate 	pg = propblock->ap_pglist;
22197c478bd9Sstevel@tonic-gate 
22207c478bd9Sstevel@tonic-gate 	/*
22217c478bd9Sstevel@tonic-gate 	 * If pgname is NULL, we're searching the default application
22227c478bd9Sstevel@tonic-gate 	 * property group, otherwise we look for the specified group.
22237c478bd9Sstevel@tonic-gate 	 */
22247c478bd9Sstevel@tonic-gate 	if (pgname == NULL) {
22257c478bd9Sstevel@tonic-gate 		while ((pg != NULL) &&
22267c478bd9Sstevel@tonic-gate 		    (strcmp(SCF_PG_APP_DEFAULT, pg->pg_name) != 0))
22277c478bd9Sstevel@tonic-gate 			pg = pg->pg_next;
22287c478bd9Sstevel@tonic-gate 	} else {
22297c478bd9Sstevel@tonic-gate 		while ((pg != NULL) && (strcmp(pgname, pg->pg_name) != 0))
22307c478bd9Sstevel@tonic-gate 			pg = pg->pg_next;
22317c478bd9Sstevel@tonic-gate 	}
22327c478bd9Sstevel@tonic-gate 
22337c478bd9Sstevel@tonic-gate 	if (pg == NULL) {
22347c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_FOUND);
22357c478bd9Sstevel@tonic-gate 		return (NULL);
22367c478bd9Sstevel@tonic-gate 	}
22377c478bd9Sstevel@tonic-gate 
22387c478bd9Sstevel@tonic-gate 	prop = pg->pg_proplist;
22397c478bd9Sstevel@tonic-gate 
22407c478bd9Sstevel@tonic-gate 	while ((prop != NULL) && (strcmp(propname, prop->pr_propname) != 0))
22417c478bd9Sstevel@tonic-gate 		prop = prop->pr_next;
22427c478bd9Sstevel@tonic-gate 
22437c478bd9Sstevel@tonic-gate 	if (prop == NULL) {
22447c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_FOUND);
22457c478bd9Sstevel@tonic-gate 		return (NULL);
22467c478bd9Sstevel@tonic-gate 	}
22477c478bd9Sstevel@tonic-gate 
22487c478bd9Sstevel@tonic-gate 	return (prop);
22497c478bd9Sstevel@tonic-gate }
22507c478bd9Sstevel@tonic-gate 
22517c478bd9Sstevel@tonic-gate void
22527c478bd9Sstevel@tonic-gate scf_simple_prop_next_reset(scf_simple_prop_t *prop)
22537c478bd9Sstevel@tonic-gate {
22547c478bd9Sstevel@tonic-gate 	if (prop == NULL)
22557c478bd9Sstevel@tonic-gate 		return;
22567c478bd9Sstevel@tonic-gate 	prop->pr_iter = 0;
22577c478bd9Sstevel@tonic-gate }
22587c478bd9Sstevel@tonic-gate 
22597c478bd9Sstevel@tonic-gate ssize_t
22607c478bd9Sstevel@tonic-gate scf_simple_prop_numvalues(const scf_simple_prop_t *prop)
22617c478bd9Sstevel@tonic-gate {
22627c478bd9Sstevel@tonic-gate 	if (prop == NULL)
22637c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
22647c478bd9Sstevel@tonic-gate 
22657c478bd9Sstevel@tonic-gate 	return (prop->pr_numvalues);
22667c478bd9Sstevel@tonic-gate }
22677c478bd9Sstevel@tonic-gate 
22687c478bd9Sstevel@tonic-gate 
22697c478bd9Sstevel@tonic-gate scf_type_t
22707c478bd9Sstevel@tonic-gate scf_simple_prop_type(const scf_simple_prop_t *prop)
22717c478bd9Sstevel@tonic-gate {
22727c478bd9Sstevel@tonic-gate 	if (prop == NULL)
22737c478bd9Sstevel@tonic-gate 		return (scf_set_error(SCF_ERROR_NOT_SET));
22747c478bd9Sstevel@tonic-gate 
22757c478bd9Sstevel@tonic-gate 	return (prop->pr_type);
22767c478bd9Sstevel@tonic-gate }
22777c478bd9Sstevel@tonic-gate 
22787c478bd9Sstevel@tonic-gate 
22797c478bd9Sstevel@tonic-gate char *
22807c478bd9Sstevel@tonic-gate scf_simple_prop_name(const scf_simple_prop_t *prop)
22817c478bd9Sstevel@tonic-gate {
22827c478bd9Sstevel@tonic-gate 	if ((prop == NULL) || (prop->pr_propname == NULL)) {
22837c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_SET);
22847c478bd9Sstevel@tonic-gate 		return (NULL);
22857c478bd9Sstevel@tonic-gate 	}
22867c478bd9Sstevel@tonic-gate 
22877c478bd9Sstevel@tonic-gate 	return (prop->pr_propname);
22887c478bd9Sstevel@tonic-gate }
22897c478bd9Sstevel@tonic-gate 
22907c478bd9Sstevel@tonic-gate 
22917c478bd9Sstevel@tonic-gate char *
22927c478bd9Sstevel@tonic-gate scf_simple_prop_pgname(const scf_simple_prop_t *prop)
22937c478bd9Sstevel@tonic-gate {
22947c478bd9Sstevel@tonic-gate 	if ((prop == NULL) || (prop->pr_pgname == NULL)) {
22957c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_SET);
22967c478bd9Sstevel@tonic-gate 		return (NULL);
22977c478bd9Sstevel@tonic-gate 	}
22987c478bd9Sstevel@tonic-gate 
22997c478bd9Sstevel@tonic-gate 	return (prop->pr_pgname);
23007c478bd9Sstevel@tonic-gate }
23017c478bd9Sstevel@tonic-gate 
23027c478bd9Sstevel@tonic-gate 
23037c478bd9Sstevel@tonic-gate static union scf_simple_prop_val *
23047c478bd9Sstevel@tonic-gate scf_next_val(scf_simple_prop_t *prop, scf_type_t type)
23057c478bd9Sstevel@tonic-gate {
23067c478bd9Sstevel@tonic-gate 	if (prop == NULL) {
23077c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NOT_SET);
23087c478bd9Sstevel@tonic-gate 		return (NULL);
23097c478bd9Sstevel@tonic-gate 	}
23107c478bd9Sstevel@tonic-gate 
23117c478bd9Sstevel@tonic-gate 	switch (prop->pr_type) {
23127c478bd9Sstevel@tonic-gate 	case SCF_TYPE_USTRING:
23137c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOST:
23147c478bd9Sstevel@tonic-gate 	case SCF_TYPE_HOSTNAME:
23157c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V4:
23167c478bd9Sstevel@tonic-gate 	case SCF_TYPE_NET_ADDR_V6:
23177c478bd9Sstevel@tonic-gate 	case SCF_TYPE_URI:
23187c478bd9Sstevel@tonic-gate 	case SCF_TYPE_FMRI: {
23197c478bd9Sstevel@tonic-gate 		if (type != SCF_TYPE_USTRING) {
23207c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_TYPE_MISMATCH);
23217c478bd9Sstevel@tonic-gate 			return (NULL);
23227c478bd9Sstevel@tonic-gate 		}
23237c478bd9Sstevel@tonic-gate 		break;
23247c478bd9Sstevel@tonic-gate 		}
23257c478bd9Sstevel@tonic-gate 	default: {
23267c478bd9Sstevel@tonic-gate 		if (type != prop->pr_type) {
23277c478bd9Sstevel@tonic-gate 			(void) scf_set_error(SCF_ERROR_TYPE_MISMATCH);
23287c478bd9Sstevel@tonic-gate 			return (NULL);
23297c478bd9Sstevel@tonic-gate 		}
23307c478bd9Sstevel@tonic-gate 		break;
23317c478bd9Sstevel@tonic-gate 		}
23327c478bd9Sstevel@tonic-gate 	}
23337c478bd9Sstevel@tonic-gate 
23347c478bd9Sstevel@tonic-gate 	if (prop->pr_iter >= prop->pr_numvalues) {
23357c478bd9Sstevel@tonic-gate 		(void) scf_set_error(SCF_ERROR_NONE);
23367c478bd9Sstevel@tonic-gate 		return (NULL);
23377c478bd9Sstevel@tonic-gate 	}
23387c478bd9Sstevel@tonic-gate 
23397c478bd9Sstevel@tonic-gate 	return (&prop->pr_vallist[prop->pr_iter++]);
23407c478bd9Sstevel@tonic-gate }
23417c478bd9Sstevel@tonic-gate 
23427c478bd9Sstevel@tonic-gate 
23437c478bd9Sstevel@tonic-gate uint8_t *
23447c478bd9Sstevel@tonic-gate scf_simple_prop_next_boolean(scf_simple_prop_t *prop)
23457c478bd9Sstevel@tonic-gate {
23467c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
23477c478bd9Sstevel@tonic-gate 
23487c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_BOOLEAN);
23497c478bd9Sstevel@tonic-gate 
23507c478bd9Sstevel@tonic-gate 	if (ret == NULL)
23517c478bd9Sstevel@tonic-gate 		return (NULL);
23527c478bd9Sstevel@tonic-gate 
23537c478bd9Sstevel@tonic-gate 	return (&ret->pv_bool);
23547c478bd9Sstevel@tonic-gate }
23557c478bd9Sstevel@tonic-gate 
23567c478bd9Sstevel@tonic-gate 
23577c478bd9Sstevel@tonic-gate uint64_t *
23587c478bd9Sstevel@tonic-gate scf_simple_prop_next_count(scf_simple_prop_t *prop)
23597c478bd9Sstevel@tonic-gate {
23607c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
23617c478bd9Sstevel@tonic-gate 
23627c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_COUNT);
23637c478bd9Sstevel@tonic-gate 
23647c478bd9Sstevel@tonic-gate 	if (ret == NULL)
23657c478bd9Sstevel@tonic-gate 		return (NULL);
23667c478bd9Sstevel@tonic-gate 
23677c478bd9Sstevel@tonic-gate 	return (&ret->pv_uint);
23687c478bd9Sstevel@tonic-gate }
23697c478bd9Sstevel@tonic-gate 
23707c478bd9Sstevel@tonic-gate 
23717c478bd9Sstevel@tonic-gate int64_t *
23727c478bd9Sstevel@tonic-gate scf_simple_prop_next_integer(scf_simple_prop_t *prop)
23737c478bd9Sstevel@tonic-gate {
23747c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
23757c478bd9Sstevel@tonic-gate 
23767c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_INTEGER);
23777c478bd9Sstevel@tonic-gate 
23787c478bd9Sstevel@tonic-gate 	if (ret == NULL)
23797c478bd9Sstevel@tonic-gate 		return (NULL);
23807c478bd9Sstevel@tonic-gate 
23817c478bd9Sstevel@tonic-gate 	return (&ret->pv_int);
23827c478bd9Sstevel@tonic-gate }
23837c478bd9Sstevel@tonic-gate 
23847c478bd9Sstevel@tonic-gate int64_t *
23857c478bd9Sstevel@tonic-gate scf_simple_prop_next_time(scf_simple_prop_t *prop, int32_t *nsec)
23867c478bd9Sstevel@tonic-gate {
23877c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
23887c478bd9Sstevel@tonic-gate 
23897c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_TIME);
23907c478bd9Sstevel@tonic-gate 
23917c478bd9Sstevel@tonic-gate 	if (ret == NULL)
23927c478bd9Sstevel@tonic-gate 		return (NULL);
23937c478bd9Sstevel@tonic-gate 
23947c478bd9Sstevel@tonic-gate 	if (nsec != NULL)
23957c478bd9Sstevel@tonic-gate 		*nsec = ret->pv_time.t_nsec;
23967c478bd9Sstevel@tonic-gate 
23977c478bd9Sstevel@tonic-gate 	return (&ret->pv_time.t_sec);
23987c478bd9Sstevel@tonic-gate }
23997c478bd9Sstevel@tonic-gate 
24007c478bd9Sstevel@tonic-gate char *
24017c478bd9Sstevel@tonic-gate scf_simple_prop_next_astring(scf_simple_prop_t *prop)
24027c478bd9Sstevel@tonic-gate {
24037c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
24047c478bd9Sstevel@tonic-gate 
24057c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_ASTRING);
24067c478bd9Sstevel@tonic-gate 
24077c478bd9Sstevel@tonic-gate 	if (ret == NULL)
24087c478bd9Sstevel@tonic-gate 		return (NULL);
24097c478bd9Sstevel@tonic-gate 
24107c478bd9Sstevel@tonic-gate 	return (ret->pv_str);
24117c478bd9Sstevel@tonic-gate }
24127c478bd9Sstevel@tonic-gate 
24137c478bd9Sstevel@tonic-gate char *
24147c478bd9Sstevel@tonic-gate scf_simple_prop_next_ustring(scf_simple_prop_t *prop)
24157c478bd9Sstevel@tonic-gate {
24167c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
24177c478bd9Sstevel@tonic-gate 
24187c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_USTRING);
24197c478bd9Sstevel@tonic-gate 
24207c478bd9Sstevel@tonic-gate 	if (ret == NULL)
24217c478bd9Sstevel@tonic-gate 		return (NULL);
24227c478bd9Sstevel@tonic-gate 
24237c478bd9Sstevel@tonic-gate 	return (ret->pv_str);
24247c478bd9Sstevel@tonic-gate }
24257c478bd9Sstevel@tonic-gate 
24267c478bd9Sstevel@tonic-gate void *
24277c478bd9Sstevel@tonic-gate scf_simple_prop_next_opaque(scf_simple_prop_t *prop, size_t *length)
24287c478bd9Sstevel@tonic-gate {
24297c478bd9Sstevel@tonic-gate 	union scf_simple_prop_val *ret;
24307c478bd9Sstevel@tonic-gate 
24317c478bd9Sstevel@tonic-gate 	ret = scf_next_val(prop, SCF_TYPE_OPAQUE);
24327c478bd9Sstevel@tonic-gate 
24337c478bd9Sstevel@tonic-gate 	if (ret == NULL) {
24347c478bd9Sstevel@tonic-gate 		*length = 0;
24357c478bd9Sstevel@tonic-gate 		return (NULL);
24367c478bd9Sstevel@tonic-gate 	}
24377c478bd9Sstevel@tonic-gate 
24387c478bd9Sstevel@tonic-gate 	*length = ret->pv_opaque.o_size;
24397c478bd9Sstevel@tonic-gate 	return (ret->pv_opaque.o_value);
24407c478bd9Sstevel@tonic-gate }
244194501b61Sskamm 
244294501b61Sskamm /*
244394501b61Sskamm  * Generate a filename based on the fmri and the given name and return
244494501b61Sskamm  * it in the buffer of MAXPATHLEN provided by the caller.
244594501b61Sskamm  * If temp_filename is non-zero, also generate a temporary, unique filename
244694501b61Sskamm  * and return it in the temp buffer of MAXPATHLEN provided by the caller.
244794501b61Sskamm  * The path to the generated pathname is also created.
244894501b61Sskamm  * Given fmri should begin with a scheme such as "svc:".
244994501b61Sskamm  * Returns
245094501b61Sskamm  *      0 on success
245194501b61Sskamm  *      -1 if filename would exceed MAXPATHLEN or
245294501b61Sskamm  *	-2 if unable to create directory to filename path
245394501b61Sskamm  */
245494501b61Sskamm int
245594501b61Sskamm gen_filenms_from_fmri(const char *fmri, const char *name, char *filename,
245694501b61Sskamm     char *temp_filename)
245794501b61Sskamm {
245894501b61Sskamm 	int		len;
245994501b61Sskamm 
246094501b61Sskamm 	len = strlen(SMF_SPEEDY_FILES_PATH);
246194501b61Sskamm 	len += strlen(fmri);
246294501b61Sskamm 	len += 2;			/* for slash and null */
246394501b61Sskamm 	len += strlen(name);
246494501b61Sskamm 	len += 6;			/* For X's needed for mkstemp */
246594501b61Sskamm 
246694501b61Sskamm 	if (len > MAXPATHLEN)
246794501b61Sskamm 		return (-1);
246894501b61Sskamm 
246994501b61Sskamm 	/* Construct directory name first - speedy path ends in slash */
247094501b61Sskamm 	(void) strcpy(filename, SMF_SPEEDY_FILES_PATH);
247194501b61Sskamm 	(void) strcat(filename, fmri);
247294501b61Sskamm 	if (mkdirp(filename, 0755) == -1) {
247394501b61Sskamm 		/* errno is set */
247494501b61Sskamm 		if (errno != EEXIST)
247594501b61Sskamm 			return (-2);
247694501b61Sskamm 	}
247794501b61Sskamm 
247894501b61Sskamm 	(void) strcat(filename, "/");
247994501b61Sskamm 	(void) strcat(filename, name);
248094501b61Sskamm 
248194501b61Sskamm 	if (temp_filename) {
248294501b61Sskamm 		(void) strcpy(temp_filename, filename);
248394501b61Sskamm 		(void) strcat(temp_filename, "XXXXXX");
248494501b61Sskamm 	}
248594501b61Sskamm 
248694501b61Sskamm 	return (0);
248794501b61Sskamm }
2488