xref: /illumos-gate/usr/src/cmd/svc/svcadm/svcadm.c (revision 50c9b2fea77d0366c0f64a5e4cfd12d607abe6ba)
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  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright 2015, Joyent, Inc. All rights reserved.
28  */
29 
30 /*
31  * svcadm - request adminstrative actions for service instances
32  */
33 
34 #include <locale.h>
35 #include <libintl.h>
36 #include <libscf.h>
37 #include <libscf_priv.h>
38 #include <libcontract.h>
39 #include <libcontract_priv.h>
40 #include <sys/contract/process.h>
41 #include <libuutil.h>
42 #include <stddef.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #include <unistd.h>
47 #include <fcntl.h>
48 #include <procfs.h>
49 #include <assert.h>
50 #include <errno.h>
51 #include <zone.h>
52 
53 #ifndef TEXT_DOMAIN
54 #define	TEXT_DOMAIN	"SUNW_OST_OSCMD"
55 #endif /* TEXT_DOMAIN */
56 
57 /* Must be a power of two */
58 #define	HT_BUCKETS	64
59 
60 /*
61  * Exit codes for enable and disable -s.
62  */
63 #define	EXIT_SVC_FAILURE	3
64 #define	EXIT_DEP_FAILURE	4
65 
66 #define	WALK_FLAGS	(SCF_WALK_UNIPARTIAL | SCF_WALK_MULTIPLE)
67 
68 /*
69  * How long we will wait (in seconds) for a service to change state
70  * before re-checking its dependencies.
71  */
72 #define	WAIT_INTERVAL		3
73 
74 #define	bad_error(func, err)						\
75 	uu_panic("%s:%d: %s() failed with unexpected error %d.\n",	\
76 	    __FILE__, __LINE__, (func), (err));
77 
78 struct ht_elt {
79 	struct ht_elt	*next;
80 	boolean_t	active;
81 	char		str[1];
82 };
83 
84 
85 scf_handle_t *h;
86 ssize_t max_scf_fmri_sz;
87 static const char *emsg_permission_denied;
88 static const char *emsg_nomem;
89 static const char *emsg_create_pg_perm_denied;
90 static const char *emsg_pg_perm_denied;
91 static const char *emsg_prop_perm_denied;
92 static const char *emsg_no_service;
93 
94 static int exit_status = 0;
95 static int verbose = 0;
96 static char *scratch_fmri;
97 static char *g_zonename = NULL;
98 static char svcstate[80];
99 static boolean_t svcsearch = B_FALSE;
100 
101 static struct ht_elt **visited;
102 
103 void do_scfdie(int lineno) __NORETURN;
104 static void usage_milestone(void) __NORETURN;
105 static void set_astring_prop(const char *, const char *, const char *,
106     uint32_t, const char *, const char *);
107 static void pr_warn(const char *format, ...);
108 
109 /*
110  * Visitors from synch.c, needed for enable -s and disable -s.
111  */
112 extern int is_enabled(scf_instance_t *);
113 extern int has_potential(scf_instance_t *, int);
114 
115 void
116 do_scfdie(int lineno)
117 {
118 	scf_error_t err;
119 
120 	switch (err = scf_error()) {
121 	case SCF_ERROR_CONNECTION_BROKEN:
122 		uu_die(gettext("Connection to repository server broken.  "
123 		    "Exiting.\n"));
124 		/* NOTREACHED */
125 
126 	case SCF_ERROR_BACKEND_READONLY:
127 		uu_die(gettext("Repository is read-only.  Exiting.\n"));
128 		/* NOTREACHED */
129 
130 	default:
131 #ifdef NDEBUG
132 		uu_die(gettext("Unexpected libscf error: %s.  Exiting.\n"),
133 		    scf_strerror(err));
134 #else
135 		uu_die("Unexpected libscf error on line %d: %s.\n", lineno,
136 		    scf_strerror(err));
137 #endif
138 	}
139 }
140 
141 #define	scfdie()	do_scfdie(__LINE__)
142 
143 static void
144 usage()
145 {
146 	(void) fprintf(stderr, gettext(
147 	"Usage: %1$s [-S <state>] [-v] [-Z | -z zone] [cmd [args ... ]]\n\n"
148 	"\t%1$s enable [-rst] [<service> ...]\t- enable and online service(s)\n"
149 	"\t%1$s disable [-st] [<service> ...]\t- disable and offline "
150 	"service(s)\n"
151 	"\t%1$s restart [-d] [<service> ...]\t- restart specified service(s)\n"
152 	"\t%1$s refresh [<service> ...]\t\t- re-read service configuration\n"
153 	"\t%1$s mark [-It] <state> [<service> ...] - set maintenance state\n"
154 	"\t%1$s clear [<service> ...]\t\t- clear maintenance state\n"
155 	"\t%1$s milestone [-d] <milestone>\t- advance to a service milestone\n"
156 	"\n\t"
157 	"Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n"
158 	"\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n"
159 	"\n"
160 	"\t%1$s <cmd> svc:/network/smtp:sendmail\n"
161 	"\t%1$s <cmd> network/smtp:sendmail\n"
162 	"\t%1$s <cmd> network/*mail\n"
163 	"\t%1$s <cmd> network/smtp\n"
164 	"\t%1$s <cmd> smtp:sendmail\n"
165 	"\t%1$s <cmd> smtp\n"
166 	"\t%1$s <cmd> sendmail\n"), uu_getpname());
167 
168 	exit(UU_EXIT_USAGE);
169 }
170 
171 
172 /*
173  * FMRI hash table for recursive enable.
174  */
175 
176 static uint32_t
177 hash_fmri(const char *str)
178 {
179 	uint32_t h = 0, g;
180 	const char *p;
181 
182 	/* Generic hash function from uts/common/os/modhash.c . */
183 	for (p = str; *p != '\0'; ++p) {
184 		h = (h << 4) + *p;
185 		if ((g = (h & 0xf0000000)) != 0) {
186 			h ^= (g >> 24);
187 			h ^= g;
188 		}
189 	}
190 
191 	return (h);
192 }
193 
194 /*
195  * Return 1 if str has been visited, 0 if it has not, and -1 if memory could not
196  * be allocated.
197  */
198 static int
199 visited_find_or_add(const char *str, struct ht_elt **hep)
200 {
201 	uint32_t h;
202 	uint_t i;
203 	struct ht_elt *he;
204 
205 	h = hash_fmri(str);
206 	i = h & (HT_BUCKETS - 1);
207 
208 	for (he = visited[i]; he != NULL; he = he->next) {
209 		if (strcmp(he->str, str) == 0) {
210 			if (hep)
211 				*hep = he;
212 			return (1);
213 		}
214 	}
215 
216 	he = malloc(offsetof(struct ht_elt, str) + strlen(str) + 1);
217 	if (he == NULL)
218 		return (-1);
219 
220 	(void) strcpy(he->str, str);
221 
222 	he->next = visited[i];
223 	visited[i] = he;
224 
225 	if (hep)
226 		*hep = he;
227 	return (0);
228 }
229 
230 
231 /*
232  * Returns 0, ECANCELED if pg is deleted, ENOENT if propname doesn't exist,
233  * EINVAL if the property is not of boolean type or has no values, and E2BIG
234  * if it has more than one value.  *bp is set if 0 or E2BIG is returned.
235  */
236 int
237 get_bool_prop(scf_propertygroup_t *pg, const char *propname, uint8_t *bp)
238 {
239 	scf_property_t *prop;
240 	scf_value_t *val;
241 	int ret;
242 
243 	if ((prop = scf_property_create(h)) == NULL ||
244 	    (val = scf_value_create(h)) == NULL)
245 		scfdie();
246 
247 	if (scf_pg_get_property(pg, propname, prop) != 0) {
248 		switch (scf_error()) {
249 		case SCF_ERROR_DELETED:
250 			ret = ECANCELED;
251 			goto out;
252 
253 		case SCF_ERROR_NOT_FOUND:
254 			ret = ENOENT;
255 			goto out;
256 
257 		case SCF_ERROR_NOT_SET:
258 			assert(0);
259 			abort();
260 			/* NOTREACHED */
261 
262 		default:
263 			scfdie();
264 		}
265 	}
266 
267 	if (scf_property_get_value(prop, val) == 0) {
268 		ret = 0;
269 	} else {
270 		switch (scf_error()) {
271 		case SCF_ERROR_DELETED:
272 			ret = ENOENT;
273 			goto out;
274 
275 		case SCF_ERROR_NOT_FOUND:
276 			ret = EINVAL;
277 			goto out;
278 
279 		case SCF_ERROR_CONSTRAINT_VIOLATED:
280 			ret = E2BIG;
281 			break;
282 
283 		case SCF_ERROR_NOT_SET:
284 			assert(0);
285 			abort();
286 			/* NOTREACHED */
287 
288 		default:
289 			scfdie();
290 		}
291 	}
292 
293 	if (scf_value_get_boolean(val, bp) != 0) {
294 		if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
295 			scfdie();
296 
297 		ret = EINVAL;
298 		goto out;
299 	}
300 
301 out:
302 	scf_value_destroy(val);
303 	scf_property_destroy(prop);
304 	return (ret);
305 }
306 
307 /*
308  * Returns 0, EPERM, or EROFS.
309  */
310 static int
311 set_bool_prop(scf_propertygroup_t *pg, const char *propname, boolean_t b)
312 {
313 	scf_value_t *v;
314 	scf_transaction_t *tx;
315 	scf_transaction_entry_t *ent;
316 	int ret = 0, r;
317 
318 	if ((tx = scf_transaction_create(h)) == NULL ||
319 	    (ent = scf_entry_create(h)) == NULL ||
320 	    (v = scf_value_create(h)) == NULL)
321 		scfdie();
322 
323 	scf_value_set_boolean(v, b);
324 
325 	for (;;) {
326 		if (scf_transaction_start(tx, pg) == -1) {
327 			switch (scf_error()) {
328 			case SCF_ERROR_PERMISSION_DENIED:
329 				ret = EPERM;
330 				goto out;
331 
332 			case SCF_ERROR_BACKEND_READONLY:
333 				ret = EROFS;
334 				goto out;
335 
336 			default:
337 				scfdie();
338 			}
339 		}
340 
341 		if (scf_transaction_property_change_type(tx, ent, propname,
342 		    SCF_TYPE_BOOLEAN) != 0) {
343 			if (scf_error() != SCF_ERROR_NOT_FOUND)
344 				scfdie();
345 
346 			if (scf_transaction_property_new(tx, ent, propname,
347 			    SCF_TYPE_BOOLEAN) != 0)
348 				scfdie();
349 		}
350 
351 		r = scf_entry_add_value(ent, v);
352 		assert(r == 0);
353 
354 		r = scf_transaction_commit(tx);
355 		if (r == 1)
356 			break;
357 
358 		scf_transaction_reset(tx);
359 
360 		if (r != 0) {
361 			switch (scf_error()) {
362 			case SCF_ERROR_PERMISSION_DENIED:
363 				ret = EPERM;
364 				goto out;
365 
366 			case SCF_ERROR_BACKEND_READONLY:
367 				ret = EROFS;
368 				goto out;
369 
370 			default:
371 				scfdie();
372 			}
373 		}
374 
375 		if (scf_pg_update(pg) == -1)
376 			scfdie();
377 	}
378 
379 out:
380 	scf_transaction_destroy(tx);
381 	scf_entry_destroy(ent);
382 	scf_value_destroy(v);
383 	return (ret);
384 }
385 
386 /*
387  * Gets the single astring value of the propname property of pg.  prop & v are
388  * scratch space.  Returns the length of the string on success or
389  *   -ENOENT - pg has no property named propname
390  *   -E2BIG - property has no values or multiple values
391  *   -EINVAL - property type is not compatible with astring
392  */
393 ssize_t
394 get_astring_prop(const scf_propertygroup_t *pg, const char *propname,
395     scf_property_t *prop, scf_value_t *v, char *buf, size_t bufsz)
396 {
397 	ssize_t sz;
398 
399 	if (scf_pg_get_property(pg, propname, prop) != 0) {
400 		if (scf_error() != SCF_ERROR_NOT_FOUND)
401 			scfdie();
402 
403 		return (-ENOENT);
404 	}
405 
406 	if (scf_property_get_value(prop, v) != 0) {
407 		switch (scf_error()) {
408 		case SCF_ERROR_NOT_FOUND:
409 		case SCF_ERROR_CONSTRAINT_VIOLATED:
410 			return (-E2BIG);
411 
412 		default:
413 			scfdie();
414 		}
415 	}
416 
417 	sz = scf_value_get_astring(v, buf, bufsz);
418 	if (sz < 0) {
419 		if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
420 			scfdie();
421 
422 		return (-EINVAL);
423 	}
424 
425 	return (sz);
426 }
427 
428 /*
429  * Returns 0 or EPERM.
430  */
431 static int
432 pg_get_or_add(const scf_instance_t *inst, const char *pgname,
433     const char *pgtype, uint32_t pgflags, scf_propertygroup_t *pg)
434 {
435 again:
436 	if (scf_instance_get_pg(inst, pgname, pg) == 0)
437 		return (0);
438 
439 	if (scf_error() != SCF_ERROR_NOT_FOUND)
440 		scfdie();
441 
442 	if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) == 0)
443 		return (0);
444 
445 	switch (scf_error()) {
446 	case SCF_ERROR_EXISTS:
447 		goto again;
448 
449 	case SCF_ERROR_PERMISSION_DENIED:
450 		return (EPERM);
451 
452 	default:
453 		scfdie();
454 		/* NOTREACHED */
455 	}
456 }
457 
458 static int
459 my_ct_name(char *out, size_t len)
460 {
461 	ct_stathdl_t st;
462 	char *ct_fmri;
463 	ctid_t ct;
464 	int fd, errno, ret;
465 
466 	if ((ct = getctid()) == -1)
467 		uu_die(gettext("Could not get contract id for process"));
468 
469 	fd = contract_open(ct, "process", "status", O_RDONLY);
470 
471 	if ((errno = ct_status_read(fd, CTD_ALL, &st)) != 0)
472 		uu_warn(gettext("Could not read status of contract "
473 		    "%ld: %s.\n"), ct, strerror(errno));
474 
475 	if ((errno = ct_pr_status_get_svc_fmri(st, &ct_fmri)) != 0)
476 		uu_warn(gettext("Could not get svc_fmri for contract "
477 		    "%ld: %s.\n"), ct, strerror(errno));
478 
479 	ret = strlcpy(out, ct_fmri, len);
480 
481 	ct_status_free(st);
482 	(void) close(fd);
483 
484 	return (ret);
485 }
486 
487 /*
488  * Set auxiliary_tty and auxiliary_fmri properties in restarter_actions pg to
489  * communicate whether the action is requested from a tty and the fmri of the
490  * responsible process.
491  *
492  * Returns 0, EPERM, or EROFS
493  */
494 static int
495 restarter_setup(const char *fmri, const scf_instance_t *inst)
496 {
497 	boolean_t b = B_FALSE;
498 	scf_propertygroup_t *pg = NULL;
499 	int ret = 0;
500 
501 	if ((pg = scf_pg_create(h)) == NULL)
502 		scfdie();
503 
504 	if (pg_get_or_add(inst, SCF_PG_RESTARTER_ACTIONS,
505 	    SCF_PG_RESTARTER_ACTIONS_TYPE, SCF_PG_RESTARTER_ACTIONS_FLAGS,
506 	    pg) == EPERM) {
507 		if (!verbose)
508 			uu_warn(emsg_permission_denied, fmri);
509 		else
510 			uu_warn(emsg_create_pg_perm_denied, fmri,
511 			    SCF_PG_RESTARTER_ACTIONS);
512 
513 		ret = EPERM;
514 		goto out;
515 	}
516 
517 	/* Set auxiliary_tty property */
518 	if (isatty(STDIN_FILENO))
519 		b = B_TRUE;
520 
521 	/* Create and set state to disabled */
522 	switch (set_bool_prop(pg, SCF_PROPERTY_AUX_TTY, b)) {
523 	case 0:
524 		break;
525 
526 	case EPERM:
527 		if (!verbose)
528 			uu_warn(emsg_permission_denied, fmri);
529 		else
530 			uu_warn(emsg_prop_perm_denied, fmri,
531 			    SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY);
532 
533 		ret = EPERM;
534 		goto out;
535 		/* NOTREACHED */
536 
537 	case EROFS:
538 		/* Shouldn't happen, but it can. */
539 		if (!verbose)
540 			uu_warn(gettext("%s: Repository read-only.\n"), fmri);
541 		else
542 			uu_warn(gettext("%s: Could not set %s/%s "
543 			    "(repository read-only).\n"), fmri,
544 			    SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_TTY);
545 
546 		ret = EROFS;
547 		goto out;
548 		/* NOTREACHED */
549 
550 	default:
551 		scfdie();
552 	}
553 
554 	if (my_ct_name(scratch_fmri, max_scf_fmri_sz) > 0) {
555 		set_astring_prop(fmri, SCF_PG_RESTARTER_ACTIONS,
556 		    SCF_PG_RESTARTER_ACTIONS_TYPE,
557 		    SCF_PG_RESTARTER_ACTIONS_FLAGS,
558 		    SCF_PROPERTY_AUX_FMRI, scratch_fmri);
559 	} else {
560 		uu_warn(gettext("%s: Could not set %s/%s: "
561 		    "my_ct_name failed.\n"), fmri,
562 		    SCF_PG_RESTARTER_ACTIONS, SCF_PROPERTY_AUX_FMRI);
563 	}
564 
565 out:
566 	scf_pg_destroy(pg);
567 	return (ret);
568 }
569 
570 /*
571  * Enable or disable inst, per enable.  If temp is true, set
572  * general_ovr/enabled.  Otherwise set general/enabled and delete
573  * general_ovr/enabled if it exists (order is important here: we don't want the
574  * enabled status to glitch).
575  */
576 static void
577 set_inst_enabled(const char *fmri, scf_instance_t *inst, boolean_t temp,
578     boolean_t enable)
579 {
580 	scf_propertygroup_t *pg;
581 	uint8_t b;
582 	const char *pgname = NULL;	/* For emsg_pg_perm_denied */
583 	int r;
584 
585 	pg = scf_pg_create(h);
586 	if (pg == NULL)
587 		scfdie();
588 
589 	if (restarter_setup(fmri, inst))
590 		goto out;
591 
592 	/*
593 	 * An instance's configuration is incomplete if general/enabled
594 	 * doesn't exist. Create both the property group and property
595 	 * here if they don't exist.
596 	 */
597 	pgname = SCF_PG_GENERAL;
598 	if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE,
599 	    SCF_PG_GENERAL_FLAGS, pg) != 0)
600 		goto eperm;
601 
602 	if (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b) != 0) {
603 		/* Create and set state to disabled */
604 		switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, B_FALSE)) {
605 		case 0:
606 			break;
607 
608 		case EPERM:
609 			goto eperm;
610 
611 		case EROFS:
612 			/* Shouldn't happen, but it can. */
613 			if (!verbose)
614 				uu_warn(gettext("%s: Repository read-only.\n"),
615 				    fmri);
616 			else
617 				uu_warn(gettext("%s: Could not set %s/%s "
618 				    "(repository read-only).\n"), fmri,
619 				    SCF_PG_GENERAL, SCF_PROPERTY_ENABLED);
620 			goto out;
621 
622 		default:
623 			assert(0);
624 			abort();
625 		}
626 	}
627 
628 	if (temp) {
629 		/* Set general_ovr/enabled */
630 		pgname = SCF_PG_GENERAL_OVR;
631 		if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_OVR_TYPE,
632 		    SCF_PG_GENERAL_OVR_FLAGS, pg) != 0)
633 			goto eperm;
634 
635 		switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) {
636 		case 0:
637 			break;
638 
639 		case EPERM:
640 			goto eperm;
641 
642 		case EROFS:
643 			/* Shouldn't happen, but it can. */
644 			if (!verbose)
645 				uu_warn(gettext("%s: Repository read-only.\n"),
646 				    fmri);
647 			else
648 				uu_warn(gettext("%s: Could not set %s/%s "
649 				    "(repository read-only).\n"), fmri,
650 				    SCF_PG_GENERAL_OVR, SCF_PROPERTY_ENABLED);
651 			goto out;
652 
653 		default:
654 			assert(0);
655 			abort();
656 		}
657 
658 		if (verbose)
659 			(void) printf(enable ?
660 			    gettext("%s temporarily enabled.\n") :
661 			    gettext("%s temporarily disabled.\n"), fmri);
662 	} else {
663 again:
664 		/*
665 		 * Both pg and property should exist since we created
666 		 * them earlier. However, there's still a chance that
667 		 * someone may have deleted the property out from under
668 		 * us.
669 		 */
670 		if (pg_get_or_add(inst, pgname, SCF_PG_GENERAL_TYPE,
671 		    SCF_PG_GENERAL_FLAGS, pg) != 0)
672 			goto eperm;
673 
674 		switch (set_bool_prop(pg, SCF_PROPERTY_ENABLED, enable)) {
675 		case 0:
676 			break;
677 
678 		case EPERM:
679 			goto eperm;
680 
681 		case EROFS:
682 			/*
683 			 * If general/enabled is already set the way we want,
684 			 * proceed.
685 			 */
686 			switch (get_bool_prop(pg, SCF_PROPERTY_ENABLED, &b)) {
687 			case 0:
688 				if ((b != 0) == (enable != B_FALSE))
689 					break;
690 				/* FALLTHROUGH */
691 
692 			case ENOENT:
693 			case EINVAL:
694 			case E2BIG:
695 				if (!verbose)
696 					uu_warn(gettext("%s: Repository "
697 					    "read-only.\n"), fmri);
698 				else
699 					uu_warn(gettext("%s: Could not set "
700 					    "%s/%s (repository read-only).\n"),
701 					    fmri, SCF_PG_GENERAL,
702 					    SCF_PROPERTY_ENABLED);
703 				goto out;
704 
705 			case ECANCELED:
706 				goto again;
707 
708 			default:
709 				assert(0);
710 				abort();
711 			}
712 			break;
713 
714 		default:
715 			assert(0);
716 			abort();
717 		}
718 
719 		pgname = SCF_PG_GENERAL_OVR;
720 		r = scf_instance_delete_prop(inst, pgname,
721 		    SCF_PROPERTY_ENABLED);
722 		switch (r) {
723 		case 0:
724 			break;
725 
726 		case ECANCELED:
727 			uu_warn(emsg_no_service, fmri);
728 			goto out;
729 
730 		case EPERM:
731 			goto eperm;
732 
733 		case EACCES:
734 			uu_warn(gettext("Could not delete %s/%s "
735 			    "property of %s: backend access denied.\n"),
736 			    pgname, SCF_PROPERTY_ENABLED, fmri);
737 			goto out;
738 
739 		case EROFS:
740 			uu_warn(gettext("Could not delete %s/%s "
741 			    "property of %s: backend is read-only.\n"),
742 			    pgname, SCF_PROPERTY_ENABLED, fmri);
743 			goto out;
744 
745 		default:
746 			bad_error("scf_instance_delete_prop", r);
747 		}
748 
749 		if (verbose)
750 			(void) printf(enable ?  gettext("%s enabled.\n") :
751 			    gettext("%s disabled.\n"), fmri);
752 	}
753 
754 	scf_pg_destroy(pg);
755 	return;
756 
757 eperm:
758 	assert(pgname != NULL);
759 	if (!verbose)
760 		uu_warn(emsg_permission_denied, fmri);
761 	else
762 		uu_warn(emsg_pg_perm_denied, fmri, pgname);
763 
764 out:
765 	scf_pg_destroy(pg);
766 	exit_status = 1;
767 }
768 
769 /*
770  * Set inst to the instance which corresponds to fmri.  If fmri identifies
771  * a service with a single instance, get that instance.
772  *
773  * Fails with
774  *   ENOTSUP - fmri has an unsupported scheme
775  *   EINVAL - fmri is invalid
776  *   ENOTDIR - fmri does not identify a service or instance
777  *   ENOENT - could not locate instance
778  *   E2BIG - fmri is a service with multiple instances (warning not printed)
779  */
780 static int
781 get_inst_mult(const char *fmri, scf_instance_t *inst)
782 {
783 	char *cfmri;
784 	const char *svc_name, *inst_name, *pg_name;
785 	scf_service_t *svc;
786 	scf_instance_t *inst2;
787 	scf_iter_t *iter;
788 	int ret;
789 
790 	if (strncmp(fmri, "lrc:", sizeof ("lrc:") - 1) == 0) {
791 		uu_warn(gettext("FMRI \"%s\" is a legacy service.\n"), fmri);
792 		exit_status = 1;
793 		return (ENOTSUP);
794 	}
795 
796 	cfmri = strdup(fmri);
797 	if (cfmri == NULL)
798 		uu_die(emsg_nomem);
799 
800 	if (scf_parse_svc_fmri(cfmri, NULL, &svc_name, &inst_name, &pg_name,
801 	    NULL) != SCF_SUCCESS) {
802 		free(cfmri);
803 		uu_warn(gettext("FMRI \"%s\" is invalid.\n"), fmri);
804 		exit_status = 1;
805 		return (EINVAL);
806 	}
807 
808 	free(cfmri);
809 
810 	if (svc_name == NULL || pg_name != NULL) {
811 		uu_warn(gettext(
812 		    "FMRI \"%s\" does not designate a service or instance.\n"),
813 		    fmri);
814 		exit_status = 1;
815 		return (ENOTDIR);
816 	}
817 
818 	if (inst_name != NULL) {
819 		if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
820 		    NULL, SCF_DECODE_FMRI_EXACT) == 0)
821 			return (0);
822 
823 		if (scf_error() != SCF_ERROR_NOT_FOUND)
824 			scfdie();
825 
826 		uu_warn(gettext("No such instance \"%s\".\n"), fmri);
827 		exit_status = 1;
828 
829 		return (ENOENT);
830 	}
831 
832 	if ((svc = scf_service_create(h)) == NULL ||
833 	    (inst2 = scf_instance_create(h)) == NULL ||
834 	    (iter = scf_iter_create(h)) == NULL)
835 		scfdie();
836 
837 	if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL,
838 	    SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) {
839 		if (scf_error() != SCF_ERROR_NOT_FOUND)
840 			scfdie();
841 
842 		uu_warn(emsg_no_service, fmri);
843 		exit_status = 1;
844 
845 		ret = ENOENT;
846 		goto out;
847 	}
848 
849 	/* If the service has only one child, use it. */
850 	if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS)
851 		scfdie();
852 
853 	ret = scf_iter_next_instance(iter, inst);
854 	if (ret < 0)
855 		scfdie();
856 	if (ret != 1) {
857 		uu_warn(gettext("Service \"%s\" has no instances.\n"),
858 		    fmri);
859 		exit_status = 1;
860 		ret = ENOENT;
861 		goto out;
862 	}
863 
864 	ret = scf_iter_next_instance(iter, inst2);
865 	if (ret < 0)
866 		scfdie();
867 
868 	if (ret != 0) {
869 		ret = E2BIG;
870 		goto out;
871 	}
872 
873 	ret = 0;
874 
875 out:
876 	scf_iter_destroy(iter);
877 	scf_instance_destroy(inst2);
878 	scf_service_destroy(svc);
879 	return (ret);
880 }
881 
882 /*
883  * Same as get_inst_mult(), but on E2BIG prints a warning and returns ENOENT.
884  */
885 static int
886 get_inst(const char *fmri, scf_instance_t *inst)
887 {
888 	int r;
889 
890 	r = get_inst_mult(fmri, inst);
891 	if (r != E2BIG)
892 		return (r);
893 
894 	uu_warn(gettext("operation on service %s is ambiguous; "
895 	    "instance specification needed.\n"), fmri);
896 	return (ENOENT);
897 }
898 
899 static char *
900 inst_get_fmri(const scf_instance_t *inst)
901 {
902 	ssize_t sz;
903 
904 	sz = scf_instance_to_fmri(inst, scratch_fmri, max_scf_fmri_sz);
905 	if (sz < 0)
906 		scfdie();
907 	if (sz >= max_scf_fmri_sz)
908 		uu_die(gettext("scf_instance_to_fmri() returned unexpectedly "
909 		    "long value.\n"));
910 
911 	return (scratch_fmri);
912 }
913 
914 static ssize_t
915 dep_get_astring(const char *fmri, const char *pgname,
916     const scf_propertygroup_t *pg, const char *propname, scf_property_t *prop,
917     scf_value_t *v, char *buf, size_t bufsz)
918 {
919 	ssize_t sz;
920 
921 	sz = get_astring_prop(pg, propname, prop, v, buf, bufsz);
922 	if (sz >= 0)
923 		return (sz);
924 
925 	switch (-sz) {
926 	case ENOENT:
927 		uu_warn(gettext("\"%s\" is misconfigured (\"%s\" dependency "
928 		    "lacks \"%s\" property.)\n"), fmri, pgname, propname);
929 		return (-1);
930 
931 	case E2BIG:
932 		uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property "
933 		    "is not single-valued.)\n"), fmri, pgname, propname);
934 		return (-1);
935 
936 	case EINVAL:
937 		uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" property "
938 		    "is not of astring type.)\n"), fmri, pgname, propname);
939 		return (-1);
940 
941 	default:
942 		assert(0);
943 		abort();
944 		/* NOTREACHED */
945 	}
946 }
947 
948 static boolean_t
949 multiple_instances(scf_iter_t *iter, scf_value_t *v, char *buf)
950 {
951 	int count = 0, r;
952 	boolean_t ret;
953 	scf_instance_t *inst;
954 
955 	inst = scf_instance_create(h);
956 	if (inst == NULL)
957 		scfdie();
958 
959 	for (;;) {
960 		r = scf_iter_next_value(iter, v);
961 		if (r == 0) {
962 			ret = B_FALSE;
963 			goto out;
964 		}
965 		if (r != 1)
966 			scfdie();
967 
968 		if (scf_value_get_astring(v, buf, max_scf_fmri_sz) < 0)
969 			scfdie();
970 
971 		switch (get_inst_mult(buf, inst)) {
972 		case 0:
973 			++count;
974 			if (count > 1) {
975 				ret = B_TRUE;
976 				goto out;
977 			}
978 			break;
979 
980 		case ENOTSUP:
981 		case EINVAL:
982 		case ENOTDIR:
983 		case ENOENT:
984 			continue;
985 
986 		case E2BIG:
987 			ret = B_TRUE;
988 			goto out;
989 
990 		default:
991 			assert(0);
992 			abort();
993 		}
994 	}
995 
996 out:
997 	scf_instance_destroy(inst);
998 	return (ret);
999 }
1000 
1001 /*
1002  * Enable the service or instance identified by fmri and its dependencies,
1003  * recursively.  Specifically, call get_inst(fmri), enable the result, and
1004  * recurse on its restarter and the dependencies.  To avoid duplication of
1005  * effort or looping around a dependency cycle, each FMRI is entered into the
1006  * "visited" hash table.  While recursing, the hash table entry is marked
1007  * "active", so that if we come upon it again, we know we've hit a cycle.
1008  * exclude_all and optional_all dependencies are ignored.  require_any
1009  * dependencies are followed only if they comprise a single service; otherwise
1010  * the user is warned.
1011  *
1012  * fmri must point to a writable max_scf_fmri_sz buffer.  Returns EINVAL if fmri
1013  * is invalid, E2BIG if fmri identifies a service with multiple instances, ELOOP
1014  * on cycle detection, or 0 on success.
1015  */
1016 static int
1017 enable_fmri_rec(char *fmri, boolean_t temp)
1018 {
1019 	scf_instance_t *inst;
1020 	scf_snapshot_t *snap;
1021 	scf_propertygroup_t *pg;
1022 	scf_property_t *prop;
1023 	scf_value_t *v;
1024 	scf_iter_t *pg_iter, *val_iter;
1025 	scf_type_t ty;
1026 	char *buf, *pgname;
1027 	ssize_t name_sz, len, sz;
1028 	int ret;
1029 	struct ht_elt *he;
1030 
1031 	len = scf_canonify_fmri(fmri, fmri, max_scf_fmri_sz);
1032 	if (len < 0) {
1033 		assert(scf_error() == SCF_ERROR_INVALID_ARGUMENT);
1034 		return (EINVAL);
1035 	}
1036 	assert(len < max_scf_fmri_sz);
1037 
1038 	switch (visited_find_or_add(fmri, &he)) {
1039 	case 0:
1040 		he->active = B_TRUE;
1041 		break;
1042 
1043 	case 1:
1044 		return (he->active ? ELOOP : 0);
1045 
1046 	case -1:
1047 		uu_die(emsg_nomem);
1048 
1049 	default:
1050 		assert(0);
1051 		abort();
1052 	}
1053 
1054 	inst = scf_instance_create(h);
1055 	if (inst == NULL)
1056 		scfdie();
1057 
1058 	switch (get_inst_mult(fmri, inst)) {
1059 	case 0:
1060 		break;
1061 
1062 	case E2BIG:
1063 		he->active = B_FALSE;
1064 		return (E2BIG);
1065 
1066 	default:
1067 		he->active = B_FALSE;
1068 		return (0);
1069 	}
1070 
1071 	set_inst_enabled(fmri, inst, temp, B_TRUE);
1072 
1073 	if ((snap = scf_snapshot_create(h)) == NULL ||
1074 	    (pg = scf_pg_create(h)) == NULL ||
1075 	    (prop = scf_property_create(h)) == NULL ||
1076 	    (v = scf_value_create(h)) == NULL ||
1077 	    (pg_iter = scf_iter_create(h)) == NULL ||
1078 	    (val_iter = scf_iter_create(h)) == NULL)
1079 		scfdie();
1080 
1081 	buf = malloc(max_scf_fmri_sz);
1082 	if (buf == NULL)
1083 		uu_die(emsg_nomem);
1084 
1085 	name_sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
1086 	if (name_sz < 0)
1087 		scfdie();
1088 	++name_sz;
1089 	pgname = malloc(name_sz);
1090 	if (pgname == NULL)
1091 		uu_die(emsg_nomem);
1092 
1093 	if (scf_instance_get_snapshot(inst, "running", snap) != 0) {
1094 		if (scf_error() != SCF_ERROR_NOT_FOUND)
1095 			scfdie();
1096 
1097 		scf_snapshot_destroy(snap);
1098 		snap = NULL;
1099 	}
1100 
1101 	/* Enable restarter */
1102 	if (scf_instance_get_pg_composed(inst, snap, SCF_PG_GENERAL, pg) != 0) {
1103 		if (scf_error() != SCF_ERROR_NOT_FOUND)
1104 			scfdie();
1105 
1106 		uu_warn(gettext("\"%s\" is misconfigured (lacks \"%s\" "
1107 		    "property group).\n"), fmri, SCF_PG_GENERAL);
1108 		ret = 0;
1109 		goto out;
1110 	}
1111 
1112 	sz = get_astring_prop(pg, SCF_PROPERTY_RESTARTER, prop, v, buf,
1113 	    max_scf_fmri_sz);
1114 	if (sz > max_scf_fmri_sz) {
1115 		uu_warn(gettext("\"%s\" is misconfigured (the value of "
1116 		    "\"%s/%s\" is too long).\n"), fmri, SCF_PG_GENERAL,
1117 		    SCF_PROPERTY_RESTARTER);
1118 		ret = 0;
1119 		goto out;
1120 	} else if (sz >= 0) {
1121 		switch (enable_fmri_rec(buf, temp)) {
1122 		case 0:
1123 			break;
1124 
1125 		case EINVAL:
1126 			uu_warn(gettext("Restarter FMRI for \"%s\" is "
1127 			    "invalid.\n"), fmri);
1128 			break;
1129 
1130 		case E2BIG:
1131 			uu_warn(gettext("Restarter FMRI for \"%s\" identifies "
1132 			    "a service with multiple instances.\n"), fmri);
1133 			break;
1134 
1135 		case ELOOP:
1136 			ret = ELOOP;
1137 			goto out;
1138 
1139 		default:
1140 			assert(0);
1141 			abort();
1142 		}
1143 	} else if (sz < 0) {
1144 		switch (-sz) {
1145 		case ENOENT:
1146 			break;
1147 
1148 		case E2BIG:
1149 			uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" "
1150 			    "property is not single-valued).\n"), fmri,
1151 			    SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER);
1152 			ret = 0;
1153 			goto out;
1154 
1155 		case EINVAL:
1156 			uu_warn(gettext("\"%s\" is misconfigured (\"%s/%s\" "
1157 			    "property is not of astring type).\n"), fmri,
1158 			    SCF_PG_GENERAL, SCF_PROPERTY_RESTARTER);
1159 			ret = 0;
1160 			goto out;
1161 
1162 		default:
1163 			assert(0);
1164 			abort();
1165 		}
1166 	}
1167 
1168 	if (scf_iter_instance_pgs_typed_composed(pg_iter, inst, snap,
1169 	    SCF_GROUP_DEPENDENCY) == -1)
1170 		scfdie();
1171 
1172 	while (scf_iter_next_pg(pg_iter, pg) > 0) {
1173 		len = scf_pg_get_name(pg, pgname, name_sz);
1174 		if (len < 0)
1175 			scfdie();
1176 		assert(len < name_sz);
1177 
1178 		if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_TYPE, prop,
1179 		    v, buf, max_scf_fmri_sz) < 0)
1180 			continue;
1181 
1182 		if (strcmp(buf, "service") != 0)
1183 			continue;
1184 
1185 		if (dep_get_astring(fmri, pgname, pg, SCF_PROPERTY_GROUPING,
1186 		    prop, v, buf, max_scf_fmri_sz) < 0)
1187 			continue;
1188 
1189 		if (strcmp(buf, SCF_DEP_EXCLUDE_ALL) == 0 ||
1190 		    strcmp(buf, SCF_DEP_OPTIONAL_ALL) == 0)
1191 			continue;
1192 
1193 		if (strcmp(buf, SCF_DEP_REQUIRE_ALL) != 0 &&
1194 		    strcmp(buf, SCF_DEP_REQUIRE_ANY) != 0) {
1195 			uu_warn(gettext("Dependency \"%s\" of \"%s\" has "
1196 			    "unknown type \"%s\".\n"), pgname, fmri, buf);
1197 			continue;
1198 		}
1199 
1200 		if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) ==
1201 		    -1) {
1202 			if (scf_error() != SCF_ERROR_NOT_FOUND)
1203 				scfdie();
1204 
1205 			uu_warn(gettext("\"%s\" is misconfigured (\"%s\" "
1206 			    "dependency lacks \"%s\" property.)\n"), fmri,
1207 			    pgname, SCF_PROPERTY_ENTITIES);
1208 			continue;
1209 		}
1210 
1211 		if (scf_property_type(prop, &ty) != SCF_SUCCESS)
1212 			scfdie();
1213 
1214 		if (ty != SCF_TYPE_FMRI) {
1215 			uu_warn(gettext("\"%s\" is misconfigured (property "
1216 			    "\"%s/%s\" is not of fmri type).\n"), fmri, pgname,
1217 			    SCF_PROPERTY_ENTITIES);
1218 			continue;
1219 		}
1220 
1221 		if (scf_iter_property_values(val_iter, prop) == -1)
1222 			scfdie();
1223 
1224 		if (strcmp(buf, SCF_DEP_REQUIRE_ANY) == 0) {
1225 			if (multiple_instances(val_iter, v, buf)) {
1226 				(void) printf(gettext("%s requires one of:\n"),
1227 				    fmri);
1228 
1229 				if (scf_iter_property_values(val_iter, prop) !=
1230 				    0)
1231 					scfdie();
1232 
1233 				for (;;) {
1234 					int r;
1235 
1236 					r = scf_iter_next_value(val_iter, v);
1237 					if (r == 0)
1238 						break;
1239 					if (r != 1)
1240 						scfdie();
1241 
1242 					if (scf_value_get_astring(v, buf,
1243 					    max_scf_fmri_sz) < 0)
1244 						scfdie();
1245 
1246 					(void) fputs("  ", stdout);
1247 					(void) puts(buf);
1248 				}
1249 
1250 				continue;
1251 			}
1252 
1253 			/*
1254 			 * Since there's only one instance, we can enable it.
1255 			 * Reset val_iter and continue.
1256 			 */
1257 			if (scf_iter_property_values(val_iter, prop) != 0)
1258 				scfdie();
1259 		}
1260 
1261 		for (;;) {
1262 			ret = scf_iter_next_value(val_iter, v);
1263 			if (ret == 0)
1264 				break;
1265 			if (ret != 1)
1266 				scfdie();
1267 
1268 			if (scf_value_get_astring(v, buf, max_scf_fmri_sz) ==
1269 			    -1)
1270 				scfdie();
1271 
1272 			switch (enable_fmri_rec(buf, temp)) {
1273 			case 0:
1274 				break;
1275 
1276 			case EINVAL:
1277 				uu_warn(gettext("\"%s\" dependency of \"%s\" "
1278 				    "has invalid FMRI \"%s\".\n"), pgname,
1279 				    fmri, buf);
1280 				break;
1281 
1282 			case E2BIG:
1283 				uu_warn(gettext("%s depends on %s, which has "
1284 				    "multiple instances.\n"), fmri, buf);
1285 				break;
1286 
1287 			case ELOOP:
1288 				ret = ELOOP;
1289 				goto out;
1290 
1291 			default:
1292 				assert(0);
1293 				abort();
1294 			}
1295 		}
1296 	}
1297 
1298 	ret = 0;
1299 
1300 out:
1301 	he->active = B_FALSE;
1302 
1303 	free(buf);
1304 	free(pgname);
1305 
1306 	(void) scf_value_destroy(v);
1307 	scf_property_destroy(prop);
1308 	scf_pg_destroy(pg);
1309 	scf_snapshot_destroy(snap);
1310 	scf_iter_destroy(pg_iter);
1311 	scf_iter_destroy(val_iter);
1312 
1313 	return (ret);
1314 }
1315 
1316 /*
1317  * fmri here is only used for verbose messages.
1318  */
1319 static void
1320 set_inst_action(const char *fmri, const scf_instance_t *inst,
1321     const char *action)
1322 {
1323 	scf_transaction_t *tx;
1324 	scf_transaction_entry_t *ent;
1325 	scf_propertygroup_t *pg;
1326 	scf_property_t *prop;
1327 	scf_value_t *v;
1328 	int ret;
1329 	int64_t t;
1330 	hrtime_t timestamp;
1331 
1332 	const char * const scf_pg_restarter_actions = SCF_PG_RESTARTER_ACTIONS;
1333 
1334 	if ((pg = scf_pg_create(h)) == NULL ||
1335 	    (prop = scf_property_create(h)) == NULL ||
1336 	    (v = scf_value_create(h)) == NULL ||
1337 	    (tx = scf_transaction_create(h)) == NULL ||
1338 	    (ent = scf_entry_create(h)) == NULL)
1339 		scfdie();
1340 
1341 	if (restarter_setup(fmri, inst)) {
1342 		exit_status = 1;
1343 		goto out;
1344 	}
1345 
1346 	if (scf_instance_get_pg(inst, scf_pg_restarter_actions, pg) == -1) {
1347 		if (scf_error() != SCF_ERROR_NOT_FOUND)
1348 			scfdie();
1349 
1350 		/* Try creating the restarter_actions property group. */
1351 		if (scf_instance_add_pg(inst, scf_pg_restarter_actions,
1352 		    SCF_PG_RESTARTER_ACTIONS_TYPE,
1353 		    SCF_PG_RESTARTER_ACTIONS_FLAGS, pg) == -1) {
1354 			switch (scf_error()) {
1355 			case SCF_ERROR_EXISTS:
1356 				/* Someone must have added it. */
1357 				break;
1358 
1359 			case SCF_ERROR_PERMISSION_DENIED:
1360 				if (!verbose)
1361 					uu_warn(emsg_permission_denied, fmri);
1362 				else
1363 					uu_warn(emsg_create_pg_perm_denied,
1364 					    fmri, scf_pg_restarter_actions);
1365 				goto out;
1366 
1367 			default:
1368 				scfdie();
1369 			}
1370 		}
1371 	}
1372 
1373 	/*
1374 	 * If we lose the transaction race and need to retry, there are 2
1375 	 * potential other winners:
1376 	 *	- another process setting actions
1377 	 *	- the restarter marking the action complete
1378 	 * Therefore, re-read the property every time through the loop before
1379 	 * making any decisions based on their values.
1380 	 */
1381 	do {
1382 		timestamp = gethrtime();
1383 
1384 		if (scf_transaction_start(tx, pg) == -1) {
1385 			if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1386 				scfdie();
1387 
1388 			if (!verbose)
1389 				uu_warn(emsg_permission_denied, fmri);
1390 			else
1391 				uu_warn(emsg_pg_perm_denied, fmri,
1392 				    scf_pg_restarter_actions);
1393 			goto out;
1394 		}
1395 
1396 		if (scf_pg_get_property(pg, action, prop) == -1) {
1397 			if (scf_error() != SCF_ERROR_NOT_FOUND)
1398 				scfdie();
1399 			if (scf_transaction_property_new(tx, ent,
1400 			    action, SCF_TYPE_INTEGER) == -1)
1401 				scfdie();
1402 			goto action_set;
1403 		} else {
1404 			if (scf_transaction_property_change_type(tx, ent,
1405 			    action, SCF_TYPE_INTEGER) == -1)
1406 				scfdie();
1407 		}
1408 
1409 		if (scf_property_get_value(prop, v) == -1) {
1410 			switch (scf_error()) {
1411 			case SCF_ERROR_CONSTRAINT_VIOLATED:
1412 			case SCF_ERROR_NOT_FOUND:
1413 				/* Misconfigured, so set anyway. */
1414 				goto action_set;
1415 
1416 			default:
1417 				scfdie();
1418 			}
1419 		} else {
1420 			if (scf_value_get_integer(v, &t) == -1) {
1421 				assert(scf_error() == SCF_ERROR_TYPE_MISMATCH);
1422 				goto action_set;
1423 			}
1424 			if (t > timestamp)
1425 				break;
1426 		}
1427 
1428 action_set:
1429 		scf_value_set_integer(v, timestamp);
1430 		if (scf_entry_add_value(ent, v) == -1)
1431 			scfdie();
1432 
1433 		ret = scf_transaction_commit(tx);
1434 		if (ret == -1) {
1435 			if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1436 				scfdie();
1437 
1438 			if (!verbose)
1439 				uu_warn(emsg_permission_denied, fmri);
1440 			else
1441 				uu_warn(emsg_prop_perm_denied, fmri,
1442 				    scf_pg_restarter_actions, action);
1443 			scf_transaction_reset(tx);
1444 			goto out;
1445 		}
1446 
1447 		scf_transaction_reset(tx);
1448 
1449 		if (ret == 0) {
1450 			if (scf_pg_update(pg) == -1)
1451 				scfdie();
1452 		}
1453 	} while (ret == 0);
1454 
1455 	if (verbose)
1456 		(void) printf(gettext("Action %s set for %s.\n"), action, fmri);
1457 
1458 out:
1459 	scf_value_destroy(v);
1460 	scf_entry_destroy(ent);
1461 	scf_transaction_destroy(tx);
1462 	scf_property_destroy(prop);
1463 	scf_pg_destroy(pg);
1464 }
1465 
1466 /*
1467  * Get the state of inst.  state should point to a buffer of
1468  * MAX_SCF_STATE_STRING_SZ bytes.  Returns 0 on success or -1 if
1469  *   no restarter property group
1470  *   no state property
1471  *   state property is misconfigured (wrong type, not single-valued)
1472  *   state value is too long
1473  * In these cases, fmri is used to print a warning.
1474  *
1475  * If pgp is non-NULL, a successful call to inst_get_state will store
1476  * the SCF_PG_RESTARTER property group in *pgp, and the caller will be
1477  * responsible for calling scf_pg_destroy on the property group.
1478  */
1479 int
1480 inst_get_state(scf_instance_t *inst, char *state, const char *fmri,
1481     scf_propertygroup_t **pgp)
1482 {
1483 	scf_propertygroup_t *pg;
1484 	scf_property_t *prop;
1485 	scf_value_t *val;
1486 	int ret = -1;
1487 	ssize_t szret;
1488 
1489 	if ((pg = scf_pg_create(h)) == NULL ||
1490 	    (prop = scf_property_create(h)) == NULL ||
1491 	    (val = scf_value_create(h)) == NULL)
1492 		scfdie();
1493 
1494 	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, pg) != SCF_SUCCESS) {
1495 		if (scf_error() != SCF_ERROR_NOT_FOUND)
1496 			scfdie();
1497 
1498 		uu_warn(gettext("%s is misconfigured (lacks \"%s\" property "
1499 		    "group).\n"), fmri ? fmri : inst_get_fmri(inst),
1500 		    SCF_PG_RESTARTER);
1501 		goto out;
1502 	}
1503 
1504 	szret = get_astring_prop(pg, SCF_PROPERTY_STATE, prop, val, state,
1505 	    MAX_SCF_STATE_STRING_SZ);
1506 	if (szret < 0) {
1507 		switch (-szret) {
1508 		case ENOENT:
1509 			uu_warn(gettext("%s is misconfigured (\"%s\" property "
1510 			    "group lacks \"%s\" property).\n"),
1511 			    fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1512 			    SCF_PROPERTY_STATE);
1513 			goto out;
1514 
1515 		case E2BIG:
1516 			uu_warn(gettext("%s is misconfigured (\"%s/%s\" "
1517 			    "property is not single-valued).\n"),
1518 			    fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1519 			    SCF_PROPERTY_STATE);
1520 			goto out;
1521 
1522 		case EINVAL:
1523 			uu_warn(gettext("%s is misconfigured (\"%s/%s\" "
1524 			    "property is not of type astring).\n"),
1525 			    fmri ? fmri : inst_get_fmri(inst), SCF_PG_RESTARTER,
1526 			    SCF_PROPERTY_STATE);
1527 			goto out;
1528 
1529 		default:
1530 			assert(0);
1531 			abort();
1532 		}
1533 	}
1534 	if (szret >= MAX_SCF_STATE_STRING_SZ) {
1535 		uu_warn(gettext("%s is misconfigured (\"%s/%s\" property value "
1536 		    "is too long).\n"), fmri ? fmri : inst_get_fmri(inst),
1537 		    SCF_PG_RESTARTER, SCF_PROPERTY_STATE);
1538 		goto out;
1539 	}
1540 
1541 	ret = 0;
1542 	if (pgp)
1543 		*pgp = pg;
1544 
1545 out:
1546 	(void) scf_value_destroy(val);
1547 	scf_property_destroy(prop);
1548 	if (ret || pgp == NULL)
1549 		scf_pg_destroy(pg);
1550 	return (ret);
1551 }
1552 
1553 static void
1554 set_astring_prop(const char *fmri, const char *pgname, const char *pgtype,
1555     uint32_t pgflags, const char *propname, const char *str)
1556 {
1557 	scf_instance_t *inst;
1558 	scf_propertygroup_t *pg;
1559 	scf_property_t *prop;
1560 	scf_value_t *val;
1561 	scf_transaction_t *tx;
1562 	scf_transaction_entry_t *txent;
1563 	int ret;
1564 
1565 	inst = scf_instance_create(h);
1566 	if (inst == NULL)
1567 		scfdie();
1568 
1569 	if (get_inst(fmri, inst) != 0)
1570 		return;
1571 
1572 	if ((pg = scf_pg_create(h)) == NULL ||
1573 	    (prop = scf_property_create(h)) == NULL ||
1574 	    (val = scf_value_create(h)) == NULL ||
1575 	    (tx = scf_transaction_create(h)) == NULL ||
1576 	    (txent = scf_entry_create(h)) == NULL)
1577 		scfdie();
1578 
1579 	if (scf_instance_get_pg(inst, pgname, pg) != SCF_SUCCESS) {
1580 		if (scf_error() != SCF_ERROR_NOT_FOUND)
1581 			scfdie();
1582 
1583 		if (scf_instance_add_pg(inst, pgname, pgtype, pgflags, pg) !=
1584 		    SCF_SUCCESS) {
1585 			switch (scf_error()) {
1586 			case SCF_ERROR_EXISTS:
1587 				if (scf_instance_get_pg(inst, pgname, pg) !=
1588 				    SCF_SUCCESS) {
1589 					if (scf_error() != SCF_ERROR_NOT_FOUND)
1590 						scfdie();
1591 
1592 					uu_warn(gettext("Repository write "
1593 					    "contention.\n"));
1594 					goto out;
1595 				}
1596 				break;
1597 
1598 			case SCF_ERROR_PERMISSION_DENIED:
1599 				if (!verbose)
1600 					uu_warn(emsg_permission_denied, fmri);
1601 				else
1602 					uu_warn(emsg_create_pg_perm_denied,
1603 					    fmri, pgname);
1604 				goto out;
1605 
1606 			default:
1607 				scfdie();
1608 			}
1609 		}
1610 	}
1611 
1612 	do {
1613 		if (scf_transaction_start(tx, pg) != SCF_SUCCESS) {
1614 			if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1615 				scfdie();
1616 
1617 			if (!verbose)
1618 				uu_warn(emsg_permission_denied, fmri);
1619 			else
1620 				uu_warn(emsg_pg_perm_denied, fmri, pgname);
1621 			goto out;
1622 		}
1623 
1624 		if (scf_transaction_property_change_type(tx, txent, propname,
1625 		    SCF_TYPE_ASTRING) != 0) {
1626 			if (scf_error() != SCF_ERROR_NOT_FOUND)
1627 				scfdie();
1628 
1629 			if (scf_transaction_property_new(tx, txent, propname,
1630 			    SCF_TYPE_ASTRING) != 0)
1631 				scfdie();
1632 		}
1633 
1634 		if (scf_value_set_astring(val, str) != SCF_SUCCESS)
1635 			scfdie();
1636 
1637 		if (scf_entry_add_value(txent, val) != SCF_SUCCESS)
1638 			scfdie();
1639 
1640 		ret = scf_transaction_commit(tx);
1641 		if (ret == -1) {
1642 			if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
1643 				scfdie();
1644 
1645 			if (!verbose)
1646 				uu_warn(emsg_permission_denied, fmri);
1647 			else
1648 				uu_warn(emsg_prop_perm_denied, fmri, pgname,
1649 				    propname);
1650 			goto out;
1651 		}
1652 
1653 		if (ret == 0) {
1654 			scf_transaction_reset(tx);
1655 
1656 			if (scf_pg_update(pg) == -1)
1657 				scfdie();
1658 		}
1659 	} while (ret == 0);
1660 
1661 out:
1662 	scf_transaction_destroy(tx);
1663 	scf_entry_destroy(txent);
1664 	scf_value_destroy(val);
1665 	scf_property_destroy(prop);
1666 	scf_pg_destroy(pg);
1667 	scf_instance_destroy(inst);
1668 }
1669 
1670 
1671 /*
1672  * Flags to control enable and disable actions.
1673  */
1674 #define	SET_ENABLED	0x1
1675 #define	SET_TEMPORARY	0x2
1676 #define	SET_RECURSIVE	0x4
1677 
1678 static int
1679 set_fmri_enabled(void *data, scf_walkinfo_t *wip)
1680 {
1681 	int flags = (int)data;
1682 
1683 	assert(wip->inst != NULL);
1684 	assert(wip->pg == NULL);
1685 
1686 	if (svcsearch) {
1687 		char state[MAX_SCF_STATE_STRING_SZ];
1688 
1689 		if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1690 			return (0);
1691 		if (strcmp(state, svcstate) != 0)
1692 			return (0);
1693 	}
1694 
1695 	if (flags & SET_RECURSIVE) {
1696 		char *fmri_buf = malloc(max_scf_fmri_sz);
1697 		if (fmri_buf == NULL)
1698 			uu_die(emsg_nomem);
1699 
1700 		visited = calloc(HT_BUCKETS, sizeof (*visited));
1701 		if (visited == NULL)
1702 			uu_die(emsg_nomem);
1703 
1704 		/* scf_walk_fmri() guarantees that fmri isn't too long */
1705 		assert(strlen(wip->fmri) <= max_scf_fmri_sz);
1706 		(void) strlcpy(fmri_buf, wip->fmri, max_scf_fmri_sz);
1707 
1708 		switch (enable_fmri_rec(fmri_buf, (flags & SET_TEMPORARY))) {
1709 		case E2BIG:
1710 			uu_warn(gettext("operation on service %s is ambiguous; "
1711 			    "instance specification needed.\n"), fmri_buf);
1712 			break;
1713 
1714 		case ELOOP:
1715 			uu_warn(gettext("%s: Dependency cycle detected.\n"),
1716 			    fmri_buf);
1717 		}
1718 
1719 		free(visited);
1720 		free(fmri_buf);
1721 
1722 	} else {
1723 		set_inst_enabled(wip->fmri, wip->inst,
1724 		    (flags & SET_TEMPORARY) != 0, (flags & SET_ENABLED) != 0);
1725 	}
1726 
1727 	return (0);
1728 }
1729 
1730 /* ARGSUSED */
1731 static int
1732 wait_fmri_enabled(void *data, scf_walkinfo_t *wip)
1733 {
1734 	scf_propertygroup_t *pg = NULL;
1735 	char state[MAX_SCF_STATE_STRING_SZ];
1736 
1737 	assert(wip->inst != NULL);
1738 	assert(wip->pg == NULL);
1739 
1740 	do {
1741 		if (pg)
1742 			scf_pg_destroy(pg);
1743 		if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) {
1744 			exit_status = EXIT_SVC_FAILURE;
1745 			return (0);
1746 		}
1747 
1748 		if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0 ||
1749 		    strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) {
1750 			/*
1751 			 * We're done.
1752 			 */
1753 			goto out;
1754 		}
1755 
1756 		if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
1757 			/*
1758 			 * The service is ill.
1759 			 */
1760 			uu_warn(gettext("Instance \"%s\" is in maintenance"
1761 			    " state.\n"), wip->fmri);
1762 			exit_status = EXIT_SVC_FAILURE;
1763 			goto out;
1764 		}
1765 
1766 		if (!is_enabled(wip->inst)) {
1767 			/*
1768 			 * Someone stepped in and disabled the service.
1769 			 */
1770 			uu_warn(gettext("Instance \"%s\" has been disabled"
1771 			    " by another entity.\n"), wip->fmri);
1772 			exit_status = EXIT_SVC_FAILURE;
1773 			goto out;
1774 		}
1775 
1776 		if (!has_potential(wip->inst, B_FALSE)) {
1777 			/*
1778 			 * Our dependencies aren't met.  We'll never
1779 			 * amount to anything.
1780 			 */
1781 			uu_warn(gettext("Instance \"%s\" has unsatisfied"
1782 			    " dependencies.\n"), wip->fmri);
1783 			/*
1784 			 * EXIT_SVC_FAILURE takes precedence over
1785 			 * EXIT_DEP_FAILURE
1786 			 */
1787 			if (exit_status == 0)
1788 				exit_status = EXIT_DEP_FAILURE;
1789 			goto out;
1790 		}
1791 	} while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0);
1792 	scfdie();
1793 	/* NOTREACHED */
1794 
1795 out:
1796 	scf_pg_destroy(pg);
1797 	return (0);
1798 }
1799 
1800 /* ARGSUSED */
1801 static int
1802 wait_fmri_disabled(void *data, scf_walkinfo_t *wip)
1803 {
1804 	scf_propertygroup_t *pg = NULL;
1805 	char state[MAX_SCF_STATE_STRING_SZ];
1806 
1807 	assert(wip->inst != NULL);
1808 	assert(wip->pg == NULL);
1809 
1810 	do {
1811 		if (pg)
1812 			scf_pg_destroy(pg);
1813 		if (inst_get_state(wip->inst, state, wip->fmri, &pg) != 0) {
1814 			exit_status = EXIT_SVC_FAILURE;
1815 			return (0);
1816 		}
1817 
1818 		if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) {
1819 			/*
1820 			 * We're done.
1821 			 */
1822 			goto out;
1823 		}
1824 
1825 		if (is_enabled(wip->inst)) {
1826 			/*
1827 			 * Someone stepped in and enabled the service.
1828 			 */
1829 			uu_warn(gettext("Instance \"%s\" has been enabled"
1830 			    " by another entity.\n"), wip->fmri);
1831 			exit_status = EXIT_SVC_FAILURE;
1832 			goto out;
1833 		}
1834 
1835 		if (!has_potential(wip->inst, B_TRUE)) {
1836 			/*
1837 			 * Our restarter is hopeless.
1838 			 */
1839 			uu_warn(gettext("Restarter for instance \"%s\" is"
1840 			    " unavailable.\n"), wip->fmri);
1841 			/*
1842 			 * EXIT_SVC_FAILURE takes precedence over
1843 			 * EXIT_DEP_FAILURE
1844 			 */
1845 			if (exit_status == 0)
1846 				exit_status = EXIT_DEP_FAILURE;
1847 			goto out;
1848 		}
1849 
1850 	} while (_scf_pg_wait(pg, WAIT_INTERVAL) >= 0);
1851 	scfdie();
1852 	/* NOTREACHED */
1853 
1854 out:
1855 	scf_pg_destroy(pg);
1856 	return (0);
1857 }
1858 
1859 /* ARGSUSED */
1860 static int
1861 clear_instance(void *data, scf_walkinfo_t *wip)
1862 {
1863 	char state[MAX_SCF_STATE_STRING_SZ];
1864 
1865 	assert(wip->inst != NULL);
1866 	assert(wip->pg == NULL);
1867 
1868 	if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1869 		return (0);
1870 
1871 	if (svcsearch && strcmp(state, svcstate) != 0)
1872 		return (0);
1873 
1874 	if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {
1875 		set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_MAINT_OFF);
1876 	} else if (strcmp(state, SCF_STATE_STRING_DEGRADED) ==
1877 	    0) {
1878 		set_inst_action(wip->fmri, wip->inst, SCF_PROPERTY_RESTORE);
1879 	} else {
1880 		uu_warn(gettext("Instance \"%s\" is not in a "
1881 		    "maintenance or degraded state.\n"), wip->fmri);
1882 
1883 		exit_status = 1;
1884 	}
1885 
1886 	return (0);
1887 }
1888 
1889 static int
1890 set_fmri_action(void *action, scf_walkinfo_t *wip)
1891 {
1892 	assert(wip->inst != NULL && wip->pg == NULL);
1893 
1894 	if (svcsearch) {
1895 		char state[MAX_SCF_STATE_STRING_SZ];
1896 
1897 		if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1898 			return (0);
1899 		if (strcmp(state, svcstate) != 0)
1900 			return (0);
1901 	}
1902 
1903 	set_inst_action(wip->fmri, wip->inst, action);
1904 
1905 	return (0);
1906 }
1907 
1908 /*
1909  * Flags to control 'mark' action.
1910  */
1911 #define	MARK_IMMEDIATE	0x1
1912 #define	MARK_TEMPORARY	0x2
1913 
1914 static int
1915 force_degraded(void *data, scf_walkinfo_t *wip)
1916 {
1917 	int flags = (int)data;
1918 	char state[MAX_SCF_STATE_STRING_SZ];
1919 
1920 	if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0) {
1921 		exit_status = 1;
1922 		return (0);
1923 	}
1924 
1925 	if (svcsearch && strcmp(state, svcstate) != 0)
1926 		return (0);
1927 
1928 	if (strcmp(state, SCF_STATE_STRING_ONLINE) != 0) {
1929 		uu_warn(gettext("Instance \"%s\" is not online.\n"), wip->fmri);
1930 		exit_status = 1;
1931 		return (0);
1932 	}
1933 
1934 	set_inst_action(wip->fmri, wip->inst, (flags & MARK_IMMEDIATE) ?
1935 	    SCF_PROPERTY_DEGRADE_IMMEDIATE : SCF_PROPERTY_DEGRADED);
1936 
1937 	return (0);
1938 }
1939 
1940 static int
1941 force_maintenance(void *data, scf_walkinfo_t *wip)
1942 {
1943 	int flags = (int)data;
1944 	const char *prop;
1945 
1946 	if (svcsearch) {
1947 		char state[MAX_SCF_STATE_STRING_SZ];
1948 
1949 		if (inst_get_state(wip->inst, state, wip->fmri, NULL) != 0)
1950 			return (0);
1951 		if (strcmp(state, svcstate) != 0)
1952 			return (0);
1953 	}
1954 
1955 	if (flags & MARK_IMMEDIATE) {
1956 		prop = (flags & MARK_TEMPORARY) ?
1957 		    SCF_PROPERTY_MAINT_ON_IMMTEMP :
1958 		    SCF_PROPERTY_MAINT_ON_IMMEDIATE;
1959 	} else {
1960 		prop = (flags & MARK_TEMPORARY) ?
1961 		    SCF_PROPERTY_MAINT_ON_TEMPORARY :
1962 		    SCF_PROPERTY_MAINT_ON;
1963 	}
1964 
1965 	set_inst_action(wip->fmri, wip->inst, prop);
1966 
1967 	return (0);
1968 }
1969 
1970 static void
1971 set_milestone(const char *fmri, boolean_t temporary)
1972 {
1973 	scf_instance_t *inst;
1974 	scf_propertygroup_t *pg;
1975 	int r;
1976 
1977 	if (temporary) {
1978 		set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS_OVR,
1979 		    SCF_PG_OPTIONS_OVR_TYPE, SCF_PG_OPTIONS_OVR_FLAGS,
1980 		    SCF_PROPERTY_MILESTONE, fmri);
1981 		return;
1982 	}
1983 
1984 	if ((inst = scf_instance_create(h)) == NULL ||
1985 	    (pg = scf_pg_create(h)) == NULL)
1986 		scfdie();
1987 
1988 	if (get_inst(SCF_SERVICE_STARTD, inst) != 0) {
1989 		scf_instance_destroy(inst);
1990 		return;
1991 	}
1992 
1993 	/*
1994 	 * Set the persistent milestone before deleting the override so we don't
1995 	 * glitch.
1996 	 */
1997 	set_astring_prop(SCF_SERVICE_STARTD, SCF_PG_OPTIONS,
1998 	    SCF_PG_OPTIONS_TYPE, SCF_PG_OPTIONS_FLAGS, SCF_PROPERTY_MILESTONE,
1999 	    fmri);
2000 
2001 	r = scf_instance_delete_prop(inst, SCF_PG_OPTIONS_OVR,
2002 	    SCF_PROPERTY_MILESTONE);
2003 	switch (r) {
2004 	case 0:
2005 		break;
2006 
2007 	case ECANCELED:
2008 		uu_warn(emsg_no_service, fmri);
2009 		exit_status = 1;
2010 		goto out;
2011 
2012 	case EPERM:
2013 		uu_warn(gettext("Could not delete %s/%s property of "
2014 		    "%s: permission denied.\n"), SCF_PG_OPTIONS_OVR,
2015 		    SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2016 		exit_status = 1;
2017 		goto out;
2018 
2019 	case EACCES:
2020 		uu_warn(gettext("Could not delete %s/%s property of "
2021 		    "%s: access denied.\n"), SCF_PG_OPTIONS_OVR,
2022 		    SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2023 		exit_status = 1;
2024 		goto out;
2025 
2026 	case EROFS:
2027 		uu_warn(gettext("Could not delete %s/%s property of "
2028 		    "%s: backend read-only.\n"), SCF_PG_OPTIONS_OVR,
2029 		    SCF_PROPERTY_MILESTONE, SCF_SERVICE_STARTD);
2030 		exit_status = 1;
2031 		goto out;
2032 
2033 	default:
2034 		bad_error("scf_instance_delete_prop", r);
2035 	}
2036 
2037 out:
2038 	scf_pg_destroy(pg);
2039 	scf_instance_destroy(inst);
2040 }
2041 
2042 static char const *milestones[] = {
2043 	SCF_MILESTONE_SINGLE_USER,
2044 	SCF_MILESTONE_MULTI_USER,
2045 	SCF_MILESTONE_MULTI_USER_SERVER,
2046 	NULL
2047 };
2048 
2049 static void
2050 usage_milestone(void)
2051 {
2052 	const char **ms;
2053 
2054 	(void) fprintf(stderr, gettext(
2055 	"Usage: svcadm milestone [-d] <milestone>\n\n"
2056 	"\t-d\tmake the specified milestone the default for system boot\n\n"
2057 	"\tMilestones can be specified using an FMRI or abbreviation.\n"
2058 	"\tThe major milestones are as follows:\n\n"
2059 	"\tall\n"
2060 	"\tnone\n"));
2061 
2062 	for (ms = milestones; *ms != NULL; ms++)
2063 		(void) fprintf(stderr, "\t%s\n", *ms);
2064 
2065 	exit(UU_EXIT_USAGE);
2066 }
2067 
2068 static const char *
2069 validate_milestone(const char *milestone)
2070 {
2071 	const char **ms;
2072 	const char *tmp;
2073 	size_t len;
2074 
2075 	if (strcmp(milestone, "all") == 0)
2076 		return (milestone);
2077 
2078 	if (strcmp(milestone, "none") == 0)
2079 		return (milestone);
2080 
2081 	/*
2082 	 * Determine if this is a full or partial milestone
2083 	 */
2084 	for (ms = milestones; *ms != NULL; ms++) {
2085 		if ((tmp = strstr(*ms, milestone)) != NULL) {
2086 			len = strlen(milestone);
2087 
2088 			/*
2089 			 * The beginning of the string must align with the start
2090 			 * of a milestone fmri, or on the boundary between
2091 			 * elements.  The end of the string must align with the
2092 			 * end of the milestone, or at the instance boundary.
2093 			 */
2094 			if ((tmp == *ms || tmp[-1] == '/') &&
2095 			    (tmp[len] == '\0' || tmp[len] == ':'))
2096 				return (*ms);
2097 		}
2098 	}
2099 
2100 	(void) fprintf(stderr,
2101 	    gettext("\"%s\" is not a valid major milestone.\n"), milestone);
2102 
2103 	usage_milestone();
2104 	/* NOTREACHED */
2105 }
2106 
2107 /*PRINTFLIKE1*/
2108 static void
2109 pr_warn(const char *format, ...)
2110 {
2111 	const char *pname = uu_getpname();
2112 	va_list alist;
2113 
2114 	va_start(alist, format);
2115 
2116 	if (pname != NULL)
2117 		(void) fprintf(stderr, "%s", pname);
2118 
2119 	if (g_zonename != NULL)
2120 		(void) fprintf(stderr, " (%s)", g_zonename);
2121 
2122 	(void) fprintf(stderr, ": ");
2123 
2124 	(void) vfprintf(stderr, format, alist);
2125 
2126 	if (strrchr(format, '\n') == NULL)
2127 		(void) fprintf(stderr, ": %s\n", strerror(errno));
2128 
2129 	va_end(alist);
2130 }
2131 
2132 /*ARGSUSED*/
2133 static void
2134 quiet(const char *fmt, ...)
2135 {
2136 	/* Do nothing */
2137 }
2138 
2139 int
2140 main(int argc, char *argv[])
2141 {
2142 	int o;
2143 	int err;
2144 	int sw_back;
2145 	boolean_t do_zones = B_FALSE;
2146 	boolean_t do_a_zone = B_FALSE;
2147 	char zonename[ZONENAME_MAX];
2148 	uint_t nzents = 0, zent = 0;
2149 	zoneid_t *zids = NULL;
2150 	int orig_optind, orig_argc;
2151 	char **orig_argv;
2152 
2153 	(void) setlocale(LC_ALL, "");
2154 	(void) textdomain(TEXT_DOMAIN);
2155 
2156 	(void) uu_setpname(argv[0]);
2157 
2158 	if (argc < 2)
2159 		usage();
2160 
2161 	max_scf_fmri_sz = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
2162 	if (max_scf_fmri_sz < 0)
2163 		scfdie();
2164 	++max_scf_fmri_sz;
2165 
2166 	scratch_fmri = malloc(max_scf_fmri_sz);
2167 	if (scratch_fmri == NULL)
2168 		uu_die(emsg_nomem);
2169 
2170 	while ((o = getopt(argc, argv, "S:vZz:")) != -1) {
2171 		switch (o) {
2172 		case 'S':
2173 			(void) strlcpy(svcstate, optarg, sizeof (svcstate));
2174 			svcsearch = B_TRUE;
2175 			break;
2176 
2177 		case 'v':
2178 			verbose = 1;
2179 			break;
2180 
2181 		case 'z':
2182 			if (getzoneid() != GLOBAL_ZONEID)
2183 				uu_die(gettext("svcadm -z may only be used "
2184 				    "from the global zone\n"));
2185 			if (do_zones)
2186 				usage();
2187 
2188 			(void) strlcpy(zonename, optarg, sizeof (zonename));
2189 			do_a_zone = B_TRUE;
2190 			break;
2191 
2192 		case 'Z':
2193 			if (getzoneid() != GLOBAL_ZONEID)
2194 				uu_die(gettext("svcadm -Z may only be used "
2195 				    "from the global zone\n"));
2196 			if (do_a_zone)
2197 				usage();
2198 
2199 			do_zones = B_TRUE;
2200 			break;
2201 
2202 		default:
2203 			usage();
2204 		}
2205 	}
2206 
2207 	while (do_zones) {
2208 		uint_t found;
2209 
2210 		if (zone_list(NULL, &nzents) != 0)
2211 			uu_die(gettext("could not get number of zones"));
2212 
2213 		if ((zids = malloc(nzents * sizeof (zoneid_t))) == NULL) {
2214 			uu_die(gettext("could not allocate array for "
2215 			    "%d zone IDs"), nzents);
2216 		}
2217 
2218 		found = nzents;
2219 
2220 		if (zone_list(zids, &found) != 0)
2221 			uu_die(gettext("could not get zone list"));
2222 
2223 		/*
2224 		 * If the number of zones has not changed between our calls to
2225 		 * zone_list(), we're done -- otherwise, we must free our array
2226 		 * of zone IDs and take another lap.
2227 		 */
2228 		if (found == nzents)
2229 			break;
2230 
2231 		free(zids);
2232 	}
2233 
2234 	emsg_permission_denied = gettext("%s: Permission denied.\n");
2235 	emsg_nomem = gettext("Out of memory.\n");
2236 	emsg_create_pg_perm_denied = gettext("%s: Couldn't create \"%s\" "
2237 	    "property group (permission denied).\n");
2238 	emsg_pg_perm_denied = gettext("%s: Couldn't modify \"%s\" property "
2239 	    "group (permission denied).\n");
2240 	emsg_prop_perm_denied = gettext("%s: Couldn't modify \"%s/%s\" "
2241 	    "property (permission denied).\n");
2242 	emsg_no_service = gettext("No such service \"%s\".\n");
2243 
2244 	orig_optind = optind;
2245 	orig_argc = argc;
2246 	orig_argv = argv;
2247 
2248 again:
2249 	h = scf_handle_create(SCF_VERSION);
2250 	if (h == NULL)
2251 		scfdie();
2252 
2253 	if (do_zones) {
2254 		zone_status_t status;
2255 
2256 		if (zone_getattr(zids[zent], ZONE_ATTR_STATUS, &status,
2257 		    sizeof (status)) < 0 || status != ZONE_IS_RUNNING) {
2258 			/*
2259 			 * If this zone is not running or we cannot
2260 			 * get its status, we do not want to attempt
2261 			 * to bind an SCF handle to it, lest we
2262 			 * accidentally interfere with a zone that
2263 			 * is not yet running by looking up a door
2264 			 * to its svc.configd (which could potentially
2265 			 * block a mount with an EBUSY).
2266 			 */
2267 			zent++;
2268 			goto nextzone;
2269 		}
2270 
2271 		if (getzonenamebyid(zids[zent++], zonename,
2272 		    sizeof (zonename)) < 0) {
2273 			uu_warn(gettext("could not get name for "
2274 			    "zone %d; ignoring"), zids[zent - 1]);
2275 			goto nextzone;
2276 		}
2277 
2278 		g_zonename = zonename;
2279 	}
2280 
2281 	if (do_a_zone || do_zones) {
2282 		scf_value_t *zone;
2283 
2284 		if ((zone = scf_value_create(h)) == NULL)
2285 			scfdie();
2286 
2287 		if (scf_value_set_astring(zone, zonename) != SCF_SUCCESS)
2288 			scfdie();
2289 
2290 		if (scf_handle_decorate(h, "zone", zone) != SCF_SUCCESS) {
2291 			if (do_a_zone) {
2292 				uu_die(gettext("invalid zone '%s'\n"), optarg);
2293 			} else {
2294 				scf_value_destroy(zone);
2295 				goto nextzone;
2296 			}
2297 		}
2298 
2299 		scf_value_destroy(zone);
2300 	}
2301 
2302 	if (scf_handle_bind(h) == -1) {
2303 		if (do_zones)
2304 			goto nextzone;
2305 
2306 		uu_die(gettext("Couldn't bind to configuration repository: "
2307 		    "%s.\n"), scf_strerror(scf_error()));
2308 	}
2309 
2310 	optind = orig_optind;
2311 	argc = orig_argc;
2312 	argv = orig_argv;
2313 
2314 	if (optind >= argc)
2315 		usage();
2316 
2317 	if (strcmp(argv[optind], "enable") == 0) {
2318 		int flags = SET_ENABLED;
2319 		int wait = 0;
2320 		int error = 0;
2321 
2322 		++optind;
2323 
2324 		while ((o = getopt(argc, argv, "rst")) != -1) {
2325 			if (o == 'r')
2326 				flags |= SET_RECURSIVE;
2327 			else if (o == 't')
2328 				flags |= SET_TEMPORARY;
2329 			else if (o == 's')
2330 				wait = 1;
2331 			else if (o == '?')
2332 				usage();
2333 			else {
2334 				assert(0);
2335 				abort();
2336 			}
2337 		}
2338 		argc -= optind;
2339 		argv += optind;
2340 
2341 		if (argc == 0 && !svcsearch)
2342 			usage();
2343 
2344 		if (argc > 0 && svcsearch)
2345 			usage();
2346 
2347 		/*
2348 		 * We want to continue with -s processing if we had
2349 		 * invalid options, but not if an enable failed.  We
2350 		 * squelch output the second time we walk fmris; we saw
2351 		 * the errors the first time.
2352 		 */
2353 		if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2354 		    set_fmri_enabled, (void *)flags, &error, pr_warn)) != 0) {
2355 
2356 			pr_warn(gettext("failed to iterate over "
2357 			    "instances: %s\n"), scf_strerror(err));
2358 			exit_status = UU_EXIT_FATAL;
2359 
2360 		} else if (wait && exit_status == 0 &&
2361 		    (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2362 		    wait_fmri_enabled, (void *)flags, &error, quiet)) != 0) {
2363 
2364 			pr_warn(gettext("failed to iterate over "
2365 			    "instances: %s\n"), scf_strerror(err));
2366 			exit_status = UU_EXIT_FATAL;
2367 		}
2368 
2369 		if (error > 0)
2370 			exit_status = error;
2371 
2372 	} else if (strcmp(argv[optind], "disable") == 0) {
2373 		int flags = 0;
2374 		int wait = 0;
2375 		int error = 0;
2376 
2377 		++optind;
2378 
2379 		while ((o = getopt(argc, argv, "st")) != -1) {
2380 			if (o == 't')
2381 				flags |= SET_TEMPORARY;
2382 			else if (o == 's')
2383 				wait = 1;
2384 			else if (o == '?')
2385 				usage();
2386 			else {
2387 				assert(0);
2388 				abort();
2389 			}
2390 		}
2391 		argc -= optind;
2392 		argv += optind;
2393 
2394 		if (argc == 0 && !svcsearch)
2395 			usage();
2396 
2397 		if (argc > 0 && svcsearch)
2398 			usage();
2399 
2400 		/*
2401 		 * We want to continue with -s processing if we had
2402 		 * invalid options, but not if a disable failed.  We
2403 		 * squelch output the second time we walk fmris; we saw
2404 		 * the errors the first time.
2405 		 */
2406 		if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2407 		    set_fmri_enabled, (void *)flags, &exit_status,
2408 		    pr_warn)) != 0) {
2409 
2410 			pr_warn(gettext("failed to iterate over "
2411 			    "instances: %s\n"), scf_strerror(err));
2412 			exit_status = UU_EXIT_FATAL;
2413 
2414 		} else if (wait && exit_status == 0 &&
2415 		    (err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2416 		    wait_fmri_disabled, (void *)flags, &error, quiet)) != 0) {
2417 
2418 			pr_warn(gettext("failed to iterate over "
2419 			    "instances: %s\n"), scf_strerror(err));
2420 			exit_status = UU_EXIT_FATAL;
2421 		}
2422 
2423 		if (error > 0)
2424 			exit_status = error;
2425 
2426 	} else if (strcmp(argv[optind], "restart") == 0) {
2427 		boolean_t do_dump = B_FALSE;
2428 
2429 		++optind;
2430 
2431 		while ((o = getopt(argc, argv, "d")) != -1) {
2432 			if (o == 'd')
2433 				do_dump = B_TRUE;
2434 			else if (o == '?')
2435 				usage();
2436 			else {
2437 				assert(0);
2438 				abort();
2439 			}
2440 		}
2441 		argc -= optind;
2442 		argv += optind;
2443 
2444 		if (argc == 0 && !svcsearch)
2445 			usage();
2446 
2447 		if (argc > 0 && svcsearch)
2448 			usage();
2449 
2450 		if (do_dump) {
2451 			if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2452 			    set_fmri_action, (void *)SCF_PROPERTY_DODUMP,
2453 			    &exit_status, pr_warn)) != 0) {
2454 				pr_warn(gettext("failed to iterate over "
2455 				    "instances: %s\n"), scf_strerror(err));
2456 				exit_status = UU_EXIT_FATAL;
2457 			}
2458 		}
2459 
2460 		if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2461 		    set_fmri_action, (void *)SCF_PROPERTY_RESTART, &exit_status,
2462 		    pr_warn)) != 0) {
2463 			pr_warn(gettext("failed to iterate over "
2464 			    "instances: %s\n"), scf_strerror(err));
2465 			exit_status = UU_EXIT_FATAL;
2466 		}
2467 
2468 	} else if (strcmp(argv[optind], "refresh") == 0) {
2469 		++optind;
2470 		argc -= optind;
2471 		argv += optind;
2472 
2473 		if (argc == 0 && !svcsearch)
2474 			usage();
2475 
2476 		if (argc > 0 && svcsearch)
2477 			usage();
2478 
2479 		if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2480 		    set_fmri_action, (void *)SCF_PROPERTY_REFRESH, &exit_status,
2481 		    pr_warn)) != 0) {
2482 			pr_warn(gettext("failed to iterate over "
2483 			    "instances: %s\n"), scf_strerror(scf_error()));
2484 			exit_status = UU_EXIT_FATAL;
2485 		}
2486 
2487 	} else if (strcmp(argv[optind], "mark") == 0) {
2488 		int flags = 0;
2489 		scf_walk_callback callback;
2490 
2491 		++optind;
2492 
2493 		while ((o = getopt(argc, argv, "It")) != -1) {
2494 			if (o == 'I')
2495 				flags |= MARK_IMMEDIATE;
2496 			else if (o == 't')
2497 				flags |= MARK_TEMPORARY;
2498 			else if (o == '?')
2499 				usage();
2500 			else {
2501 				assert(0);
2502 				abort();
2503 			}
2504 		}
2505 
2506 		if (argc - optind < 2)
2507 			usage();
2508 
2509 		if (strcmp(argv[optind], "degraded") == 0) {
2510 			if (flags & MARK_TEMPORARY)
2511 				uu_xdie(UU_EXIT_USAGE, gettext("-t may not be "
2512 				    "used with degraded.\n"));
2513 			callback = force_degraded;
2514 
2515 		} else if (strcmp(argv[optind], "maintenance") == 0) {
2516 			callback = force_maintenance;
2517 		} else {
2518 			usage();
2519 		}
2520 
2521 		optind++;
2522 		argc -= optind;
2523 		argv += optind;
2524 
2525 		if (argc == 0 && !svcsearch)
2526 			usage();
2527 
2528 		if (argc > 0 && svcsearch)
2529 			usage();
2530 
2531 		if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS, callback,
2532 		    NULL, &exit_status, pr_warn)) != 0) {
2533 			pr_warn(gettext("failed to iterate over "
2534 			    "instances: %s\n"),
2535 			    scf_strerror(err));
2536 			exit_status = UU_EXIT_FATAL;
2537 		}
2538 
2539 	} else if (strcmp(argv[optind], "clear") == 0) {
2540 		++optind;
2541 		argc -= optind;
2542 		argv += optind;
2543 
2544 		if (argc == 0 && !svcsearch)
2545 			usage();
2546 
2547 		if (svcsearch) {
2548 			if (argc > 0)
2549 				usage();
2550 			if (strcmp(svcstate, SCF_STATE_STRING_MAINT) != 0 &&
2551 			    strcmp(svcstate, SCF_STATE_STRING_DEGRADED) != 0)
2552 				uu_die(gettext("State must be '%s' or '%s'\n"),
2553 				    SCF_STATE_STRING_MAINT,
2554 				    SCF_STATE_STRING_DEGRADED);
2555 		}
2556 
2557 		if ((err = scf_walk_fmri(h, argc, argv, WALK_FLAGS,
2558 		    clear_instance, NULL, &exit_status, pr_warn)) != 0) {
2559 			pr_warn(gettext("failed to iterate over "
2560 			    "instances: %s\n"), scf_strerror(err));
2561 			exit_status = UU_EXIT_FATAL;
2562 		}
2563 
2564 	} else if (strcmp(argv[optind], "milestone") == 0) {
2565 		boolean_t temporary = B_TRUE;
2566 		const char *milestone;
2567 
2568 		++optind;
2569 
2570 		while ((o = getopt(argc, argv, "d")) != -1) {
2571 			if (o == 'd')
2572 				temporary = B_FALSE;
2573 			else if (o == '?')
2574 				usage_milestone();
2575 			else {
2576 				assert(0);
2577 				abort();
2578 			}
2579 		}
2580 
2581 		if (optind >= argc)
2582 			usage_milestone();
2583 
2584 		milestone = validate_milestone(argv[optind]);
2585 
2586 		set_milestone(milestone, temporary);
2587 	} else if (strcmp(argv[optind], "_smf_backup") == 0) {
2588 		const char *reason = NULL;
2589 
2590 		++optind;
2591 
2592 		if (optind != argc - 1)
2593 			usage();
2594 
2595 		if ((err = _scf_request_backup(h, argv[optind])) !=
2596 		    SCF_SUCCESS) {
2597 			switch (scf_error()) {
2598 			case SCF_ERROR_NOT_BOUND:
2599 			case SCF_ERROR_CONNECTION_BROKEN:
2600 			case SCF_ERROR_BACKEND_READONLY:
2601 				scfdie();
2602 				break;
2603 
2604 			case SCF_ERROR_PERMISSION_DENIED:
2605 			case SCF_ERROR_INVALID_ARGUMENT:
2606 				reason = scf_strerror(scf_error());
2607 				break;
2608 
2609 			case SCF_ERROR_INTERNAL:
2610 				reason =
2611 				    "unknown error (see console for details)";
2612 				break;
2613 			}
2614 
2615 			pr_warn("failed to backup repository: %s\n", reason);
2616 			exit_status = UU_EXIT_FATAL;
2617 		}
2618 	} else if (strcmp(argv[optind], "_smf_repository_switch") == 0) {
2619 		const char *reason = NULL;
2620 
2621 		++optind;
2622 
2623 		/*
2624 		 * Check argument and setup scf_switch structure
2625 		 */
2626 		if (optind != argc - 1)
2627 			exit(1);
2628 
2629 		if (strcmp(argv[optind], "fast") == 0) {
2630 			sw_back = 0;
2631 		} else if (strcmp(argv[optind], "perm") == 0) {
2632 			sw_back = 1;
2633 		} else {
2634 			exit(UU_EXIT_USAGE);
2635 		}
2636 
2637 		/*
2638 		 * Call into switch primitive
2639 		 */
2640 		if ((err = _scf_repository_switch(h, sw_back)) !=
2641 		    SCF_SUCCESS) {
2642 			/*
2643 			 * Retrieve per thread SCF error code
2644 			 */
2645 			switch (scf_error()) {
2646 			case SCF_ERROR_NOT_BOUND:
2647 				abort();
2648 				/* NOTREACHED */
2649 
2650 			case SCF_ERROR_CONNECTION_BROKEN:
2651 			case SCF_ERROR_BACKEND_READONLY:
2652 				scfdie();
2653 				/* NOTREACHED */
2654 
2655 			case SCF_ERROR_PERMISSION_DENIED:
2656 			case SCF_ERROR_INVALID_ARGUMENT:
2657 				reason = scf_strerror(scf_error());
2658 				break;
2659 
2660 			case SCF_ERROR_INTERNAL:
2661 				reason = "File operation error: (see console)";
2662 				break;
2663 
2664 			default:
2665 				abort();
2666 				/* NOTREACHED */
2667 			}
2668 
2669 			pr_warn("failed to switch repository: %s\n", reason);
2670 			exit_status = UU_EXIT_FATAL;
2671 		}
2672 	} else {
2673 		usage();
2674 	}
2675 
2676 	if (scf_handle_unbind(h) == -1)
2677 		scfdie();
2678 nextzone:
2679 	scf_handle_destroy(h);
2680 	if (do_zones && zent < nzents)
2681 		goto again;
2682 
2683 	return (exit_status);
2684 }
2685