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