xref: /illumos-gate/usr/src/lib/libscf/common/midlevel.c (revision e6ccb06dae563daedbe76eeadbdd3940a4e4f693)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2013 Nexenta Systems, Inc.  All rights reserved.
25  * Copyright 2018 RackTop Systems.
26  */
27 
28 #include "libscf_impl.h"
29 
30 #include <assert.h>
31 #include <libuutil.h>
32 #include <stdio.h>
33 #include <string.h>
34 #include <stdlib.h>
35 #include <sys/param.h>
36 #include <errno.h>
37 #include <libgen.h>
38 #include <assert.h>
39 #include "midlevel_impl.h"
40 #include "lowlevel_impl.h"
41 
42 #ifndef NDEBUG
43 #define	bad_error(func, err)	{					\
44 	uu_warn("%s:%d: %s failed with unexpected error %d.  Aborting.\n", \
45 	    __FILE__, __LINE__, func, err);				\
46 	abort();							\
47 }
48 #else
49 #define	bad_error(func, err)	abort()
50 #endif
51 
52 /* Path to speedy files area must end with a slash */
53 #define	SMF_SPEEDY_FILES_PATH		"/etc/svc/volatile/"
54 
55 void
56 scf_simple_handle_destroy(scf_simple_handle_t *simple_h)
57 {
58 	if (simple_h == NULL)
59 		return;
60 
61 	scf_pg_destroy(simple_h->running_pg);
62 	scf_pg_destroy(simple_h->editing_pg);
63 	scf_snapshot_destroy(simple_h->snap);
64 	scf_instance_destroy(simple_h->inst);
65 	scf_handle_destroy(simple_h->h);
66 	uu_free(simple_h);
67 }
68 
69 /*
70  * Given a base service FMRI and the names of a property group and property,
71  * assemble_fmri() merges them into a property FMRI.  Note that if the base
72  * FMRI is NULL, assemble_fmri() gets the base FMRI from scf_myname().
73  */
74 
75 static char *
76 assemble_fmri(scf_handle_t *h, const char *base, const char *pg,
77     const char *prop)
78 {
79 	size_t	fmri_sz, pglen;
80 	ssize_t baselen;
81 	char	*fmri_buf;
82 
83 	if (prop == NULL) {
84 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
85 		return (NULL);
86 	}
87 
88 	if (pg == NULL)
89 		pglen = strlen(SCF_PG_APP_DEFAULT);
90 	else
91 		pglen = strlen(pg);
92 
93 	if (base == NULL) {
94 		if ((baselen = scf_myname(h, NULL, 0)) == -1)
95 			return (NULL);
96 	} else {
97 		baselen = strlen(base);
98 	}
99 
100 	fmri_sz = baselen + sizeof (SCF_FMRI_PROPERTYGRP_PREFIX) - 1 +
101 	    pglen + sizeof (SCF_FMRI_PROPERTY_PREFIX) - 1 +
102 	    strlen(prop) + 1;
103 
104 	if ((fmri_buf = malloc(fmri_sz)) == NULL) {
105 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
106 		return (NULL);
107 	}
108 
109 	if (base == NULL) {
110 		if (scf_myname(h, fmri_buf, fmri_sz) == -1) {
111 			free(fmri_buf);
112 			return (NULL);
113 		}
114 	} else {
115 		(void) strcpy(fmri_buf, base);
116 	}
117 
118 	(void) strcat(fmri_buf, SCF_FMRI_PROPERTYGRP_PREFIX);
119 
120 	if (pg == NULL)
121 		(void) strcat(fmri_buf, SCF_PG_APP_DEFAULT);
122 	else
123 		(void) strcat(fmri_buf, pg);
124 
125 	(void) strcat(fmri_buf, SCF_FMRI_PROPERTY_PREFIX);
126 	(void) strcat(fmri_buf, prop);
127 	return (fmri_buf);
128 }
129 
130 /*
131  * Given a property, this function allocates and fills an scf_simple_prop_t
132  * with the data it contains.
133  */
134 
135 static scf_simple_prop_t *
136 fill_prop(scf_property_t *prop, const char *pgname, const char *propname,
137     scf_handle_t *h)
138 {
139 	scf_simple_prop_t 		*ret;
140 	scf_iter_t 			*iter;
141 	scf_value_t 			*val;
142 	int 				iterret, i;
143 	ssize_t 			valsize, numvals;
144 	union scf_simple_prop_val 	*vallist = NULL, *vallist_backup = NULL;
145 
146 	if ((ret = malloc(sizeof (*ret))) == NULL) {
147 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
148 		return (NULL);
149 	}
150 
151 	ret->pr_next = NULL;
152 	ret->pr_pg = NULL;
153 	ret->pr_iter = 0;
154 
155 	if (pgname == NULL)
156 		ret->pr_pgname = strdup(SCF_PG_APP_DEFAULT);
157 	else
158 		ret->pr_pgname = strdup(pgname);
159 
160 	if (ret->pr_pgname == NULL) {
161 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
162 		free(ret);
163 		return (NULL);
164 	}
165 
166 	if ((ret->pr_propname = strdup(propname)) == NULL) {
167 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
168 		free(ret->pr_pgname);
169 		free(ret);
170 		return (NULL);
171 	}
172 
173 	if (scf_property_type(prop, &ret->pr_type) == -1)
174 		goto error3;
175 
176 	if ((iter = scf_iter_create(h)) == NULL)
177 		goto error3;
178 	if ((val = scf_value_create(h)) == NULL) {
179 		scf_iter_destroy(iter);
180 		goto error3;
181 	}
182 
183 	if (scf_iter_property_values(iter, prop) == -1)
184 		goto error1;
185 
186 	for (numvals = 0; (iterret = scf_iter_next_value(iter, val)) == 1;
187 	    numvals++) {
188 		vallist_backup = vallist;
189 		if ((vallist = realloc(vallist, (numvals + 1) *
190 		    sizeof (*vallist))) == NULL) {
191 			vallist = vallist_backup;
192 			goto error1;
193 		}
194 
195 		switch (ret->pr_type) {
196 		case SCF_TYPE_BOOLEAN:
197 			if (scf_value_get_boolean(val,
198 			    &vallist[numvals].pv_bool) == -1)
199 				goto error1;
200 			break;
201 
202 		case SCF_TYPE_COUNT:
203 			if (scf_value_get_count(val,
204 			    &vallist[numvals].pv_uint) == -1)
205 				goto error1;
206 			break;
207 
208 		case SCF_TYPE_INTEGER:
209 			if (scf_value_get_integer(val,
210 			    &vallist[numvals].pv_int) == -1)
211 				goto error1;
212 			break;
213 
214 		case SCF_TYPE_TIME:
215 			if (scf_value_get_time(val,
216 			    &vallist[numvals].pv_time.t_sec,
217 			    &vallist[numvals].pv_time.t_nsec) == -1)
218 				goto error1;
219 			break;
220 
221 		case SCF_TYPE_ASTRING:
222 			vallist[numvals].pv_str = NULL;
223 			if ((valsize = scf_value_get_astring(val, NULL, 0)) ==
224 			    -1)
225 				goto error1;
226 			if ((vallist[numvals].pv_str = malloc(valsize+1)) ==
227 			    NULL) {
228 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
229 				goto error1;
230 			}
231 			if (scf_value_get_astring(val,
232 			    vallist[numvals].pv_str, valsize+1) == -1) {
233 				free(vallist[numvals].pv_str);
234 				goto error1;
235 			}
236 			break;
237 
238 		case SCF_TYPE_USTRING:
239 		case SCF_TYPE_HOST:
240 		case SCF_TYPE_HOSTNAME:
241 		case SCF_TYPE_NET_ADDR:
242 		case SCF_TYPE_NET_ADDR_V4:
243 		case SCF_TYPE_NET_ADDR_V6:
244 		case SCF_TYPE_URI:
245 		case SCF_TYPE_FMRI:
246 			vallist[numvals].pv_str = NULL;
247 			if ((valsize = scf_value_get_ustring(val, NULL, 0)) ==
248 			    -1)
249 				goto error1;
250 			if ((vallist[numvals].pv_str = malloc(valsize+1)) ==
251 			    NULL) {
252 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
253 				goto error1;
254 			}
255 			if (scf_value_get_ustring(val,
256 			    vallist[numvals].pv_str, valsize+1) == -1) {
257 				free(vallist[numvals].pv_str);
258 				goto error1;
259 			}
260 			break;
261 
262 		case SCF_TYPE_OPAQUE:
263 			vallist[numvals].pv_opaque.o_value = NULL;
264 			if ((valsize = scf_value_get_opaque(val, NULL, 0)) ==
265 			    -1)
266 				goto error1;
267 			if ((vallist[numvals].pv_opaque.o_value =
268 			    malloc(valsize)) == NULL) {
269 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
270 				goto error1;
271 			}
272 			vallist[numvals].pv_opaque.o_size = valsize;
273 			if (scf_value_get_opaque(val,
274 			    vallist[numvals].pv_opaque.o_value,
275 			    valsize) == -1) {
276 				free(vallist[numvals].pv_opaque.o_value);
277 				goto error1;
278 			}
279 			break;
280 
281 		default:
282 			(void) scf_set_error(SCF_ERROR_INTERNAL);
283 			goto error1;
284 
285 		}
286 	}
287 
288 	if (iterret == -1) {
289 		int err = scf_error();
290 		if (err != SCF_ERROR_CONNECTION_BROKEN &&
291 		    err != SCF_ERROR_PERMISSION_DENIED)
292 			(void) scf_set_error(SCF_ERROR_INTERNAL);
293 		goto error1;
294 	}
295 
296 	ret->pr_vallist = vallist;
297 	ret->pr_numvalues = numvals;
298 
299 	scf_iter_destroy(iter);
300 	(void) scf_value_destroy(val);
301 
302 	return (ret);
303 
304 	/*
305 	 * Exit point for a successful call.  Below this line are exit points
306 	 * for failures at various stages during the function.
307 	 */
308 
309 error1:
310 	if (vallist == NULL)
311 		goto error2;
312 
313 	switch (ret->pr_type) {
314 	case SCF_TYPE_ASTRING:
315 	case SCF_TYPE_USTRING:
316 	case SCF_TYPE_HOST:
317 	case SCF_TYPE_HOSTNAME:
318 	case SCF_TYPE_NET_ADDR:
319 	case SCF_TYPE_NET_ADDR_V4:
320 	case SCF_TYPE_NET_ADDR_V6:
321 	case SCF_TYPE_URI:
322 	case SCF_TYPE_FMRI: {
323 		for (i = 0; i < numvals; i++) {
324 			free(vallist[i].pv_str);
325 		}
326 		break;
327 	}
328 	case SCF_TYPE_OPAQUE: {
329 		for (i = 0; i < numvals; i++) {
330 			free(vallist[i].pv_opaque.o_value);
331 		}
332 		break;
333 	}
334 	default:
335 		break;
336 	}
337 
338 	free(vallist);
339 
340 error2:
341 	scf_iter_destroy(iter);
342 	(void) scf_value_destroy(val);
343 
344 error3:
345 	free(ret->pr_pgname);
346 	free(ret->pr_propname);
347 	free(ret);
348 	return (NULL);
349 }
350 
351 /*
352  * insert_app_props iterates over a property iterator, getting all the
353  * properties from a property group, and adding or overwriting them into
354  * a simple_app_props_t.  This is used by scf_simple_app_props_get to provide
355  * service/instance composition while filling the app_props_t.
356  * insert_app_props iterates over a single property group.
357  */
358 
359 static int
360 insert_app_props(scf_iter_t *propiter, char *pgname, char *propname, struct
361     scf_simple_pg *thispg, scf_property_t *prop, size_t namelen,
362     scf_handle_t *h)
363 {
364 	scf_simple_prop_t	*thisprop, *prevprop, *newprop;
365 	uint8_t			found;
366 	int			propiter_ret;
367 
368 	while ((propiter_ret = scf_iter_next_property(propiter, prop)) == 1) {
369 
370 		if (scf_property_get_name(prop, propname, namelen) < 0) {
371 			if (scf_error() == SCF_ERROR_NOT_SET)
372 				(void) scf_set_error(SCF_ERROR_INTERNAL);
373 			return (-1);
374 		}
375 
376 		thisprop = thispg->pg_proplist;
377 		prevprop = thispg->pg_proplist;
378 		found = 0;
379 
380 		while ((thisprop != NULL) && (!found)) {
381 			if (strcmp(thisprop->pr_propname, propname) == 0) {
382 				found = 1;
383 				if ((newprop = fill_prop(prop, pgname,
384 				    propname, h)) == NULL)
385 					return (-1);
386 
387 				if (thisprop == thispg->pg_proplist)
388 					thispg->pg_proplist = newprop;
389 				else
390 					prevprop->pr_next = newprop;
391 
392 				newprop->pr_pg = thispg;
393 				newprop->pr_next = thisprop->pr_next;
394 				scf_simple_prop_free(thisprop);
395 				thisprop = NULL;
396 			} else {
397 				if (thisprop != thispg->pg_proplist)
398 					prevprop = prevprop->pr_next;
399 				thisprop = thisprop->pr_next;
400 			}
401 		}
402 
403 		if (!found) {
404 			if ((newprop = fill_prop(prop, pgname, propname, h)) ==
405 			    NULL)
406 				return (-1);
407 
408 			if (thispg->pg_proplist == NULL)
409 				thispg->pg_proplist = newprop;
410 			else
411 				prevprop->pr_next = newprop;
412 
413 			newprop->pr_pg = thispg;
414 		}
415 	}
416 
417 	if (propiter_ret == -1) {
418 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
419 			(void) scf_set_error(SCF_ERROR_INTERNAL);
420 		return (-1);
421 	}
422 
423 	return (0);
424 }
425 
426 
427 /*
428  * Sets up e in tx to set pname's values.  Returns 0 on success or -1 on
429  * failure, with scf_error() set to
430  *   SCF_ERROR_HANDLE_MISMATCH - tx & e are derived from different handles
431  *   SCF_ERROR_INVALID_ARGUMENT - pname or ty are invalid
432  *   SCF_ERROR_NOT_BOUND - handle is not bound
433  *   SCF_ERROR_CONNECTION_BROKEN - connection was broken
434  *   SCF_ERROR_NOT_SET - tx has not been started
435  *   SCF_ERROR_DELETED - the pg tx was started on was deleted
436  */
437 static int
438 transaction_property_set(scf_transaction_t *tx, scf_transaction_entry_t *e,
439     const char *pname, scf_type_t ty)
440 {
441 	for (;;) {
442 		if (scf_transaction_property_change_type(tx, e, pname, ty) == 0)
443 			return (0);
444 
445 		switch (scf_error()) {
446 		case SCF_ERROR_HANDLE_MISMATCH:
447 		case SCF_ERROR_INVALID_ARGUMENT:
448 		case SCF_ERROR_NOT_BOUND:
449 		case SCF_ERROR_CONNECTION_BROKEN:
450 		case SCF_ERROR_NOT_SET:
451 		case SCF_ERROR_DELETED:
452 		default:
453 			return (-1);
454 
455 		case SCF_ERROR_NOT_FOUND:
456 			break;
457 		}
458 
459 		if (scf_transaction_property_new(tx, e, pname, ty) == 0)
460 			return (0);
461 
462 		switch (scf_error()) {
463 		case SCF_ERROR_HANDLE_MISMATCH:
464 		case SCF_ERROR_INVALID_ARGUMENT:
465 		case SCF_ERROR_NOT_BOUND:
466 		case SCF_ERROR_CONNECTION_BROKEN:
467 		case SCF_ERROR_NOT_SET:
468 		case SCF_ERROR_DELETED:
469 		default:
470 			return (-1);
471 
472 		case SCF_ERROR_EXISTS:
473 			break;
474 		}
475 	}
476 }
477 
478 static int
479 get_inst_enabled(const scf_instance_t *inst, const char *pgname)
480 {
481 	scf_propertygroup_t 	*gpg = NULL;
482 	scf_property_t 		*eprop = NULL;
483 	scf_value_t 		*v = NULL;
484 	scf_handle_t		*h = NULL;
485 	uint8_t			enabled;
486 	int			ret = -1;
487 
488 	if ((h = scf_instance_handle(inst)) == NULL)
489 		return (-1);
490 
491 	if ((gpg = scf_pg_create(h)) == NULL ||
492 	    (eprop = scf_property_create(h)) == NULL ||
493 	    (v = scf_value_create(h)) == NULL)
494 		goto out;
495 
496 	if (scf_instance_get_pg(inst, pgname, gpg) ||
497 	    scf_pg_get_property(gpg, SCF_PROPERTY_ENABLED, eprop) ||
498 	    scf_property_get_value(eprop, v) ||
499 	    scf_value_get_boolean(v, &enabled))
500 		goto out;
501 	ret = enabled;
502 
503 out:
504 	scf_pg_destroy(gpg);
505 	scf_property_destroy(eprop);
506 	scf_value_destroy(v);
507 	return (ret);
508 }
509 
510 /*
511  * set_inst_enabled() is a "master" enable/disable call that takes the
512  * instance and the desired state for the enabled bit in the instance's
513  * named property group.  If the group doesn't exist, it's created with the
514  * given flags.  Called by smf_{dis,en}able_instance().
515  */
516 static int
517 set_inst_enabled(const scf_instance_t *inst, uint8_t desired,
518     const char *pgname, uint32_t pgflags)
519 {
520 	scf_transaction_t 	*tx = NULL;
521 	scf_transaction_entry_t *ent = NULL;
522 	scf_propertygroup_t 	*gpg = NULL;
523 	scf_property_t 		*eprop = NULL;
524 	scf_value_t 		*v = NULL;
525 	scf_handle_t		*h = NULL;
526 	int 			ret = -1;
527 	int			committed;
528 	uint8_t			b;
529 
530 	if ((h = scf_instance_handle(inst)) == NULL)
531 		return (-1);
532 
533 	if ((gpg = scf_pg_create(h)) == NULL ||
534 	    (eprop = scf_property_create(h)) == NULL ||
535 	    (v = scf_value_create(h)) == NULL ||
536 	    (tx = scf_transaction_create(h)) == NULL ||
537 	    (ent = scf_entry_create(h)) == NULL)
538 		goto out;
539 
540 general_pg_get:
541 	if (scf_instance_get_pg(inst, SCF_PG_GENERAL, gpg) == -1) {
542 		if (scf_error() != SCF_ERROR_NOT_FOUND)
543 			goto out;
544 
545 		if (scf_instance_add_pg(inst, SCF_PG_GENERAL,
546 		    SCF_GROUP_FRAMEWORK, SCF_PG_GENERAL_FLAGS, gpg) == -1) {
547 			if (scf_error() != SCF_ERROR_EXISTS)
548 				goto out;
549 			goto general_pg_get;
550 		}
551 	}
552 
553 	if (strcmp(pgname, SCF_PG_GENERAL) != 0) {
554 get:
555 		if (scf_instance_get_pg(inst, pgname, gpg) == -1) {
556 			if (scf_error() != SCF_ERROR_NOT_FOUND)
557 				goto out;
558 
559 			if (scf_instance_add_pg(inst, pgname,
560 			    SCF_GROUP_FRAMEWORK, pgflags, gpg) == -1) {
561 				if (scf_error() != SCF_ERROR_EXISTS)
562 					goto out;
563 				goto get;
564 			}
565 		}
566 	}
567 
568 	if (scf_pg_get_property(gpg, SCF_PROPERTY_ENABLED, eprop) == -1) {
569 		if (scf_error() != SCF_ERROR_NOT_FOUND)
570 			goto out;
571 		else
572 			goto set;
573 	}
574 
575 	/*
576 	 * If it's already set the way we want, forgo the transaction.
577 	 */
578 	if (scf_property_get_value(eprop, v) == -1) {
579 		switch (scf_error()) {
580 		case SCF_ERROR_CONSTRAINT_VIOLATED:
581 		case SCF_ERROR_NOT_FOUND:
582 			/* Misconfigured, so set anyway. */
583 			goto set;
584 
585 		default:
586 			goto out;
587 		}
588 	}
589 	if (scf_value_get_boolean(v, &b) == -1) {
590 		if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
591 			goto out;
592 		goto set;
593 	}
594 	if (b == desired) {
595 		ret = 0;
596 		goto out;
597 	}
598 
599 set:
600 	do {
601 		if (scf_transaction_start(tx, gpg) == -1)
602 			goto out;
603 
604 		if (transaction_property_set(tx, ent, SCF_PROPERTY_ENABLED,
605 		    SCF_TYPE_BOOLEAN) != 0) {
606 			switch (scf_error()) {
607 			case SCF_ERROR_CONNECTION_BROKEN:
608 			case SCF_ERROR_DELETED:
609 			default:
610 				goto out;
611 
612 			case SCF_ERROR_HANDLE_MISMATCH:
613 			case SCF_ERROR_INVALID_ARGUMENT:
614 			case SCF_ERROR_NOT_BOUND:
615 			case SCF_ERROR_NOT_SET:
616 				bad_error("transaction_property_set",
617 				    scf_error());
618 			}
619 		}
620 
621 		scf_value_set_boolean(v, desired);
622 		if (scf_entry_add_value(ent, v) == -1)
623 			goto out;
624 
625 		committed = scf_transaction_commit(tx);
626 		if (committed == -1)
627 			goto out;
628 
629 		scf_transaction_reset(tx);
630 
631 		if (committed == 0) { /* out-of-sync */
632 			if (scf_pg_update(gpg) == -1)
633 				goto out;
634 		}
635 	} while (committed == 0);
636 
637 	ret = 0;
638 
639 out:
640 	scf_value_destroy(v);
641 	scf_entry_destroy(ent);
642 	scf_transaction_destroy(tx);
643 	scf_property_destroy(eprop);
644 	scf_pg_destroy(gpg);
645 
646 	return (ret);
647 }
648 
649 static int
650 delete_inst_enabled(const scf_instance_t *inst, const char *pgname)
651 {
652 	scf_transaction_t 	*tx = NULL;
653 	scf_transaction_entry_t *ent = NULL;
654 	scf_propertygroup_t 	*gpg = NULL;
655 	scf_handle_t		*h = NULL;
656 	int			ret = -1;
657 	int			committed;
658 
659 	if ((h = scf_instance_handle(inst)) == NULL)
660 		return (-1);
661 
662 	if ((gpg = scf_pg_create(h)) == NULL ||
663 	    (tx = scf_transaction_create(h)) == NULL ||
664 	    (ent = scf_entry_create(h)) == NULL)
665 		goto out;
666 
667 	if (scf_instance_get_pg(inst, pgname, gpg) != 0)
668 		goto error;
669 	do {
670 		if (scf_transaction_start(tx, gpg) == -1 ||
671 		    scf_transaction_property_delete(tx, ent,
672 		    SCF_PROPERTY_ENABLED) == -1 ||
673 		    (committed = scf_transaction_commit(tx)) == -1)
674 			goto error;
675 
676 		scf_transaction_reset(tx);
677 
678 		if (committed == 0 && scf_pg_update(gpg) == -1)
679 			goto error;
680 	} while (committed == 0);
681 
682 	ret = 0;
683 	goto out;
684 
685 error:
686 	switch (scf_error()) {
687 	case SCF_ERROR_DELETED:
688 	case SCF_ERROR_NOT_FOUND:
689 		/* success */
690 		ret = 0;
691 	}
692 
693 out:
694 	scf_entry_destroy(ent);
695 	scf_transaction_destroy(tx);
696 	scf_pg_destroy(gpg);
697 
698 	return (ret);
699 }
700 
701 /*
702  * Returns 0 on success or -1 on failure.  On failure leaves scf_error() set to
703  *   SCF_ERROR_HANDLE_DESTROYED - inst's handle has been destroyed
704  *   SCF_ERROR_NOT_BOUND - inst's handle is not bound
705  *   SCF_ERROR_CONNECTION_BROKEN - the repository connection was broken
706  *   SCF_ERROR_NOT_SET - inst is not set
707  *   SCF_ERROR_DELETED - inst was deleted
708  *   SCF_ERROR_PERMISSION_DENIED
709  *   SCF_ERROR_BACKEND_ACCESS
710  *   SCF_ERROR_BACKEND_READONLY
711  */
712 static int
713 set_inst_action_inst(scf_instance_t *inst, const char *action)
714 {
715 	scf_handle_t			*h;
716 	scf_transaction_t		*tx = NULL;
717 	scf_transaction_entry_t		*ent = NULL;
718 	scf_propertygroup_t		*pg = NULL;
719 	scf_property_t			*prop = NULL;
720 	scf_value_t			*v = NULL;
721 	int				trans, ret = -1;
722 	int64_t				t;
723 	hrtime_t			timestamp;
724 
725 	if ((h = scf_instance_handle(inst)) == NULL ||
726 	    (pg = scf_pg_create(h)) == NULL ||
727 	    (prop = scf_property_create(h)) == NULL ||
728 	    (v = scf_value_create(h)) == NULL ||
729 	    (tx = scf_transaction_create(h)) == NULL ||
730 	    (ent = scf_entry_create(h)) == NULL)
731 		goto out;
732 
733 get:
734 	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER_ACTIONS, pg) == -1) {
735 		switch (scf_error()) {
736 		case SCF_ERROR_NOT_BOUND:
737 		case SCF_ERROR_CONNECTION_BROKEN:
738 		case SCF_ERROR_NOT_SET:
739 		case SCF_ERROR_DELETED:
740 		default:
741 			goto out;
742 
743 		case SCF_ERROR_NOT_FOUND:
744 			break;
745 
746 		case SCF_ERROR_HANDLE_MISMATCH:
747 		case SCF_ERROR_INVALID_ARGUMENT:
748 			bad_error("scf_instance_get_pg", scf_error());
749 		}
750 
751 		/* Try creating the restarter_actions property group. */
752 add:
753 		if (scf_instance_add_pg(inst, SCF_PG_RESTARTER_ACTIONS,
754 		    SCF_PG_RESTARTER_ACTIONS_TYPE,
755 		    SCF_PG_RESTARTER_ACTIONS_FLAGS, pg) == -1) {
756 			switch (scf_error()) {
757 			case SCF_ERROR_NOT_BOUND:
758 			case SCF_ERROR_CONNECTION_BROKEN:
759 			case SCF_ERROR_NOT_SET:
760 			case SCF_ERROR_DELETED:
761 			case SCF_ERROR_PERMISSION_DENIED:
762 			case SCF_ERROR_BACKEND_ACCESS:
763 			case SCF_ERROR_BACKEND_READONLY:
764 			default:
765 				goto out;
766 
767 			case SCF_ERROR_EXISTS:
768 				goto get;
769 
770 			case SCF_ERROR_HANDLE_MISMATCH:
771 			case SCF_ERROR_INVALID_ARGUMENT:
772 				bad_error("scf_instance_add_pg", scf_error());
773 			}
774 		}
775 	}
776 
777 	for (;;) {
778 		timestamp = gethrtime();
779 
780 		if (scf_pg_get_property(pg, action, prop) != 0) {
781 			switch (scf_error()) {
782 			case SCF_ERROR_CONNECTION_BROKEN:
783 			default:
784 				goto out;
785 
786 			case SCF_ERROR_DELETED:
787 				goto add;
788 
789 			case SCF_ERROR_NOT_FOUND:
790 				break;
791 
792 			case SCF_ERROR_HANDLE_MISMATCH:
793 			case SCF_ERROR_INVALID_ARGUMENT:
794 			case SCF_ERROR_NOT_BOUND:
795 			case SCF_ERROR_NOT_SET:
796 				bad_error("scf_pg_get_property", scf_error());
797 			}
798 		} else if (scf_property_get_value(prop, v) != 0) {
799 			switch (scf_error()) {
800 			case SCF_ERROR_CONNECTION_BROKEN:
801 			default:
802 				goto out;
803 
804 			case SCF_ERROR_DELETED:
805 				goto add;
806 
807 			case SCF_ERROR_CONSTRAINT_VIOLATED:
808 			case SCF_ERROR_NOT_FOUND:
809 				break;
810 
811 			case SCF_ERROR_HANDLE_MISMATCH:
812 			case SCF_ERROR_NOT_BOUND:
813 			case SCF_ERROR_NOT_SET:
814 				bad_error("scf_property_get_value",
815 				    scf_error());
816 			}
817 		} else if (scf_value_get_integer(v, &t) != 0) {
818 			bad_error("scf_value_get_integer", scf_error());
819 		} else if (t > timestamp) {
820 			break;
821 		}
822 
823 		if (scf_transaction_start(tx, pg) == -1) {
824 			switch (scf_error()) {
825 			case SCF_ERROR_NOT_BOUND:
826 			case SCF_ERROR_CONNECTION_BROKEN:
827 			case SCF_ERROR_PERMISSION_DENIED:
828 			case SCF_ERROR_BACKEND_ACCESS:
829 			case SCF_ERROR_BACKEND_READONLY:
830 			default:
831 				goto out;
832 
833 			case SCF_ERROR_DELETED:
834 				goto add;
835 
836 			case SCF_ERROR_HANDLE_MISMATCH:
837 			case SCF_ERROR_NOT_SET:
838 			case SCF_ERROR_IN_USE:
839 				bad_error("scf_transaction_start", scf_error());
840 			}
841 		}
842 
843 		if (transaction_property_set(tx, ent, action,
844 		    SCF_TYPE_INTEGER) != 0) {
845 			switch (scf_error()) {
846 			case SCF_ERROR_NOT_BOUND:
847 			case SCF_ERROR_CONNECTION_BROKEN:
848 			case SCF_ERROR_DELETED:
849 			default:
850 				goto out;
851 
852 			case SCF_ERROR_HANDLE_MISMATCH:
853 			case SCF_ERROR_INVALID_ARGUMENT:
854 			case SCF_ERROR_NOT_SET:
855 				bad_error("transaction_property_set",
856 				    scf_error());
857 			}
858 		}
859 
860 		scf_value_set_integer(v, timestamp);
861 		if (scf_entry_add_value(ent, v) == -1)
862 			bad_error("scf_entry_add_value", scf_error());
863 
864 		trans = scf_transaction_commit(tx);
865 		if (trans == 1)
866 			break;
867 
868 		if (trans != 0) {
869 			switch (scf_error()) {
870 			case SCF_ERROR_CONNECTION_BROKEN:
871 			case SCF_ERROR_PERMISSION_DENIED:
872 			case SCF_ERROR_BACKEND_ACCESS:
873 			case SCF_ERROR_BACKEND_READONLY:
874 			default:
875 				goto out;
876 
877 			case SCF_ERROR_DELETED:
878 				scf_transaction_reset(tx);
879 				goto add;
880 
881 			case SCF_ERROR_INVALID_ARGUMENT:
882 			case SCF_ERROR_NOT_BOUND:
883 			case SCF_ERROR_NOT_SET:
884 				bad_error("scf_transaction_commit",
885 				    scf_error());
886 			}
887 		}
888 
889 		scf_transaction_reset(tx);
890 		if (scf_pg_update(pg) == -1) {
891 			switch (scf_error()) {
892 			case SCF_ERROR_CONNECTION_BROKEN:
893 			default:
894 				goto out;
895 
896 			case SCF_ERROR_DELETED:
897 				goto add;
898 
899 			case SCF_ERROR_NOT_SET:
900 			case SCF_ERROR_NOT_BOUND:
901 				bad_error("scf_pg_update", scf_error());
902 			}
903 		}
904 	}
905 
906 	ret = 0;
907 
908 out:
909 	scf_value_destroy(v);
910 	scf_entry_destroy(ent);
911 	scf_transaction_destroy(tx);
912 	scf_property_destroy(prop);
913 	scf_pg_destroy(pg);
914 	return (ret);
915 }
916 
917 static int
918 set_inst_action(const char *fmri, const char *action)
919 {
920 	scf_handle_t *h;
921 	scf_instance_t *inst;
922 	int ret = -1;
923 
924 	h = _scf_handle_create_and_bind(SCF_VERSION);
925 	if (h == NULL)
926 		return (-1);
927 
928 	inst = scf_instance_create(h);
929 
930 	if (inst != NULL) {
931 		if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
932 		    NULL, SCF_DECODE_FMRI_EXACT) == 0) {
933 			ret = set_inst_action_inst(inst, action);
934 			if (ret == -1 && scf_error() == SCF_ERROR_DELETED)
935 				(void) scf_set_error(SCF_ERROR_NOT_FOUND);
936 		} else {
937 			switch (scf_error()) {
938 			case SCF_ERROR_CONSTRAINT_VIOLATED:
939 				(void) scf_set_error(
940 				    SCF_ERROR_INVALID_ARGUMENT);
941 				break;
942 			case SCF_ERROR_DELETED:
943 				(void) scf_set_error(SCF_ERROR_NOT_FOUND);
944 				break;
945 			}
946 		}
947 
948 		scf_instance_destroy(inst);
949 	}
950 
951 	scf_handle_destroy(h);
952 
953 	return (ret);
954 }
955 
956 
957 /*
958  * get_inst_state() gets the state string from an instance, and returns
959  * the SCF_STATE_* constant that coincides with the instance's current state.
960  */
961 
962 static int
963 get_inst_state(scf_instance_t *inst, scf_handle_t *h)
964 {
965 	scf_propertygroup_t	*pg = NULL;
966 	scf_property_t		*prop = NULL;
967 	scf_value_t		*val = NULL;
968 	char			state[MAX_SCF_STATE_STRING_SZ];
969 	int			ret = -1;
970 
971 	if (((pg = scf_pg_create(h)) == NULL) ||
972 	    ((prop = scf_property_create(h)) == NULL) ||
973 	    ((val = scf_value_create(h)) == NULL))
974 		goto out;
975 
976 	/* Pull the state property from the instance */
977 
978 	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) == -1 ||
979 	    scf_pg_get_property(pg, SCF_PROPERTY_STATE, prop) == -1 ||
980 	    scf_property_get_value(prop, val) == -1) {
981 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
982 			(void) scf_set_error(SCF_ERROR_INTERNAL);
983 		goto out;
984 	}
985 
986 	if (scf_value_get_astring(val, state, sizeof (state)) <= 0) {
987 		(void) scf_set_error(SCF_ERROR_INTERNAL);
988 		goto out;
989 	}
990 
991 	if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) {
992 		ret = SCF_STATE_UNINIT;
993 	} else if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
994 		ret = SCF_STATE_MAINT;
995 	} else if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0) {
996 		ret = SCF_STATE_OFFLINE;
997 	} else if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) {
998 		ret = SCF_STATE_DISABLED;
999 	} else if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) {
1000 		ret = SCF_STATE_ONLINE;
1001 	} else if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) {
1002 		ret = SCF_STATE_DEGRADED;
1003 	}
1004 
1005 out:
1006 	scf_pg_destroy(pg);
1007 	scf_property_destroy(prop);
1008 	(void) scf_value_destroy(val);
1009 
1010 	return (ret);
1011 }
1012 
1013 /*
1014  * Sets an instance to be enabled or disabled after reboot, using the
1015  * temporary (overriding) general_ovr property group to reflect the
1016  * present state, if it is different.
1017  */
1018 static int
1019 set_inst_enabled_atboot(scf_instance_t *inst, uint8_t desired)
1020 {
1021 	int enabled;
1022 	int persistent;
1023 	int ret = -1;
1024 
1025 	if ((persistent = get_inst_enabled(inst, SCF_PG_GENERAL)) < 0) {
1026 		if (scf_error() != SCF_ERROR_NOT_FOUND)
1027 			goto out;
1028 		persistent = B_FALSE;
1029 	}
1030 	if ((enabled = get_inst_enabled(inst, SCF_PG_GENERAL_OVR)) < 0) {
1031 		enabled = persistent;
1032 		if (persistent != desired) {
1033 			/*
1034 			 * Temporarily store the present enabled state.
1035 			 */
1036 			if (set_inst_enabled(inst, persistent,
1037 			    SCF_PG_GENERAL_OVR, SCF_PG_GENERAL_OVR_FLAGS))
1038 				goto out;
1039 		}
1040 	}
1041 	if (persistent != desired)
1042 		if (set_inst_enabled(inst, desired, SCF_PG_GENERAL,
1043 		    SCF_PG_GENERAL_FLAGS))
1044 			goto out;
1045 	if (enabled == desired)
1046 		ret = delete_inst_enabled(inst, SCF_PG_GENERAL_OVR);
1047 	else
1048 		ret = 0;
1049 
1050 out:
1051 	return (ret);
1052 }
1053 
1054 static int
1055 set_inst_enabled_flags(const char *fmri, int flags, uint8_t desired)
1056 {
1057 	int ret = -1;
1058 	scf_handle_t *h;
1059 	scf_instance_t *inst;
1060 
1061 	if (flags & ~(SMF_TEMPORARY | SMF_AT_NEXT_BOOT) ||
1062 	    flags & SMF_TEMPORARY && flags & SMF_AT_NEXT_BOOT) {
1063 		(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
1064 		return (ret);
1065 	}
1066 
1067 	if ((h = _scf_handle_create_and_bind(SCF_VERSION)) == NULL)
1068 		return (ret);
1069 
1070 	if ((inst = scf_instance_create(h)) == NULL) {
1071 		scf_handle_destroy(h);
1072 		return (ret);
1073 	}
1074 
1075 	if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL, NULL,
1076 	    SCF_DECODE_FMRI_EXACT) == -1) {
1077 		if (scf_error() == SCF_ERROR_CONSTRAINT_VIOLATED)
1078 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
1079 		goto out;
1080 	}
1081 
1082 	if (flags & SMF_AT_NEXT_BOOT) {
1083 		ret = set_inst_enabled_atboot(inst, desired);
1084 	} else {
1085 		if (set_inst_enabled(inst, desired, flags & SMF_TEMPORARY ?
1086 		    SCF_PG_GENERAL_OVR : SCF_PG_GENERAL, flags & SMF_TEMPORARY ?
1087 		    SCF_PG_GENERAL_OVR_FLAGS : SCF_PG_GENERAL_FLAGS))
1088 			goto out;
1089 
1090 		/*
1091 		 * Make the persistent value effective by deleting the
1092 		 * temporary one.
1093 		 */
1094 		if (flags & SMF_TEMPORARY)
1095 			ret = 0;
1096 		else
1097 			ret = delete_inst_enabled(inst, SCF_PG_GENERAL_OVR);
1098 	}
1099 
1100 out:
1101 	scf_instance_destroy(inst);
1102 	scf_handle_destroy(h);
1103 	if (ret == -1 && scf_error() == SCF_ERROR_DELETED)
1104 		(void) scf_set_error(SCF_ERROR_NOT_FOUND);
1105 	return (ret);
1106 }
1107 
1108 /*
1109  * Create and return a pg from the instance associated with the given handle.
1110  * This function is only called in scf_transaction_setup and
1111  * scf_transaction_restart where the h->rh_instance pointer is properly filled
1112  * in by scf_general_setup_pg().
1113  */
1114 static scf_propertygroup_t *
1115 get_instance_pg(scf_simple_handle_t *simple_h)
1116 {
1117 	scf_propertygroup_t	*ret_pg = scf_pg_create(simple_h->h);
1118 	char			*pg_name;
1119 	ssize_t			namelen;
1120 
1121 	if (ret_pg == NULL) {
1122 		return (NULL);
1123 	}
1124 
1125 	namelen = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
1126 	assert(namelen > 0);
1127 
1128 	if ((pg_name = malloc(namelen)) == NULL) {
1129 		if (scf_error() == SCF_ERROR_NOT_SET) {
1130 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1131 		}
1132 		return (NULL);
1133 	}
1134 
1135 	if (scf_pg_get_name(simple_h->running_pg, pg_name, namelen) < 0) {
1136 		if (scf_error() == SCF_ERROR_NOT_SET) {
1137 			(void) scf_set_error(SCF_ERROR_INTERNAL);
1138 		}
1139 		return (NULL);
1140 	}
1141 
1142 	/* Get pg from instance */
1143 	if (scf_instance_get_pg(simple_h->inst, pg_name, ret_pg) == -1) {
1144 		return (NULL);
1145 	}
1146 
1147 	return (ret_pg);
1148 }
1149 
1150 int
1151 smf_enable_instance(const char *fmri, int flags)
1152 {
1153 	return (set_inst_enabled_flags(fmri, flags, B_TRUE));
1154 }
1155 
1156 int
1157 smf_disable_instance(const char *fmri, int flags)
1158 {
1159 	return (set_inst_enabled_flags(fmri, flags, B_FALSE));
1160 }
1161 
1162 int
1163 _smf_refresh_instance_i(scf_instance_t *inst)
1164 {
1165 	return (set_inst_action_inst(inst, SCF_PROPERTY_REFRESH));
1166 }
1167 
1168 int
1169 _smf_refresh_all_instances(scf_service_t *s)
1170 {
1171 	scf_handle_t	*h = scf_service_handle(s);
1172 	scf_instance_t	*i = scf_instance_create(h);
1173 	scf_iter_t	*it = scf_iter_create(h);
1174 	int err, r = -1;
1175 
1176 	if (h == NULL || i == NULL || it == NULL)
1177 		goto error;
1178 
1179 	if (scf_iter_service_instances(it, s) != 0)
1180 		goto error;
1181 
1182 	while ((err = scf_iter_next_instance(it, i)) == 1)
1183 		if (_smf_refresh_instance_i(i) != 0)
1184 			goto error;
1185 
1186 	if (err == -1)
1187 		goto error;
1188 
1189 	r = 0;
1190 error:
1191 	scf_instance_destroy(i);
1192 	scf_iter_destroy(it);
1193 
1194 	return (r);
1195 }
1196 
1197 int
1198 smf_refresh_instance(const char *instance)
1199 {
1200 	return (set_inst_action(instance, SCF_PROPERTY_REFRESH));
1201 }
1202 
1203 int
1204 smf_restart_instance(const char *instance)
1205 {
1206 	return (set_inst_action(instance, SCF_PROPERTY_RESTART));
1207 }
1208 
1209 int
1210 smf_maintain_instance(const char *instance, int flags)
1211 {
1212 	if (flags & SMF_TEMPORARY)
1213 		return (set_inst_action(instance,
1214 		    (flags & SMF_IMMEDIATE) ?
1215 		    SCF_PROPERTY_MAINT_ON_IMMTEMP :
1216 		    SCF_PROPERTY_MAINT_ON_TEMPORARY));
1217 	else
1218 		return (set_inst_action(instance,
1219 		    (flags & SMF_IMMEDIATE) ?
1220 		    SCF_PROPERTY_MAINT_ON_IMMEDIATE :
1221 		    SCF_PROPERTY_MAINT_ON));
1222 }
1223 
1224 int
1225 smf_degrade_instance(const char *instance, int flags)
1226 {
1227 	scf_simple_prop_t		*prop;
1228 	const char			*state_str;
1229 
1230 	if (flags & SMF_TEMPORARY)
1231 		return (scf_set_error(SCF_ERROR_INVALID_ARGUMENT));
1232 
1233 	if ((prop = scf_simple_prop_get(NULL, instance, SCF_PG_RESTARTER,
1234 	    SCF_PROPERTY_STATE)) == NULL)
1235 		return (SCF_FAILED);
1236 
1237 	if ((state_str = scf_simple_prop_next_astring(prop)) == NULL) {
1238 		scf_simple_prop_free(prop);
1239 		return (SCF_FAILED);
1240 	}
1241 
1242 	if (strcmp(state_str, SCF_STATE_STRING_ONLINE) != 0) {
1243 		scf_simple_prop_free(prop);
1244 		return (scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED));
1245 	}
1246 	scf_simple_prop_free(prop);
1247 
1248 	return (set_inst_action(instance, (flags & SMF_IMMEDIATE) ?
1249 	    SCF_PROPERTY_DEGRADE_IMMEDIATE : SCF_PROPERTY_DEGRADED));
1250 }
1251 
1252 int
1253 smf_restore_instance(const char *instance)
1254 {
1255 	scf_simple_prop_t		*prop;
1256 	const char			*state_str;
1257 	int				ret;
1258 
1259 	if ((prop = scf_simple_prop_get(NULL, instance, SCF_PG_RESTARTER,
1260 	    SCF_PROPERTY_STATE)) == NULL)
1261 		return (SCF_FAILED);
1262 
1263 	if ((state_str = scf_simple_prop_next_astring(prop)) == NULL) {
1264 		scf_simple_prop_free(prop);
1265 		return (SCF_FAILED);
1266 	}
1267 
1268 	if (strcmp(state_str, SCF_STATE_STRING_MAINT) == 0) {
1269 		ret = set_inst_action(instance, SCF_PROPERTY_MAINT_OFF);
1270 	} else if (strcmp(state_str, SCF_STATE_STRING_DEGRADED) == 0) {
1271 		ret = set_inst_action(instance, SCF_PROPERTY_RESTORE);
1272 	} else {
1273 		ret = scf_set_error(SCF_ERROR_CONSTRAINT_VIOLATED);
1274 	}
1275 
1276 	scf_simple_prop_free(prop);
1277 	return (ret);
1278 }
1279 
1280 char *
1281 smf_get_state(const char *instance)
1282 {
1283 	scf_simple_prop_t		*prop;
1284 	const char			*state_str;
1285 	char				*ret;
1286 
1287 	if ((prop = scf_simple_prop_get(NULL, instance, SCF_PG_RESTARTER,
1288 	    SCF_PROPERTY_STATE)) == NULL)
1289 		return (NULL);
1290 
1291 	if ((state_str = scf_simple_prop_next_astring(prop)) == NULL) {
1292 		scf_simple_prop_free(prop);
1293 		return (NULL);
1294 	}
1295 
1296 	if ((ret = strdup(state_str)) == NULL)
1297 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1298 
1299 	scf_simple_prop_free(prop);
1300 	return (ret);
1301 }
1302 
1303 /*
1304  * scf_general_pg_setup(fmri, pg_name)
1305  * Create a scf_simple_handle_t and fill in the instance, snapshot, and
1306  * property group fields associated with the given fmri and property group
1307  * name.
1308  * Returns:
1309  *      Handle  on success
1310  *      Null  on error with scf_error set to:
1311  *              SCF_ERROR_HANDLE_MISMATCH,
1312  *              SCF_ERROR_INVALID_ARGUMENT,
1313  *              SCF_ERROR_CONSTRAINT_VIOLATED,
1314  *              SCF_ERROR_NOT_FOUND,
1315  *              SCF_ERROR_NOT_SET,
1316  *              SCF_ERROR_DELETED,
1317  *              SCF_ERROR_NOT_BOUND,
1318  *              SCF_ERROR_CONNECTION_BROKEN,
1319  *              SCF_ERROR_INTERNAL,
1320  *              SCF_ERROR_NO_RESOURCES,
1321  *              SCF_ERROR_BACKEND_ACCESS
1322  */
1323 scf_simple_handle_t *
1324 scf_general_pg_setup(const char *fmri, const char *pg_name)
1325 {
1326 	scf_simple_handle_t	*ret;
1327 
1328 	ret = uu_zalloc(sizeof (*ret));
1329 	if (ret == NULL) {
1330 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1331 		return (NULL);
1332 	} else {
1333 
1334 		ret->h = _scf_handle_create_and_bind(SCF_VERSION);
1335 		ret->inst = scf_instance_create(ret->h);
1336 		ret->snap = scf_snapshot_create(ret->h);
1337 		ret->running_pg = scf_pg_create(ret->h);
1338 	}
1339 
1340 	if ((ret->h == NULL) || (ret->inst == NULL) ||
1341 	    (ret->snap == NULL) || (ret->running_pg == NULL)) {
1342 		goto out;
1343 	}
1344 
1345 	if (scf_handle_decode_fmri(ret->h, fmri, NULL, NULL, ret->inst,
1346 	    NULL, NULL, NULL) == -1) {
1347 		goto out;
1348 	}
1349 
1350 	if ((scf_instance_get_snapshot(ret->inst, "running", ret->snap))
1351 	    != 0) {
1352 		goto out;
1353 	}
1354 
1355 	if (scf_instance_get_pg_composed(ret->inst, ret->snap, pg_name,
1356 	    ret->running_pg) != 0) {
1357 		goto out;
1358 	}
1359 
1360 	return (ret);
1361 
1362 out:
1363 	scf_simple_handle_destroy(ret);
1364 	return (NULL);
1365 }
1366 
1367 /*
1368  * scf_transaction_setup(h)
1369  * creates and starts the transaction
1370  * Returns:
1371  *      transaction  on success
1372  *      NULL on failure with scf_error set to:
1373  *      SCF_ERROR_NO_MEMORY,
1374  *	SCF_ERROR_INVALID_ARGUMENT,
1375  *      SCF_ERROR_HANDLE_DESTROYED,
1376  *	SCF_ERROR_INTERNAL,
1377  *	SCF_ERROR_NO_RESOURCES,
1378  *      SCF_ERROR_NOT_BOUND,
1379  *	SCF_ERROR_CONNECTION_BROKEN,
1380  *      SCF_ERROR_NOT_SET,
1381  *	SCF_ERROR_DELETED,
1382  *	SCF_ERROR_CONSTRAINT_VIOLATED,
1383  *      SCF_ERROR_HANDLE_MISMATCH,
1384  *	SCF_ERROR_BACKEND_ACCESS,
1385  *	SCF_ERROR_IN_USE
1386  */
1387 scf_transaction_t *
1388 scf_transaction_setup(scf_simple_handle_t *simple_h)
1389 {
1390 	scf_transaction_t	*tx = NULL;
1391 
1392 	if ((tx = scf_transaction_create(simple_h->h)) == NULL) {
1393 		return (NULL);
1394 	}
1395 
1396 	if ((simple_h->editing_pg = get_instance_pg(simple_h)) == NULL) {
1397 		return (NULL);
1398 	}
1399 
1400 	if (scf_transaction_start(tx, simple_h->editing_pg) == -1) {
1401 		scf_pg_destroy(simple_h->editing_pg);
1402 		simple_h->editing_pg = NULL;
1403 		return (NULL);
1404 	}
1405 
1406 	return (tx);
1407 }
1408 
1409 int
1410 scf_transaction_restart(scf_simple_handle_t *simple_h, scf_transaction_t *tx)
1411 {
1412 	scf_transaction_reset(tx);
1413 
1414 	if (scf_pg_update(simple_h->editing_pg) == -1) {
1415 		return (SCF_FAILED);
1416 	}
1417 
1418 	if (scf_transaction_start(tx, simple_h->editing_pg) == -1) {
1419 		return (SCF_FAILED);
1420 	}
1421 
1422 	return (SCF_SUCCESS);
1423 }
1424 
1425 /*
1426  * scf_read_count_property(scf_simple_handle_t *simple_h, char *prop_name,
1427  * uint64_t *ret_count)
1428  *
1429  * For the given property name, return the count value.
1430  * RETURNS:
1431  *	SCF_SUCCESS
1432  *	SCF_FAILED on failure with scf_error() set to:
1433  *		SCF_ERROR_HANDLE_DESTROYED
1434  *		SCF_ERROR_INTERNAL
1435  *		SCF_ERROR_NO_RESOURCES
1436  *		SCF_ERROR_NO_MEMORY
1437  *		SCF_ERROR_HANDLE_MISMATCH
1438  *		SCF_ERROR_INVALID_ARGUMENT
1439  *		SCF_ERROR_NOT_BOUND
1440  *		SCF_ERROR_CONNECTION_BROKEN
1441  *		SCF_ERROR_NOT_SET
1442  *		SCF_ERROR_DELETED
1443  *		SCF_ERROR_BACKEND_ACCESS
1444  *		SCF_ERROR_CONSTRAINT_VIOLATED
1445  *		SCF_ERROR_TYPE_MISMATCH
1446  */
1447 int
1448 scf_read_count_property(
1449 	scf_simple_handle_t	*simple_h,
1450 	char			*prop_name,
1451 	uint64_t		*ret_count)
1452 {
1453 	scf_property_t		*prop = scf_property_create(simple_h->h);
1454 	scf_value_t		*val = scf_value_create(simple_h->h);
1455 	int			ret = SCF_FAILED;
1456 
1457 	if ((val == NULL) || (prop == NULL)) {
1458 		goto out;
1459 	}
1460 
1461 	/*
1462 	 * Get the property struct that goes with this property group and
1463 	 * property name.
1464 	 */
1465 	if (scf_pg_get_property(simple_h->running_pg, prop_name, prop) != 0) {
1466 		goto out;
1467 	}
1468 
1469 	/* Get the value structure */
1470 	if (scf_property_get_value(prop, val) == -1) {
1471 		goto out;
1472 	}
1473 
1474 	/*
1475 	 * Now get the count value.
1476 	 */
1477 	if (scf_value_get_count(val, ret_count) == -1) {
1478 		goto out;
1479 	}
1480 
1481 	ret = SCF_SUCCESS;
1482 
1483 out:
1484 	scf_property_destroy(prop);
1485 	scf_value_destroy(val);
1486 	return (ret);
1487 }
1488 
1489 /*
1490  * scf_trans_add_count_property(trans, propname, count, create_flag)
1491  *
1492  * Set a count property transaction entry into the pending SMF transaction.
1493  * The transaction is created and committed outside of this function.
1494  * Returns:
1495  *	SCF_SUCCESS
1496  *	SCF_FAILED on failure with scf_error() set to:
1497  *			SCF_ERROR_HANDLE_DESTROYED,
1498  *			SCF_ERROR_INVALID_ARGUMENT,
1499  *			SCF_ERROR_NO_MEMORY,
1500  *			SCF_ERROR_HANDLE_MISMATCH,
1501  *			SCF_ERROR_NOT_SET,
1502  *			SCF_ERROR_IN_USE,
1503  *			SCF_ERROR_NOT_FOUND,
1504  *			SCF_ERROR_EXISTS,
1505  *			SCF_ERROR_TYPE_MISMATCH,
1506  *			SCF_ERROR_NOT_BOUND,
1507  *			SCF_ERROR_CONNECTION_BROKEN,
1508  *			SCF_ERROR_INTERNAL,
1509  *			SCF_ERROR_DELETED,
1510  *			SCF_ERROR_NO_RESOURCES,
1511  *			SCF_ERROR_BACKEND_ACCESS
1512  */
1513 int
1514 scf_set_count_property(
1515 	scf_transaction_t	*trans,
1516 	char			*propname,
1517 	uint64_t		count,
1518 	boolean_t		create_flag)
1519 {
1520 	scf_handle_t		*handle = scf_transaction_handle(trans);
1521 	scf_value_t		*value = scf_value_create(handle);
1522 	scf_transaction_entry_t	*entry = scf_entry_create(handle);
1523 
1524 	if ((value == NULL) || (entry == NULL)) {
1525 		return (SCF_FAILED);
1526 	}
1527 
1528 	/*
1529 	 * Property must be set in transaction and won't take
1530 	 * effect until the transaction is committed.
1531 	 *
1532 	 * Attempt to change the current value. However, create new property
1533 	 * if it doesn't exist and the create flag is set.
1534 	 */
1535 	if (scf_transaction_property_change(trans, entry, propname,
1536 	    SCF_TYPE_COUNT) == 0) {
1537 		scf_value_set_count(value, count);
1538 		if (scf_entry_add_value(entry, value) == 0) {
1539 			return (SCF_SUCCESS);
1540 		}
1541 	} else {
1542 		if ((create_flag == B_TRUE) &&
1543 		    (scf_error() == SCF_ERROR_NOT_FOUND)) {
1544 			if (scf_transaction_property_new(trans, entry, propname,
1545 			    SCF_TYPE_COUNT) == 0) {
1546 				scf_value_set_count(value, count);
1547 				if (scf_entry_add_value(entry, value) == 0) {
1548 					return (SCF_SUCCESS);
1549 				}
1550 			}
1551 		}
1552 	}
1553 
1554 	/*
1555 	 * cleanup if there were any errors that didn't leave these
1556 	 * values where they would be cleaned up later.
1557 	 */
1558 	if (value != NULL)
1559 		scf_value_destroy(value);
1560 	if (entry != NULL)
1561 		scf_entry_destroy(entry);
1562 	return (SCF_FAILED);
1563 }
1564 
1565 int
1566 scf_simple_walk_instances(uint_t state_flags, void *private,
1567     int (*inst_callback)(scf_handle_t *, scf_instance_t *, void *))
1568 {
1569 	scf_scope_t 		*scope = NULL;
1570 	scf_service_t		*svc = NULL;
1571 	scf_instance_t		*inst = NULL;
1572 	scf_iter_t		*svc_iter = NULL, *inst_iter = NULL;
1573 	scf_handle_t		*h = NULL;
1574 	int			ret = SCF_FAILED;
1575 	int			svc_iter_ret, inst_iter_ret;
1576 	int			inst_state;
1577 
1578 	if ((h = _scf_handle_create_and_bind(SCF_VERSION)) == NULL)
1579 		return (ret);
1580 
1581 	if (((scope = scf_scope_create(h)) == NULL) ||
1582 	    ((svc = scf_service_create(h)) == NULL) ||
1583 	    ((inst = scf_instance_create(h)) == NULL) ||
1584 	    ((svc_iter = scf_iter_create(h)) == NULL) ||
1585 	    ((inst_iter = scf_iter_create(h)) == NULL))
1586 		goto out;
1587 
1588 	/*
1589 	 * Get the local scope, and set up nested iteration through every
1590 	 * local service, and every instance of every service.
1591 	 */
1592 
1593 	if ((scf_handle_get_local_scope(h, scope) != SCF_SUCCESS) ||
1594 	    (scf_iter_scope_services(svc_iter, scope) != SCF_SUCCESS))
1595 		goto out;
1596 
1597 	while ((svc_iter_ret = scf_iter_next_service(svc_iter, svc)) > 0) {
1598 
1599 		if ((scf_iter_service_instances(inst_iter, svc)) !=
1600 		    SCF_SUCCESS)
1601 			goto out;
1602 
1603 		while ((inst_iter_ret =
1604 		    scf_iter_next_instance(inst_iter, inst)) > 0) {
1605 			/*
1606 			 * If get_inst_state fails from an internal error,
1607 			 * IE, being unable to get the property group or
1608 			 * property containing the state of the instance,
1609 			 * we continue instead of failing, as this might just
1610 			 * be an improperly configured instance.
1611 			 */
1612 			if ((inst_state = get_inst_state(inst, h)) == -1) {
1613 				if (scf_error() == SCF_ERROR_INTERNAL) {
1614 					continue;
1615 				} else {
1616 					goto out;
1617 				}
1618 			}
1619 
1620 			if ((uint_t)inst_state & state_flags) {
1621 				if (inst_callback(h, inst, private) !=
1622 				    SCF_SUCCESS) {
1623 					(void) scf_set_error(
1624 					    SCF_ERROR_CALLBACK_FAILED);
1625 					goto out;
1626 				}
1627 			}
1628 		}
1629 
1630 		if (inst_iter_ret == -1)
1631 			goto out;
1632 		scf_iter_reset(inst_iter);
1633 	}
1634 
1635 	if (svc_iter_ret != -1)
1636 		ret = SCF_SUCCESS;
1637 
1638 out:
1639 	scf_scope_destroy(scope);
1640 	scf_service_destroy(svc);
1641 	scf_instance_destroy(inst);
1642 	scf_iter_destroy(svc_iter);
1643 	scf_iter_destroy(inst_iter);
1644 	scf_handle_destroy(h);
1645 
1646 	return (ret);
1647 }
1648 
1649 
1650 scf_simple_prop_t *
1651 scf_simple_prop_get(scf_handle_t *hin, const char *instance, const char *pgname,
1652 			const char *propname)
1653 {
1654 	char 			*fmri_buf, *svcfmri = NULL;
1655 	ssize_t 		fmri_sz;
1656 	scf_property_t 		*prop = NULL;
1657 	scf_service_t 		*svc = NULL;
1658 	scf_simple_prop_t 	*ret;
1659 	scf_handle_t		*h = NULL;
1660 	boolean_t		local_h = B_TRUE;
1661 
1662 	/* If the user passed in a handle, use it. */
1663 	if (hin != NULL) {
1664 		h = hin;
1665 		local_h = B_FALSE;
1666 	}
1667 
1668 	if (local_h && ((h = _scf_handle_create_and_bind(SCF_VERSION)) == NULL))
1669 		return (NULL);
1670 
1671 	if ((fmri_buf = assemble_fmri(h, instance, pgname, propname)) == NULL) {
1672 		if (local_h)
1673 			scf_handle_destroy(h);
1674 		return (NULL);
1675 	}
1676 
1677 	if ((svc = scf_service_create(h)) == NULL ||
1678 	    (prop = scf_property_create(h)) == NULL)
1679 		goto error1;
1680 	if (scf_handle_decode_fmri(h, fmri_buf, NULL, NULL, NULL, NULL, prop,
1681 	    SCF_DECODE_FMRI_REQUIRE_INSTANCE) == -1) {
1682 		switch (scf_error()) {
1683 		/*
1684 		 * If the property isn't found in the instance, we grab the
1685 		 * underlying service, create an FMRI out of it, and then
1686 		 * query the datastore again at the service level for the
1687 		 * property.
1688 		 */
1689 		case SCF_ERROR_NOT_FOUND:
1690 			if (scf_handle_decode_fmri(h, fmri_buf, NULL, svc,
1691 			    NULL, NULL, NULL, SCF_DECODE_FMRI_TRUNCATE) == -1)
1692 				goto error1;
1693 
1694 			fmri_sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH) + 1;
1695 			assert(fmri_sz > 0);
1696 
1697 			if (scf_service_to_fmri(svc, fmri_buf, fmri_sz) == -1)
1698 				goto error1;
1699 			if ((svcfmri = assemble_fmri(h, fmri_buf, pgname,
1700 			    propname)) == NULL)
1701 				goto error1;
1702 			if (scf_handle_decode_fmri(h, svcfmri, NULL, NULL,
1703 			    NULL, NULL, prop, 0) == -1) {
1704 				free(svcfmri);
1705 				goto error1;
1706 			}
1707 			free(svcfmri);
1708 			break;
1709 		case SCF_ERROR_CONSTRAINT_VIOLATED:
1710 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
1711 		default:
1712 			goto error1;
1713 		}
1714 	}
1715 	/*
1716 	 * At this point, we've successfully pulled the property from the
1717 	 * datastore, and simply need to copy its innards into an
1718 	 * scf_simple_prop_t.
1719 	 */
1720 	if ((ret = fill_prop(prop, pgname, propname, h)) == NULL)
1721 		goto error1;
1722 
1723 	scf_service_destroy(svc);
1724 	scf_property_destroy(prop);
1725 	free(fmri_buf);
1726 	if (local_h)
1727 		scf_handle_destroy(h);
1728 	return (ret);
1729 
1730 	/*
1731 	 * Exit point for a successful call.  Below this line are exit points
1732 	 * for failures at various stages during the function.
1733 	 */
1734 
1735 error1:
1736 	scf_service_destroy(svc);
1737 	scf_property_destroy(prop);
1738 error2:
1739 	free(fmri_buf);
1740 	if (local_h)
1741 		scf_handle_destroy(h);
1742 	return (NULL);
1743 }
1744 
1745 
1746 void
1747 scf_simple_prop_free(scf_simple_prop_t *prop)
1748 {
1749 	int i;
1750 
1751 	if (prop == NULL)
1752 		return;
1753 
1754 	free(prop->pr_propname);
1755 	free(prop->pr_pgname);
1756 	switch (prop->pr_type) {
1757 	case SCF_TYPE_OPAQUE: {
1758 		for (i = 0; i < prop->pr_numvalues; i++) {
1759 			free(prop->pr_vallist[i].pv_opaque.o_value);
1760 		}
1761 		break;
1762 	}
1763 	case SCF_TYPE_ASTRING:
1764 	case SCF_TYPE_USTRING:
1765 	case SCF_TYPE_HOST:
1766 	case SCF_TYPE_HOSTNAME:
1767 	case SCF_TYPE_NET_ADDR:
1768 	case SCF_TYPE_NET_ADDR_V4:
1769 	case SCF_TYPE_NET_ADDR_V6:
1770 	case SCF_TYPE_URI:
1771 	case SCF_TYPE_FMRI: {
1772 		for (i = 0; i < prop->pr_numvalues; i++) {
1773 			free(prop->pr_vallist[i].pv_str);
1774 		}
1775 		break;
1776 	}
1777 	default:
1778 		break;
1779 	}
1780 	free(prop->pr_vallist);
1781 	free(prop);
1782 }
1783 
1784 
1785 scf_simple_app_props_t *
1786 scf_simple_app_props_get(scf_handle_t *hin, const char *inst_fmri)
1787 {
1788 	scf_instance_t 		*inst = NULL;
1789 	scf_service_t 		*svc = NULL;
1790 	scf_propertygroup_t 	*pg = NULL;
1791 	scf_property_t 		*prop = NULL;
1792 	scf_simple_app_props_t	*ret = NULL;
1793 	scf_iter_t		*pgiter = NULL, *propiter = NULL;
1794 	struct scf_simple_pg	*thispg = NULL, *nextpg;
1795 	scf_simple_prop_t	*thisprop, *nextprop;
1796 	scf_handle_t		*h = NULL;
1797 	int			pgiter_ret, propiter_ret;
1798 	ssize_t			namelen;
1799 	char 			*propname = NULL, *pgname = NULL, *sys_fmri;
1800 	uint8_t			found;
1801 	boolean_t		local_h = B_TRUE;
1802 
1803 	/* If the user passed in a handle, use it. */
1804 	if (hin != NULL) {
1805 		h = hin;
1806 		local_h = B_FALSE;
1807 	}
1808 
1809 	if (local_h && ((h = _scf_handle_create_and_bind(SCF_VERSION)) == NULL))
1810 		return (NULL);
1811 
1812 	if (inst_fmri == NULL) {
1813 		if ((namelen = scf_myname(h, NULL, 0)) == -1) {
1814 			if (local_h)
1815 				scf_handle_destroy(h);
1816 			return (NULL);
1817 		}
1818 		if ((sys_fmri = malloc(namelen + 1)) == NULL) {
1819 			if (local_h)
1820 				scf_handle_destroy(h);
1821 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1822 			return (NULL);
1823 		}
1824 		if (scf_myname(h, sys_fmri, namelen + 1) == -1) {
1825 			if (local_h)
1826 				scf_handle_destroy(h);
1827 			free(sys_fmri);
1828 			return (NULL);
1829 		}
1830 	} else {
1831 		if ((sys_fmri = strdup(inst_fmri)) == NULL) {
1832 			if (local_h)
1833 				scf_handle_destroy(h);
1834 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1835 			return (NULL);
1836 		}
1837 	}
1838 
1839 	namelen = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
1840 	assert(namelen > 0);
1841 
1842 	if ((inst = scf_instance_create(h)) == NULL ||
1843 	    (svc = scf_service_create(h)) == NULL ||
1844 	    (pgiter = scf_iter_create(h)) == NULL ||
1845 	    (propiter = scf_iter_create(h)) == NULL ||
1846 	    (pg = scf_pg_create(h)) == NULL ||
1847 	    (prop = scf_property_create(h)) == NULL) {
1848 		free(sys_fmri);
1849 		goto error2;
1850 	}
1851 
1852 	if (scf_handle_decode_fmri(h, sys_fmri, NULL, svc, inst, NULL, NULL,
1853 	    SCF_DECODE_FMRI_REQUIRE_INSTANCE) == -1) {
1854 		free(sys_fmri);
1855 		if (scf_error() == SCF_ERROR_CONSTRAINT_VIOLATED)
1856 			(void) scf_set_error(SCF_ERROR_INVALID_ARGUMENT);
1857 		goto error2;
1858 	}
1859 
1860 	if ((ret = malloc(sizeof (*ret))) == NULL ||
1861 	    (thispg = malloc(sizeof (*thispg))) == NULL ||
1862 	    (propname = malloc(namelen)) == NULL ||
1863 	    (pgname = malloc(namelen)) == NULL) {
1864 		free(thispg);
1865 		free(ret);
1866 		free(sys_fmri);
1867 		(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1868 		goto error2;
1869 	}
1870 
1871 	ret->ap_fmri = sys_fmri;
1872 	thispg->pg_name = NULL;
1873 	thispg->pg_proplist = NULL;
1874 	thispg->pg_next = NULL;
1875 	ret->ap_pglist = thispg;
1876 
1877 	if (scf_iter_service_pgs_typed(pgiter, svc, SCF_GROUP_APPLICATION) !=
1878 	    0) {
1879 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
1880 			(void) scf_set_error(SCF_ERROR_INTERNAL);
1881 		goto error1;
1882 	}
1883 
1884 	while ((pgiter_ret = scf_iter_next_pg(pgiter, pg)) == 1) {
1885 		if (thispg->pg_name != NULL) {
1886 			if ((nextpg = malloc(sizeof (*nextpg))) == NULL) {
1887 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1888 				goto error1;
1889 			}
1890 			nextpg->pg_name = NULL;
1891 			nextpg->pg_next = NULL;
1892 			nextpg->pg_proplist = NULL;
1893 			thispg->pg_next = nextpg;
1894 			thispg = nextpg;
1895 		} else {
1896 			/* This is the first iteration */
1897 			nextpg = thispg;
1898 		}
1899 
1900 		if ((nextpg->pg_name = malloc(namelen)) == NULL) {
1901 			(void) scf_set_error(SCF_ERROR_NO_MEMORY);
1902 			goto error1;
1903 		}
1904 
1905 		if (scf_pg_get_name(pg, nextpg->pg_name, namelen) < 0) {
1906 			if (scf_error() == SCF_ERROR_NOT_SET)
1907 				(void) scf_set_error(SCF_ERROR_INTERNAL);
1908 			goto error1;
1909 		}
1910 
1911 		thisprop = NULL;
1912 
1913 		scf_iter_reset(propiter);
1914 
1915 		if (scf_iter_pg_properties(propiter, pg) != 0) {
1916 			if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
1917 				(void) scf_set_error(SCF_ERROR_INTERNAL);
1918 			goto error1;
1919 		}
1920 
1921 		while ((propiter_ret = scf_iter_next_property(propiter, prop))
1922 		    == 1) {
1923 			if (scf_property_get_name(prop, propname, namelen) <
1924 			    0) {
1925 				if (scf_error() == SCF_ERROR_NOT_SET)
1926 					(void) scf_set_error(
1927 					    SCF_ERROR_INTERNAL);
1928 				goto error1;
1929 			}
1930 			if (thisprop != NULL) {
1931 				if ((nextprop = fill_prop(prop,
1932 				    nextpg->pg_name, propname, h)) == NULL)
1933 					goto error1;
1934 				thisprop->pr_next = nextprop;
1935 				thisprop = nextprop;
1936 			} else {
1937 				/* This is the first iteration */
1938 				if ((thisprop = fill_prop(prop,
1939 				    nextpg->pg_name, propname, h)) == NULL)
1940 					goto error1;
1941 				nextpg->pg_proplist = thisprop;
1942 				nextprop = thisprop;
1943 			}
1944 			nextprop->pr_pg = nextpg;
1945 			nextprop->pr_next = NULL;
1946 		}
1947 
1948 		if (propiter_ret == -1) {
1949 			if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
1950 				(void) scf_set_error(SCF_ERROR_INTERNAL);
1951 			goto error1;
1952 		}
1953 	}
1954 
1955 	if (pgiter_ret == -1) {
1956 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
1957 			(void) scf_set_error(SCF_ERROR_INTERNAL);
1958 		goto error1;
1959 	}
1960 
1961 	/*
1962 	 * At this point, we've filled the scf_simple_app_props_t with all the
1963 	 * properties at the service level.  Now we iterate over all the
1964 	 * properties at the instance level, overwriting any duplicate
1965 	 * properties, in order to provide service/instance composition.
1966 	 */
1967 
1968 	scf_iter_reset(pgiter);
1969 	scf_iter_reset(propiter);
1970 
1971 	if (scf_iter_instance_pgs_typed(pgiter, inst, SCF_GROUP_APPLICATION)
1972 	    != 0) {
1973 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
1974 			(void) scf_set_error(SCF_ERROR_INTERNAL);
1975 		goto error1;
1976 	}
1977 
1978 	while ((pgiter_ret = scf_iter_next_pg(pgiter, pg)) == 1) {
1979 
1980 		thispg = ret->ap_pglist;
1981 		found = 0;
1982 
1983 		/*
1984 		 * Find either the end of the list, so we can append the
1985 		 * property group, or an existing property group that matches
1986 		 * it, so we can insert/overwrite its properties.
1987 		 */
1988 
1989 		if (scf_pg_get_name(pg, pgname, namelen) < 0) {
1990 			if (scf_error() == SCF_ERROR_NOT_SET)
1991 				(void) scf_set_error(SCF_ERROR_INTERNAL);
1992 			goto error1;
1993 		}
1994 
1995 		while ((thispg != NULL) && (thispg->pg_name != NULL)) {
1996 			if (strcmp(thispg->pg_name, pgname) == 0) {
1997 				found = 1;
1998 				break;
1999 			}
2000 			if (thispg->pg_next == NULL)
2001 				break;
2002 
2003 			thispg = thispg->pg_next;
2004 		}
2005 
2006 		scf_iter_reset(propiter);
2007 
2008 		if (scf_iter_pg_properties(propiter, pg) != 0) {
2009 			if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
2010 				(void) scf_set_error(SCF_ERROR_INTERNAL);
2011 			goto error1;
2012 		}
2013 
2014 		if (found) {
2015 			/*
2016 			 * insert_app_props inserts or overwrites the
2017 			 * properties in thispg.
2018 			 */
2019 
2020 			if (insert_app_props(propiter, pgname, propname,
2021 			    thispg, prop, namelen, h) == -1)
2022 				goto error1;
2023 
2024 		} else {
2025 			/*
2026 			 * If the property group wasn't found, we're adding
2027 			 * a newly allocated property group to the end of the
2028 			 * list.
2029 			 */
2030 
2031 			if ((nextpg = malloc(sizeof (*nextpg))) == NULL) {
2032 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
2033 				goto error1;
2034 			}
2035 			nextpg->pg_next = NULL;
2036 			nextpg->pg_proplist = NULL;
2037 			thisprop = NULL;
2038 
2039 			if ((nextpg->pg_name = strdup(pgname)) == NULL) {
2040 				(void) scf_set_error(SCF_ERROR_NO_MEMORY);
2041 				free(nextpg);
2042 				goto error1;
2043 			}
2044 
2045 			if (thispg->pg_name == NULL) {
2046 				free(thispg);
2047 				ret->ap_pglist = nextpg;
2048 			} else {
2049 				thispg->pg_next = nextpg;
2050 			}
2051 
2052 			while ((propiter_ret =
2053 			    scf_iter_next_property(propiter, prop)) == 1) {
2054 				if (scf_property_get_name(prop, propname,
2055 				    namelen) < 0) {
2056 					if (scf_error() == SCF_ERROR_NOT_SET)
2057 						(void) scf_set_error(
2058 						    SCF_ERROR_INTERNAL);
2059 					goto error1;
2060 				}
2061 				if (thisprop != NULL) {
2062 					if ((nextprop = fill_prop(prop,
2063 					    pgname, propname, h)) ==
2064 					    NULL)
2065 						goto error1;
2066 					thisprop->pr_next = nextprop;
2067 					thisprop = nextprop;
2068 				} else {
2069 					/* This is the first iteration */
2070 					if ((thisprop = fill_prop(prop,
2071 					    pgname, propname, h)) ==
2072 					    NULL)
2073 						goto error1;
2074 					nextpg->pg_proplist = thisprop;
2075 					nextprop = thisprop;
2076 				}
2077 				nextprop->pr_pg = nextpg;
2078 				nextprop->pr_next = NULL;
2079 			}
2080 
2081 			if (propiter_ret == -1) {
2082 				if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
2083 					(void) scf_set_error(
2084 					    SCF_ERROR_INTERNAL);
2085 				goto error1;
2086 			}
2087 		}
2088 
2089 	}
2090 
2091 	if (pgiter_ret == -1) {
2092 		if (scf_error() != SCF_ERROR_CONNECTION_BROKEN)
2093 			(void) scf_set_error(SCF_ERROR_INTERNAL);
2094 		goto error1;
2095 	}
2096 
2097 	if (ret->ap_pglist->pg_name == NULL)
2098 		goto error1;
2099 
2100 	scf_iter_destroy(pgiter);
2101 	scf_iter_destroy(propiter);
2102 	scf_pg_destroy(pg);
2103 	scf_property_destroy(prop);
2104 	scf_instance_destroy(inst);
2105 	scf_service_destroy(svc);
2106 	free(propname);
2107 	free(pgname);
2108 	if (local_h)
2109 		scf_handle_destroy(h);
2110 
2111 	return (ret);
2112 
2113 	/*
2114 	 * Exit point for a successful call.  Below this line are exit points
2115 	 * for failures at various stages during the function.
2116 	 */
2117 
2118 error1:
2119 	scf_simple_app_props_free(ret);
2120 
2121 error2:
2122 	scf_iter_destroy(pgiter);
2123 	scf_iter_destroy(propiter);
2124 	scf_pg_destroy(pg);
2125 	scf_property_destroy(prop);
2126 	scf_instance_destroy(inst);
2127 	scf_service_destroy(svc);
2128 	free(propname);
2129 	free(pgname);
2130 	if (local_h)
2131 		scf_handle_destroy(h);
2132 	return (NULL);
2133 }
2134 
2135 
2136 void
2137 scf_simple_app_props_free(scf_simple_app_props_t *propblock)
2138 {
2139 	struct scf_simple_pg 	*pgthis, *pgnext;
2140 	scf_simple_prop_t 	*propthis, *propnext;
2141 
2142 	if ((propblock == NULL) || (propblock->ap_pglist == NULL))
2143 		return;
2144 
2145 	for (pgthis = propblock->ap_pglist; pgthis != NULL; pgthis = pgnext) {
2146 		pgnext = pgthis->pg_next;
2147 
2148 		propthis = pgthis->pg_proplist;
2149 
2150 		while (propthis != NULL) {
2151 			propnext = propthis->pr_next;
2152 			scf_simple_prop_free(propthis);
2153 			propthis = propnext;
2154 		}
2155 
2156 		free(pgthis->pg_name);
2157 		free(pgthis);
2158 	}
2159 
2160 	free(propblock->ap_fmri);
2161 	free(propblock);
2162 }
2163 
2164 const scf_simple_prop_t *
2165 scf_simple_app_props_next(const scf_simple_app_props_t *propblock,
2166     scf_simple_prop_t *last)
2167 {
2168 	struct scf_simple_pg 	*this;
2169 
2170 	if (propblock == NULL) {
2171 		(void) scf_set_error(SCF_ERROR_NOT_SET);
2172 		return (NULL);
2173 	}
2174 
2175 	this = propblock->ap_pglist;
2176 
2177 	/*
2178 	 * We're looking for the first property in this block if last is
2179 	 * NULL
2180 	 */
2181 
2182 	if (last == NULL) {
2183 		/* An empty pglist is legal, it just means no properties */
2184 		if (this == NULL) {
2185 			(void) scf_set_error(SCF_ERROR_NONE);
2186 			return (NULL);
2187 		}
2188 		/*
2189 		 * Walk until we find a pg with a property in it, or we run
2190 		 * out of property groups.
2191 		 */
2192 		while ((this->pg_proplist == NULL) && (this->pg_next != NULL))
2193 			this = this->pg_next;
2194 
2195 		if (this->pg_proplist == NULL) {
2196 			(void) scf_set_error(SCF_ERROR_NONE);
2197 			return (NULL);
2198 		}
2199 
2200 		return (this->pg_proplist);
2201 
2202 	}
2203 	/*
2204 	 * If last isn't NULL, then return the next prop in the property group,
2205 	 * or walk the property groups until we find another property, or
2206 	 * run out of property groups.
2207 	 */
2208 	if (last->pr_next != NULL)
2209 		return (last->pr_next);
2210 
2211 	if (last->pr_pg->pg_next == NULL) {
2212 		(void) scf_set_error(SCF_ERROR_NONE);
2213 		return (NULL);
2214 	}
2215 
2216 	this = last->pr_pg->pg_next;
2217 
2218 	while ((this->pg_proplist == NULL) && (this->pg_next != NULL))
2219 		this = this->pg_next;
2220 
2221 	if (this->pg_proplist == NULL) {
2222 		(void) scf_set_error(SCF_ERROR_NONE);
2223 		return (NULL);
2224 	}
2225 
2226 	return (this->pg_proplist);
2227 }
2228 
2229 const scf_simple_prop_t *
2230 scf_simple_app_props_search(const scf_simple_app_props_t *propblock,
2231     const char *pgname, const char *propname)
2232 {
2233 	struct scf_simple_pg 	*pg;
2234 	scf_simple_prop_t 	*prop;
2235 
2236 	if ((propblock == NULL) || (propname == NULL)) {
2237 		(void) scf_set_error(SCF_ERROR_NOT_SET);
2238 		return (NULL);
2239 	}
2240 
2241 	pg = propblock->ap_pglist;
2242 
2243 	/*
2244 	 * If pgname is NULL, we're searching the default application
2245 	 * property group, otherwise we look for the specified group.
2246 	 */
2247 	if (pgname == NULL) {
2248 		while ((pg != NULL) &&
2249 		    (strcmp(SCF_PG_APP_DEFAULT, pg->pg_name) != 0))
2250 			pg = pg->pg_next;
2251 	} else {
2252 		while ((pg != NULL) && (strcmp(pgname, pg->pg_name) != 0))
2253 			pg = pg->pg_next;
2254 	}
2255 
2256 	if (pg == NULL) {
2257 		(void) scf_set_error(SCF_ERROR_NOT_FOUND);
2258 		return (NULL);
2259 	}
2260 
2261 	prop = pg->pg_proplist;
2262 
2263 	while ((prop != NULL) && (strcmp(propname, prop->pr_propname) != 0))
2264 		prop = prop->pr_next;
2265 
2266 	if (prop == NULL) {
2267 		(void) scf_set_error(SCF_ERROR_NOT_FOUND);
2268 		return (NULL);
2269 	}
2270 
2271 	return (prop);
2272 }
2273 
2274 void
2275 scf_simple_prop_next_reset(scf_simple_prop_t *prop)
2276 {
2277 	if (prop == NULL)
2278 		return;
2279 	prop->pr_iter = 0;
2280 }
2281 
2282 ssize_t
2283 scf_simple_prop_numvalues(const scf_simple_prop_t *prop)
2284 {
2285 	if (prop == NULL)
2286 		return (scf_set_error(SCF_ERROR_NOT_SET));
2287 
2288 	return (prop->pr_numvalues);
2289 }
2290 
2291 
2292 scf_type_t
2293 scf_simple_prop_type(const scf_simple_prop_t *prop)
2294 {
2295 	if (prop == NULL)
2296 		return (scf_set_error(SCF_ERROR_NOT_SET));
2297 
2298 	return (prop->pr_type);
2299 }
2300 
2301 
2302 char *
2303 scf_simple_prop_name(const scf_simple_prop_t *prop)
2304 {
2305 	if ((prop == NULL) || (prop->pr_propname == NULL)) {
2306 		(void) scf_set_error(SCF_ERROR_NOT_SET);
2307 		return (NULL);
2308 	}
2309 
2310 	return (prop->pr_propname);
2311 }
2312 
2313 
2314 char *
2315 scf_simple_prop_pgname(const scf_simple_prop_t *prop)
2316 {
2317 	if ((prop == NULL) || (prop->pr_pgname == NULL)) {
2318 		(void) scf_set_error(SCF_ERROR_NOT_SET);
2319 		return (NULL);
2320 	}
2321 
2322 	return (prop->pr_pgname);
2323 }
2324 
2325 
2326 static union scf_simple_prop_val *
2327 scf_next_val(scf_simple_prop_t *prop, scf_type_t type)
2328 {
2329 	if (prop == NULL) {
2330 		(void) scf_set_error(SCF_ERROR_NOT_SET);
2331 		return (NULL);
2332 	}
2333 
2334 	switch (prop->pr_type) {
2335 	case SCF_TYPE_USTRING:
2336 	case SCF_TYPE_HOST:
2337 	case SCF_TYPE_HOSTNAME:
2338 	case SCF_TYPE_NET_ADDR:
2339 	case SCF_TYPE_NET_ADDR_V4:
2340 	case SCF_TYPE_NET_ADDR_V6:
2341 	case SCF_TYPE_URI:
2342 	case SCF_TYPE_FMRI: {
2343 		if (type != SCF_TYPE_USTRING) {
2344 			(void) scf_set_error(SCF_ERROR_TYPE_MISMATCH);
2345 			return (NULL);
2346 		}
2347 		break;
2348 		}
2349 	default: {
2350 		if (type != prop->pr_type) {
2351 			(void) scf_set_error(SCF_ERROR_TYPE_MISMATCH);
2352 			return (NULL);
2353 		}
2354 		break;
2355 		}
2356 	}
2357 
2358 	if (prop->pr_iter >= prop->pr_numvalues) {
2359 		(void) scf_set_error(SCF_ERROR_NONE);
2360 		return (NULL);
2361 	}
2362 
2363 	return (&prop->pr_vallist[prop->pr_iter++]);
2364 }
2365 
2366 
2367 uint8_t *
2368 scf_simple_prop_next_boolean(scf_simple_prop_t *prop)
2369 {
2370 	union scf_simple_prop_val *ret;
2371 
2372 	ret = scf_next_val(prop, SCF_TYPE_BOOLEAN);
2373 
2374 	if (ret == NULL)
2375 		return (NULL);
2376 
2377 	return (&ret->pv_bool);
2378 }
2379 
2380 
2381 uint64_t *
2382 scf_simple_prop_next_count(scf_simple_prop_t *prop)
2383 {
2384 	union scf_simple_prop_val *ret;
2385 
2386 	ret = scf_next_val(prop, SCF_TYPE_COUNT);
2387 
2388 	if (ret == NULL)
2389 		return (NULL);
2390 
2391 	return (&ret->pv_uint);
2392 }
2393 
2394 
2395 int64_t *
2396 scf_simple_prop_next_integer(scf_simple_prop_t *prop)
2397 {
2398 	union scf_simple_prop_val *ret;
2399 
2400 	ret = scf_next_val(prop, SCF_TYPE_INTEGER);
2401 
2402 	if (ret == NULL)
2403 		return (NULL);
2404 
2405 	return (&ret->pv_int);
2406 }
2407 
2408 int64_t *
2409 scf_simple_prop_next_time(scf_simple_prop_t *prop, int32_t *nsec)
2410 {
2411 	union scf_simple_prop_val *ret;
2412 
2413 	ret = scf_next_val(prop, SCF_TYPE_TIME);
2414 
2415 	if (ret == NULL)
2416 		return (NULL);
2417 
2418 	if (nsec != NULL)
2419 		*nsec = ret->pv_time.t_nsec;
2420 
2421 	return (&ret->pv_time.t_sec);
2422 }
2423 
2424 char *
2425 scf_simple_prop_next_astring(scf_simple_prop_t *prop)
2426 {
2427 	union scf_simple_prop_val *ret;
2428 
2429 	ret = scf_next_val(prop, SCF_TYPE_ASTRING);
2430 
2431 	if (ret == NULL)
2432 		return (NULL);
2433 
2434 	return (ret->pv_str);
2435 }
2436 
2437 char *
2438 scf_simple_prop_next_ustring(scf_simple_prop_t *prop)
2439 {
2440 	union scf_simple_prop_val *ret;
2441 
2442 	ret = scf_next_val(prop, SCF_TYPE_USTRING);
2443 
2444 	if (ret == NULL)
2445 		return (NULL);
2446 
2447 	return (ret->pv_str);
2448 }
2449 
2450 void *
2451 scf_simple_prop_next_opaque(scf_simple_prop_t *prop, size_t *length)
2452 {
2453 	union scf_simple_prop_val *ret;
2454 
2455 	ret = scf_next_val(prop, SCF_TYPE_OPAQUE);
2456 
2457 	if (ret == NULL) {
2458 		*length = 0;
2459 		return (NULL);
2460 	}
2461 
2462 	*length = ret->pv_opaque.o_size;
2463 	return (ret->pv_opaque.o_value);
2464 }
2465 
2466 /*
2467  * Generate a filename based on the fmri and the given name and return
2468  * it in the buffer of MAXPATHLEN provided by the caller.
2469  * If temp_filename is non-zero, also generate a temporary, unique filename
2470  * and return it in the temp buffer of MAXPATHLEN provided by the caller.
2471  * The path to the generated pathname is also created.
2472  * Given fmri should begin with a scheme such as "svc:".
2473  * Returns
2474  *      0 on success
2475  *      -1 if filename would exceed MAXPATHLEN or
2476  *	-2 if unable to create directory to filename path
2477  */
2478 int
2479 gen_filenms_from_fmri(const char *fmri, const char *name, char *filename,
2480     char *temp_filename)
2481 {
2482 	int		len;
2483 
2484 	len = strlen(SMF_SPEEDY_FILES_PATH);
2485 	len += strlen(fmri);
2486 	len += 2;			/* for slash and null */
2487 	len += strlen(name);
2488 	len += 6;			/* For X's needed for mkstemp */
2489 
2490 	if (len > MAXPATHLEN)
2491 		return (-1);
2492 
2493 	/* Construct directory name first - speedy path ends in slash */
2494 	(void) strcpy(filename, SMF_SPEEDY_FILES_PATH);
2495 	(void) strcat(filename, fmri);
2496 	if (mkdirp(filename, 0755) == -1) {
2497 		/* errno is set */
2498 		if (errno != EEXIST)
2499 			return (-2);
2500 	}
2501 
2502 	(void) strcat(filename, "/");
2503 	(void) strcat(filename, name);
2504 
2505 	if (temp_filename) {
2506 		(void) strcpy(temp_filename, filename);
2507 		(void) strcat(temp_filename, "XXXXXX");
2508 	}
2509 
2510 	return (0);
2511 }
2512 
2513 scf_type_t
2514 scf_true_base_type(scf_type_t type)
2515 {
2516 	scf_type_t base = type;
2517 
2518 	do {
2519 		type = base;
2520 		(void) scf_type_base_type(type, &base);
2521 	} while (base != type);
2522 
2523 	return (base);
2524 }
2525 
2526 /*
2527  * Convenience routine which frees all strings and opaque data
2528  * allocated by scf_read_propvec.
2529  *
2530  * Like free(3C), this function preserves the value of errno.
2531  */
2532 void
2533 scf_clean_propvec(scf_propvec_t *propvec)
2534 {
2535 	int saved_errno = errno;
2536 	scf_propvec_t *prop;
2537 
2538 	for (prop = propvec; prop->pv_prop != NULL; prop++) {
2539 		assert(prop->pv_type != SCF_TYPE_INVALID);
2540 		if (prop->pv_type == SCF_TYPE_OPAQUE) {
2541 			scf_opaque_t *o = prop->pv_ptr;
2542 
2543 			if (o->so_addr != NULL)
2544 				free(o->so_addr);
2545 		} else if (scf_true_base_type(prop->pv_type) ==
2546 		    SCF_TYPE_ASTRING) {
2547 			if (*(char **)prop->pv_ptr != NULL)
2548 				free(*(char **)prop->pv_ptr);
2549 		}
2550 	}
2551 
2552 	errno = saved_errno;
2553 }
2554 
2555 static int
2556 count_props(scf_propvec_t *props)
2557 {
2558 	int count = 0;
2559 
2560 	for (; props->pv_prop != NULL; props++)
2561 		count++;
2562 	return (count);
2563 }
2564 
2565 /*
2566  * Reads a vector of properties from the specified fmri/property group.
2567  * If 'running' is true, reads from the running snapshot instead of the
2568  * editing snapshot.
2569  *
2570  * For string types, a buffer is allocated using malloc(3C) to hold the
2571  * zero-terminated string, a pointer to which is stored in the
2572  * caller-provided char **.  It is the caller's responsbility to free
2573  * this string.  To simplify error handling, unread strings are
2574  * initialized to NULL.
2575  *
2576  * For opaque types, a buffer is allocated using malloc(3C) to hold the
2577  * opaque data.  A pointer to this buffer and its size are stored in
2578  * the caller-provided scf_opaque_t.  It is the caller's responsibility
2579  * to free this buffer.  To simplify error handling, the address fields
2580  * for unread opaque data are initialized to NULL.
2581  *
2582  * All other data is stored directly in caller-provided variables or
2583  * structures.
2584  *
2585  * If this function fails to read a specific property, *badprop is set
2586  * to point at that property's entry in the properties array.
2587  *
2588  * On all failures, all memory allocated by this function is freed.
2589  */
2590 int
2591 scf_read_propvec(const char *fmri, const char *pgname, boolean_t running,
2592     scf_propvec_t *properties, scf_propvec_t **badprop)
2593 {
2594 	scf_handle_t *h = _scf_handle_create_and_bind(SCF_VERSION);
2595 	scf_service_t *s = scf_service_create(h);
2596 	scf_instance_t *i = scf_instance_create(h);
2597 	scf_snapshot_t *snap = running ? scf_snapshot_create(h) : NULL;
2598 	scf_propertygroup_t *pg = scf_pg_create(h);
2599 	scf_property_t *p = scf_property_create(h);
2600 	scf_value_t *v = scf_value_create(h);
2601 	boolean_t instance = B_TRUE;
2602 	scf_propvec_t *prop;
2603 	int error = 0;
2604 
2605 	for (prop = properties; prop->pv_prop != NULL; prop++) {
2606 		if (prop->pv_type == SCF_TYPE_OPAQUE)
2607 			((scf_opaque_t *)prop->pv_ptr)->so_addr = NULL;
2608 		else if (scf_true_base_type(prop->pv_type) == SCF_TYPE_ASTRING)
2609 			*((char **)prop->pv_ptr) = NULL;
2610 	}
2611 
2612 	if (h == NULL || s == NULL || i == NULL || (running && snap == NULL) ||
2613 	    pg == NULL || p == NULL || v == NULL)
2614 		goto scferror;
2615 
2616 	if (scf_handle_decode_fmri(h, fmri, NULL, s, i, NULL, NULL, 0) == -1)
2617 		goto scferror;
2618 
2619 	if (scf_instance_to_fmri(i, NULL, 0) == -1) {
2620 		if (scf_error() != SCF_ERROR_NOT_SET)
2621 			goto scferror;
2622 		instance = B_FALSE;
2623 	}
2624 
2625 	if (running) {
2626 		if (!instance) {
2627 			error = SCF_ERROR_TYPE_MISMATCH;
2628 			goto out;
2629 		}
2630 
2631 		if (scf_instance_get_snapshot(i, "running", snap) !=
2632 		    SCF_SUCCESS)
2633 			goto scferror;
2634 	}
2635 
2636 	if ((instance ? scf_instance_get_pg_composed(i, snap, pgname, pg) :
2637 	    scf_service_get_pg(s, pgname, pg)) == -1)
2638 		goto scferror;
2639 
2640 	for (prop = properties; prop->pv_prop != NULL; prop++) {
2641 		int ret = 0;
2642 
2643 		if (scf_pg_get_property(pg, prop->pv_prop, p) == -1 ||
2644 		    scf_property_get_value(p, v) == -1) {
2645 			*badprop = prop;
2646 			goto scferror;
2647 		}
2648 		switch (prop->pv_type) {
2649 		case SCF_TYPE_BOOLEAN: {
2650 			uint8_t b;
2651 
2652 			ret = scf_value_get_boolean(v, &b);
2653 			if (ret == -1)
2654 				break;
2655 			if (prop->pv_aux != 0) {
2656 				uint64_t *bits = prop->pv_ptr;
2657 				*bits = b ? (*bits | prop->pv_aux) :
2658 				    (*bits & ~prop->pv_aux);
2659 			} else {
2660 				boolean_t *bool = prop->pv_ptr;
2661 				*bool = b ? B_TRUE : B_FALSE;
2662 			}
2663 			break;
2664 		}
2665 		case SCF_TYPE_COUNT:
2666 			ret = scf_value_get_count(v, prop->pv_ptr);
2667 			break;
2668 		case SCF_TYPE_INTEGER:
2669 			ret = scf_value_get_integer(v, prop->pv_ptr);
2670 			break;
2671 		case SCF_TYPE_TIME: {
2672 			scf_time_t *time = prop->pv_ptr;
2673 
2674 			ret = scf_value_get_time(v, &time->t_seconds,
2675 			    &time->t_ns);
2676 			break;
2677 		}
2678 		case SCF_TYPE_OPAQUE: {
2679 			scf_opaque_t *opaque = prop->pv_ptr;
2680 			ssize_t size = scf_value_get_opaque(v, NULL, 0);
2681 
2682 			if (size == -1) {
2683 				*badprop = prop;
2684 				goto scferror;
2685 			}
2686 			if ((opaque->so_addr = malloc(size)) == NULL) {
2687 				error = SCF_ERROR_NO_MEMORY;
2688 				goto out;
2689 			}
2690 			opaque->so_size = size;
2691 			ret = scf_value_get_opaque(v, opaque->so_addr, size);
2692 			break;
2693 		}
2694 		default: {
2695 			char *s;
2696 			ssize_t size;
2697 
2698 			assert(scf_true_base_type(prop->pv_type) ==
2699 			    SCF_TYPE_ASTRING);
2700 
2701 			size = scf_value_get_astring(v, NULL, 0);
2702 			if (size == -1) {
2703 				*badprop = prop;
2704 				goto scferror;
2705 			}
2706 			if ((s = malloc(++size)) == NULL) {
2707 				error = SCF_ERROR_NO_MEMORY;
2708 				goto out;
2709 			}
2710 			ret = scf_value_get_astring(v, s, size);
2711 			*(char **)prop->pv_ptr = s;
2712 		}
2713 
2714 		if (ret == -1) {
2715 			*badprop = prop;
2716 			goto scferror;
2717 		}
2718 
2719 		}
2720 	}
2721 
2722 	goto out;
2723 
2724 scferror:
2725 	error = scf_error();
2726 	scf_clean_propvec(properties);
2727 
2728 out:
2729 	scf_value_destroy(v);
2730 	scf_property_destroy(p);
2731 	scf_pg_destroy(pg);
2732 	scf_snapshot_destroy(snap);
2733 	scf_instance_destroy(i);
2734 	scf_service_destroy(s);
2735 	scf_handle_destroy(h);
2736 
2737 	if (error != 0) {
2738 		(void) scf_set_error(error);
2739 		return (SCF_FAILED);
2740 	}
2741 
2742 	return (SCF_SUCCESS);
2743 }
2744 
2745 /*
2746  * Writes a vector of properties to the specified fmri/property group.
2747  *
2748  * If this function fails to write a specific property, *badprop is set
2749  * to point at that property's entry in the properties array.
2750  *
2751  * One significant difference between this function and the
2752  * scf_read_propvec function is that for string types, pv_ptr is a
2753  * char *, not a char **.  This means that you can't write a propvec
2754  * you just read, but makes other uses (hopefully the majority) simpler.
2755  */
2756 int
2757 scf_write_propvec(const char *fmri, const char *pgname,
2758     scf_propvec_t *properties, scf_propvec_t **badprop)
2759 {
2760 	scf_handle_t *h = _scf_handle_create_and_bind(SCF_VERSION);
2761 	scf_service_t *s = scf_service_create(h);
2762 	scf_instance_t *inst = scf_instance_create(h);
2763 	scf_snapshot_t *snap = scf_snapshot_create(h);
2764 	scf_propertygroup_t *pg = scf_pg_create(h);
2765 	scf_property_t *p = scf_property_create(h);
2766 	scf_transaction_t *tx = scf_transaction_create(h);
2767 	scf_value_t **v = NULL;
2768 	scf_transaction_entry_t **e = NULL;
2769 	boolean_t instance = B_TRUE;
2770 	int i, n;
2771 	scf_propvec_t *prop;
2772 	int error = 0, ret;
2773 
2774 	n = count_props(properties);
2775 	v = calloc(n, sizeof (scf_value_t *));
2776 	e = calloc(n, sizeof (scf_transaction_entry_t *));
2777 
2778 	if (v == NULL || e == NULL) {
2779 		error = SCF_ERROR_NO_MEMORY;
2780 		goto out;
2781 	}
2782 
2783 	if (h == NULL || s == NULL || inst == NULL || pg == NULL || p == NULL ||
2784 	    tx == NULL)
2785 		goto scferror;
2786 
2787 	for (i = 0; i < n; i++) {
2788 		v[i] = scf_value_create(h);
2789 		e[i] = scf_entry_create(h);
2790 		if (v[i] == NULL || e[i] == NULL)
2791 			goto scferror;
2792 	}
2793 
2794 	if (scf_handle_decode_fmri(h, fmri, NULL, s, inst, NULL, NULL, 0)
2795 	    != SCF_SUCCESS)
2796 		goto scferror;
2797 
2798 	if (scf_instance_to_fmri(inst, NULL, 0) == -1) {
2799 		if (scf_error() != SCF_ERROR_NOT_SET)
2800 			goto scferror;
2801 		instance = B_FALSE;
2802 	}
2803 
2804 	if ((instance ? scf_instance_get_pg(inst, pgname, pg) :
2805 	    scf_service_get_pg(s, pgname, pg)) == -1)
2806 		goto scferror;
2807 
2808 top:
2809 	if (scf_transaction_start(tx, pg) == -1)
2810 		goto scferror;
2811 
2812 	for (prop = properties, i = 0; prop->pv_prop != NULL; prop++, i++) {
2813 		ret = scf_transaction_property_change(tx, e[i], prop->pv_prop,
2814 		    prop->pv_type);
2815 		if (ret == -1 && scf_error() == SCF_ERROR_NOT_FOUND)
2816 			ret = scf_transaction_property_new(tx, e[i],
2817 			    prop->pv_prop, prop->pv_type);
2818 
2819 		if (ret == -1) {
2820 			*badprop = prop;
2821 			goto scferror;
2822 		}
2823 
2824 		switch (prop->pv_type) {
2825 		case SCF_TYPE_BOOLEAN: {
2826 			boolean_t b = (prop->pv_aux != 0) ?
2827 			    (*(uint64_t *)prop->pv_ptr & prop->pv_aux) != 0 :
2828 			    *(boolean_t *)prop->pv_ptr;
2829 
2830 			scf_value_set_boolean(v[i], b ? 1 : 0);
2831 			break;
2832 		}
2833 		case SCF_TYPE_COUNT:
2834 			scf_value_set_count(v[i], *(uint64_t *)prop->pv_ptr);
2835 			break;
2836 		case SCF_TYPE_INTEGER:
2837 			scf_value_set_integer(v[i], *(int64_t *)prop->pv_ptr);
2838 			break;
2839 		case SCF_TYPE_TIME: {
2840 			scf_time_t *time = prop->pv_ptr;
2841 
2842 			ret = scf_value_set_time(v[i], time->t_seconds,
2843 			    time->t_ns);
2844 			break;
2845 		}
2846 		case SCF_TYPE_OPAQUE: {
2847 			scf_opaque_t *opaque = prop->pv_ptr;
2848 
2849 			ret = scf_value_set_opaque(v[i], opaque->so_addr,
2850 			    opaque->so_size);
2851 			break;
2852 		}
2853 		case SCF_TYPE_ASTRING:
2854 			ret = scf_value_set_astring(v[i],
2855 			    (const char *)prop->pv_ptr);
2856 			break;
2857 		default:
2858 			ret = scf_value_set_from_string(v[i], prop->pv_type,
2859 			    (const char *)prop->pv_ptr);
2860 		}
2861 
2862 		if (ret == -1 || scf_entry_add_value(e[i], v[i]) == -1) {
2863 			*badprop = prop;
2864 			goto scferror;
2865 		}
2866 	}
2867 
2868 	ret = scf_transaction_commit(tx);
2869 	if (ret == 1)
2870 		goto out;
2871 
2872 	if (ret == 0 && scf_pg_update(pg) != -1) {
2873 		scf_transaction_reset(tx);
2874 		goto top;
2875 	}
2876 
2877 scferror:
2878 	error = scf_error();
2879 
2880 out:
2881 	if (v != NULL) {
2882 		for (i = 0; i < n; i++)
2883 			scf_value_destroy(v[i]);
2884 		free(v);
2885 	}
2886 
2887 	if (e != NULL) {
2888 		for (i = 0; i < n; i++)
2889 			scf_entry_destroy(e[i]);
2890 		free(e);
2891 	}
2892 
2893 	scf_transaction_destroy(tx);
2894 	scf_property_destroy(p);
2895 	scf_pg_destroy(pg);
2896 	scf_snapshot_destroy(snap);
2897 	scf_instance_destroy(inst);
2898 	scf_service_destroy(s);
2899 	scf_handle_destroy(h);
2900 
2901 	if (error != 0) {
2902 		(void) scf_set_error(error);
2903 		return (SCF_FAILED);
2904 	}
2905 
2906 	return (SCF_SUCCESS);
2907 }
2908 
2909 /*
2910  * Returns
2911  *   0 - success
2912  *   ECONNABORTED - repository connection broken
2913  *   ECANCELED - inst was deleted
2914  *   EPERM
2915  *   EACCES
2916  *   EROFS
2917  *   ENOMEM
2918  */
2919 int
2920 scf_instance_delete_prop(scf_instance_t *inst, const char *pgname,
2921     const char *pname)
2922 {
2923 	scf_handle_t *h;
2924 	scf_propertygroup_t *pg;
2925 	scf_transaction_t *tx;
2926 	scf_transaction_entry_t *e;
2927 	int error = 0, ret = 1, r;
2928 
2929 	h = scf_instance_handle(inst);
2930 
2931 	if ((pg = scf_pg_create(h)) == NULL) {
2932 		return (ENOMEM);
2933 	}
2934 
2935 	if (scf_instance_get_pg(inst, pgname, pg) != 0) {
2936 		error = scf_error();
2937 		scf_pg_destroy(pg);
2938 		switch (error) {
2939 		case SCF_ERROR_NOT_FOUND:
2940 			return (SCF_SUCCESS);
2941 
2942 		case SCF_ERROR_DELETED:
2943 			return (ECANCELED);
2944 
2945 		case SCF_ERROR_CONNECTION_BROKEN:
2946 		default:
2947 			return (ECONNABORTED);
2948 
2949 		case SCF_ERROR_NOT_SET:
2950 			bad_error("scf_instance_get_pg", scf_error());
2951 		}
2952 	}
2953 
2954 	tx = scf_transaction_create(h);
2955 	e = scf_entry_create(h);
2956 	if (tx == NULL || e == NULL) {
2957 		ret = ENOMEM;
2958 		goto out;
2959 	}
2960 
2961 	for (;;) {
2962 		if (scf_transaction_start(tx, pg) != 0) {
2963 			goto scferror;
2964 		}
2965 
2966 		if (scf_transaction_property_delete(tx, e, pname) != 0) {
2967 			goto scferror;
2968 		}
2969 
2970 		if ((r = scf_transaction_commit(tx)) == 1) {
2971 			ret = 0;
2972 			goto out;
2973 		}
2974 
2975 		if (r == -1) {
2976 			goto scferror;
2977 		}
2978 
2979 		scf_transaction_reset(tx);
2980 		if (scf_pg_update(pg) == -1) {
2981 			goto scferror;
2982 		}
2983 	}
2984 
2985 scferror:
2986 	switch (scf_error()) {
2987 	case SCF_ERROR_DELETED:
2988 	case SCF_ERROR_NOT_FOUND:
2989 		ret = 0;
2990 		break;
2991 
2992 	case SCF_ERROR_PERMISSION_DENIED:
2993 		ret = EPERM;
2994 		break;
2995 
2996 	case SCF_ERROR_BACKEND_ACCESS:
2997 		ret = EACCES;
2998 		break;
2999 
3000 	case SCF_ERROR_BACKEND_READONLY:
3001 		ret = EROFS;
3002 		break;
3003 
3004 	case SCF_ERROR_CONNECTION_BROKEN:
3005 	default:
3006 		ret = ECONNABORTED;
3007 		break;
3008 
3009 	case SCF_ERROR_HANDLE_MISMATCH:
3010 	case SCF_ERROR_INVALID_ARGUMENT:
3011 	case SCF_ERROR_NOT_BOUND:
3012 	case SCF_ERROR_NOT_SET:
3013 		bad_error("scf_instance_delete_prop", scf_error());
3014 	}
3015 
3016 out:
3017 	scf_transaction_destroy(tx);
3018 	scf_entry_destroy(e);
3019 	scf_pg_destroy(pg);
3020 
3021 	return (ret);
3022 }
3023 
3024 /*
3025  * Check the "application/auto_enable" property for the passed FMRI.
3026  * scf_simple_prop_get() should find the property on an instance
3027  * or on the service FMRI.  The routine returns:
3028  * -1: inconclusive (likely no such property or FMRI)
3029  *  0: auto_enable is false
3030  *  1: auto_enable is true
3031  */
3032 static int
3033 is_auto_enabled(char *fmri)
3034 {
3035 	scf_simple_prop_t *prop;
3036 	int retval = -1;
3037 	uint8_t *ret;
3038 
3039 	prop = scf_simple_prop_get(NULL, fmri, SCF_GROUP_APPLICATION,
3040 	    "auto_enable");
3041 	if (!prop)
3042 		return (retval);
3043 	ret = scf_simple_prop_next_boolean(prop);
3044 	retval = (*ret != 0);
3045 	scf_simple_prop_free(prop);
3046 	return (retval);
3047 }
3048 
3049 /*
3050  * Check an array of services and enable any that don't have the
3051  * "application/auto_enable" property set to "false", which is
3052  * the interface to turn off this behaviour (see PSARC 2004/739).
3053  */
3054 void
3055 _check_services(char **svcs)
3056 {
3057 	char *s;
3058 
3059 	for (; *svcs; svcs++) {
3060 		if (is_auto_enabled(*svcs) == 0)
3061 			continue;
3062 		if ((s = smf_get_state(*svcs)) != NULL) {
3063 			if (strcmp(SCF_STATE_STRING_DISABLED, s) == 0)
3064 				(void) smf_enable_instance(*svcs,
3065 				    SMF_TEMPORARY);
3066 			free(s);
3067 		}
3068 	}
3069 }
3070 
3071 /*ARGSUSED*/
3072 static int
3073 str_compare(const char *s1, const char *s2, size_t n)
3074 {
3075 	return (strcmp(s1, s2));
3076 }
3077 
3078 static int
3079 str_n_compare(const char *s1, const char *s2, size_t n)
3080 {
3081 	return (strncmp(s1, s2, n));
3082 }
3083 
3084 int32_t
3085 state_from_string(const char *state, size_t l)
3086 {
3087 	int (*str_cmp)(const char *, const char *, size_t);
3088 
3089 	if (l == 0)
3090 		str_cmp = str_compare;
3091 	else
3092 		str_cmp = str_n_compare;
3093 
3094 	if (str_cmp(SCF_STATE_STRING_UNINIT, state, l) == 0)
3095 		return (SCF_STATE_UNINIT);
3096 	else if (str_cmp(SCF_STATE_STRING_MAINT, state, l) == 0)
3097 		return (SCF_STATE_MAINT);
3098 	else if (str_cmp(SCF_STATE_STRING_OFFLINE, state, l) == 0)
3099 		return (SCF_STATE_OFFLINE);
3100 	else if (str_cmp(SCF_STATE_STRING_DISABLED, state, l) == 0)
3101 		return (SCF_STATE_DISABLED);
3102 	else if (str_cmp(SCF_STATE_STRING_ONLINE, state, l) == 0)
3103 		return (SCF_STATE_ONLINE);
3104 	else if (str_cmp(SCF_STATE_STRING_DEGRADED, state, l) == 0)
3105 		return (SCF_STATE_DEGRADED);
3106 	else if (str_cmp("all", state, l) == 0)
3107 		return (SCF_STATE_ALL);
3108 	else
3109 		return (-1);
3110 }
3111 
3112 /*
3113  * int32_t smf_state_from_string()
3114  * return the value of the macro SCF_STATE_* for the corresponding state
3115  * it returns SCF_STATE_ALL if "all" is passed. -1 if the string passed doesn't
3116  * correspond to any valid state.
3117  */
3118 int32_t
3119 smf_state_from_string(const char *state)
3120 {
3121 	return (state_from_string(state, 0));
3122 }
3123 
3124 /*
3125  * smf_state_to_string()
3126  * Takes an int32_t representing an SMF state and returns
3127  * the corresponding string. The string is read only and need not to be
3128  * freed.
3129  * returns NULL on invalid input.
3130  */
3131 const char *
3132 smf_state_to_string(int32_t s)
3133 {
3134 	switch (s) {
3135 	case SCF_STATE_UNINIT:
3136 		return (SCF_STATE_STRING_UNINIT);
3137 	case SCF_STATE_MAINT:
3138 		return (SCF_STATE_STRING_MAINT);
3139 	case SCF_STATE_OFFLINE:
3140 		return (SCF_STATE_STRING_OFFLINE);
3141 	case SCF_STATE_DISABLED:
3142 		return (SCF_STATE_STRING_DISABLED);
3143 	case SCF_STATE_ONLINE:
3144 		return (SCF_STATE_STRING_ONLINE);
3145 	case SCF_STATE_DEGRADED:
3146 		return (SCF_STATE_STRING_DEGRADED);
3147 	case SCF_STATE_ALL:
3148 		return ("all");
3149 	default:
3150 		return (NULL);
3151 	}
3152 }
3153