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