xref: /titanic_41/usr/src/cmd/svc/svcprop/svcprop.c (revision 647f844472a221fb1f7025c8391adb4db2be23b6)
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 2007 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*
28  * Copyright (c) 2011, Joyent, Inc. All rights reserved.
29  */
30 
31 /*
32  * svcprop - report service configuration properties
33  */
34 
35 #include <locale.h>
36 #include <libintl.h>
37 #include <libscf.h>
38 #include <libscf_priv.h>
39 #include <libuutil.h>
40 #include <stddef.h>
41 #include <stdio.h>
42 #include <stdlib.h>
43 #include <unistd.h>
44 #include <strings.h>
45 #include <assert.h>
46 #include <zone.h>
47 
48 #ifndef TEXT_DOMAIN
49 #define	TEXT_DOMAIN	"SUNW_OST_OSCMD"
50 #endif /* TEXT_DOMAIN */
51 
52 /*
53  * Error functions.  These can change if the quiet (-q) option is used.
54  */
55 static void (*warn)(const char *, ...) = uu_warn;
56 static void (*die)(const char *, ...) = uu_die;
57 
58 /*
59  * Entity encapsulation.  This allows me to treat services and instances
60  * similarly, and avoid duplicating process_ent().
61  */
62 typedef struct {
63 	char type;			/* !=0: service, 0: instance */
64 	union {
65 		scf_service_t *svc;
66 		scf_instance_t *inst;
67 	} u;
68 } scf_entityp_t;
69 
70 #define	ENT_INSTANCE	0
71 
72 #define	SCF_ENTITY_SET_TO_SERVICE(ent, s)	{ ent.type = 1; ent.u.svc = s; }
73 
74 #define	SCF_ENTITY_SET_TO_INSTANCE(ent, i)	\
75 	{ ent.type = ENT_INSTANCE; ent.u.inst = i; }
76 
77 #define	scf_entity_get_pg(ent, name, pg) \
78 	(ent.type ? scf_service_get_pg(ent.u.svc, name, pg) : \
79 	scf_instance_get_pg(ent.u.inst, name, pg))
80 
81 #define	scf_entity_to_fmri(ent, buf, buf_sz) \
82 	(ent.type ? scf_service_to_fmri(ent.u.svc, buf, buf_sz) : \
83 	scf_instance_to_fmri(ent.u.inst, buf, buf_sz))
84 
85 #define	SCF_ENTITY_TYPE_NAME(ent)	(ent.type ? "service" : "instance")
86 
87 /*
88  * Data structure for -p arguments.  Since they may be name or name/name, we
89  * just track the components.
90  */
91 typedef struct svcprop_prop_node {
92 	uu_list_node_t	spn_list_node;
93 	const char	*spn_comp1;
94 	const char	*spn_comp2;
95 } svcprop_prop_node_t;
96 
97 static uu_list_pool_t	*prop_pool;
98 static uu_list_t	*prop_list;
99 
100 static scf_handle_t *hndl;
101 static ssize_t max_scf_name_length;
102 static ssize_t max_scf_value_length;
103 static ssize_t max_scf_fmri_length;
104 
105 /* Options */
106 static int quiet = 0;			/* No output. Nothing found, exit(1) */
107 static int types = 0;			/* Display types of properties. */
108 static int verbose = 0;			/* Print not found errors to stderr. */
109 static int fmris = 0;			/* Display full FMRIs for properties. */
110 static int wait = 0;			/* Wait mode. */
111 static char *snapshot = "running";	/* Snapshot to use. */
112 static int Cflag = 0;			/* C option supplied */
113 static int cflag = 0;			/* c option supplied */
114 static int sflag = 0;			/* s option supplied */
115 static int return_code;			/* main's return code */
116 
117 #define	PRINT_NOPROP_ERRORS	(!quiet || verbose)
118 
119 /*
120  * For unexpected libscf errors.  The ending newline is necessary to keep
121  * uu_die() from appending the errno error.
122  */
123 static void
scfdie()124 scfdie()
125 {
126 	die(gettext("Unexpected libscf error: %s.  Exiting.\n"),
127 	    scf_strerror(scf_error()));
128 }
129 
130 static void *
safe_malloc(size_t sz)131 safe_malloc(size_t sz)
132 {
133 	void *p;
134 
135 	p = malloc(sz);
136 	if (p == NULL)
137 		die(gettext("Could not allocate memory"));
138 
139 	return (p);
140 }
141 
142 static void
usage()143 usage()
144 {
145 	(void) fprintf(stderr, gettext("Usage: %1$s [-fqtv] "
146 	    "[-C | -c | -s snapshot] [-z zone] "
147 	    "[-p [name/]name]... \n"
148 	    "         {FMRI | pattern}...\n"
149 	    "       %1$s -w [-fqtv] [-z zone] [-p [name/]name] "
150 	    "{FMRI | pattern}\n"), uu_getpname());
151 	exit(UU_EXIT_USAGE);
152 }
153 
154 /*
155  * Return an allocated copy of str, with the Bourne shell's metacharacters
156  * escaped by '\'.
157  *
158  * What about unicode?
159  */
160 static char *
quote_for_shell(const char * str)161 quote_for_shell(const char *str)
162 {
163 	const char *sp;
164 	char *dst, *dp;
165 	size_t dst_len;
166 
167 	const char * const metachars = ";&()|^<>\n \t\\\"\'`";
168 
169 	if (str[0] == '\0')
170 		return (strdup("\"\""));
171 
172 	dst_len = 0;
173 	for (sp = str; *sp != '\0'; ++sp) {
174 		++dst_len;
175 
176 		if (strchr(metachars, *sp) != NULL)
177 			++dst_len;
178 	}
179 
180 	if (sp - str == dst_len)
181 		return (strdup(str));
182 
183 	dst = safe_malloc(dst_len + 1);
184 
185 	for (dp = dst, sp = str; *sp != '\0'; ++dp, ++sp) {
186 		if (strchr(metachars, *sp) != NULL)
187 			*dp++ = '\\';
188 
189 		*dp = *sp;
190 	}
191 	*dp = '\0';
192 
193 	return (dst);
194 }
195 
196 static void
print_value(scf_value_t * val)197 print_value(scf_value_t *val)
198 {
199 	char *buf, *qbuf;
200 	ssize_t bufsz, r;
201 
202 	bufsz = scf_value_get_as_string(val, NULL, 0) + 1;
203 	if (bufsz - 1 < 0)
204 		scfdie();
205 
206 	buf = safe_malloc(bufsz);
207 
208 	r = scf_value_get_as_string(val, buf, bufsz);
209 	assert(r + 1 == bufsz);
210 
211 	qbuf = quote_for_shell(buf);
212 	(void) fputs(qbuf, stdout);
213 
214 	free(qbuf);
215 	free(buf);
216 }
217 
218 /*
219  * Display a property's values on a line.  If types is true, prepend
220  * identification (the FMRI if fmris is true, pg/prop otherwise) and the type
221  * of the property.
222  */
223 static void
display_prop(scf_propertygroup_t * pg,scf_property_t * prop)224 display_prop(scf_propertygroup_t *pg, scf_property_t *prop)
225 {
226 	scf_value_t *val;
227 	scf_iter_t *iter;
228 	int ret, first, err;
229 
230 	const char * const permission_denied_emsg =
231 	    gettext("Permission denied.\n");
232 
233 	if (types) {
234 		scf_type_t ty;
235 		char *buf;
236 		size_t buf_sz;
237 
238 		if (fmris) {
239 			buf_sz = max_scf_fmri_length + 1;
240 			buf = safe_malloc(buf_sz);
241 
242 			if (scf_property_to_fmri(prop, buf, buf_sz) == -1)
243 				scfdie();
244 			(void) fputs(buf, stdout);
245 
246 			free(buf);
247 		} else {
248 			buf_sz = max_scf_name_length + 1;
249 			buf = safe_malloc(buf_sz);
250 
251 			if (scf_pg_get_name(pg, buf, buf_sz) < 0)
252 				scfdie();
253 			(void) fputs(buf, stdout);
254 			(void) putchar('/');
255 
256 			if (scf_property_get_name(prop, buf, buf_sz) < 0)
257 				scfdie();
258 			(void) fputs(buf, stdout);
259 
260 			free(buf);
261 		}
262 
263 		(void) putchar(' ');
264 
265 		if (scf_property_type(prop, &ty) == -1)
266 			scfdie();
267 		(void) fputs(scf_type_to_string(ty), stdout);
268 		(void) putchar(' ');
269 	}
270 
271 	if ((iter = scf_iter_create(hndl)) == NULL ||
272 	    (val = scf_value_create(hndl)) == NULL)
273 		scfdie();
274 
275 	if (scf_iter_property_values(iter, prop) == -1)
276 		scfdie();
277 
278 	first = 1;
279 	while ((ret = scf_iter_next_value(iter, val)) == 1) {
280 		if (first)
281 			first = 0;
282 		else
283 			(void) putchar(' ');
284 		print_value(val);
285 	}
286 	if (ret == -1) {
287 		err = scf_error();
288 		if (err == SCF_ERROR_PERMISSION_DENIED) {
289 			if (uu_list_numnodes(prop_list) > 0)
290 				die(permission_denied_emsg);
291 		} else {
292 			scfdie();
293 		}
294 	}
295 
296 	(void) putchar('\n');
297 
298 	scf_iter_destroy(iter);
299 	(void) scf_value_destroy(val);
300 }
301 
302 /*
303  * display_prop() all of the properties in the given property group.  Force
304  * types to true so identification will be displayed.
305  */
306 static void
display_pg(scf_propertygroup_t * pg)307 display_pg(scf_propertygroup_t *pg)
308 {
309 	scf_property_t *prop;
310 	scf_iter_t *iter;
311 	int ret;
312 
313 	types = 1;	/* Always display types for whole propertygroups. */
314 
315 	if ((prop = scf_property_create(hndl)) == NULL ||
316 	    (iter = scf_iter_create(hndl)) == NULL)
317 		scfdie();
318 
319 	if (scf_iter_pg_properties(iter, pg) == -1)
320 		scfdie();
321 
322 	while ((ret = scf_iter_next_property(iter, prop)) == 1)
323 		display_prop(pg, prop);
324 	if (ret == -1)
325 		scfdie();
326 
327 	scf_iter_destroy(iter);
328 	scf_property_destroy(prop);
329 }
330 
331 /*
332  * Common code to execute when a nonexistant property is encountered.
333  */
334 static void
noprop_common_action()335 noprop_common_action()
336 {
337 	if (!PRINT_NOPROP_ERRORS)
338 		/* We're not printing errors, so we can cut out early. */
339 		exit(UU_EXIT_FATAL);
340 
341 	return_code = UU_EXIT_FATAL;
342 }
343 
344 /*
345  * Iterate the properties of a service or an instance when no snapshot
346  * is specified.
347  */
348 static int
scf_iter_entity_pgs(scf_iter_t * iter,scf_entityp_t ent)349 scf_iter_entity_pgs(scf_iter_t *iter, scf_entityp_t ent)
350 {
351 	int ret = 0;
352 
353 	if (ent.type) {
354 		/*
355 		 * If we are displaying properties for a service,
356 		 * treat it as though it were a composed, current
357 		 * lookup. (implicit cflag) However, if a snapshot
358 		 * was specified, fail.
359 		 */
360 		if (sflag)
361 			die(gettext("Only instances have "
362 			    "snapshots.\n"));
363 		ret = scf_iter_service_pgs(iter, ent.u.svc);
364 	} else {
365 		if (Cflag)
366 			ret = scf_iter_instance_pgs(iter, ent.u.inst);
367 		else
368 			ret = scf_iter_instance_pgs_composed(iter, ent.u.inst,
369 			    NULL);
370 	}
371 	return (ret);
372 }
373 
374 /*
375  * Return a snapshot for the supplied instance and snapshot name.
376  */
377 static scf_snapshot_t *
get_snapshot(const scf_instance_t * inst,const char * snapshot)378 get_snapshot(const scf_instance_t *inst, const char *snapshot)
379 {
380 	scf_snapshot_t *snap = scf_snapshot_create(hndl);
381 
382 	if (snap == NULL)
383 		scfdie();
384 
385 	if (scf_instance_get_snapshot(inst, snapshot, snap) == -1) {
386 		switch (scf_error()) {
387 		case SCF_ERROR_INVALID_ARGUMENT:
388 			die(gettext("Invalid snapshot name.\n"));
389 			/* NOTREACHED */
390 
391 		case SCF_ERROR_NOT_FOUND:
392 			if (sflag == 0) {
393 				scf_snapshot_destroy(snap);
394 				snap = NULL;
395 			} else
396 				die(gettext("No such snapshot.\n"));
397 			break;
398 
399 		default:
400 			scfdie();
401 		}
402 	}
403 
404 	return (snap);
405 }
406 
407 /*
408  * Entity (service or instance): If there are -p options,
409  * display_{pg,prop}() the named property groups and/or properties.  Otherwise
410  * display_pg() all property groups.
411  */
412 static void
process_ent(scf_entityp_t ent)413 process_ent(scf_entityp_t ent)
414 {
415 	scf_snapshot_t *snap = NULL;
416 	scf_propertygroup_t *pg;
417 	scf_property_t *prop;
418 	scf_iter_t *iter;
419 	svcprop_prop_node_t *spn;
420 	int ret, err;
421 
422 	if (uu_list_numnodes(prop_list) == 0) {
423 		if (quiet)
424 			return;
425 
426 		if ((pg = scf_pg_create(hndl)) == NULL ||
427 		    (iter = scf_iter_create(hndl)) == NULL)
428 			scfdie();
429 
430 		if (cflag || Cflag || ent.type != ENT_INSTANCE) {
431 			if (scf_iter_entity_pgs(iter, ent) == -1)
432 				scfdie();
433 		} else {
434 			if (snapshot != NULL)
435 				snap = get_snapshot(ent.u.inst, snapshot);
436 
437 			if (scf_iter_instance_pgs_composed(iter, ent.u.inst,
438 			    snap) == -1)
439 				scfdie();
440 			if (snap)
441 				scf_snapshot_destroy(snap);
442 		}
443 
444 		while ((ret = scf_iter_next_pg(iter, pg)) == 1)
445 			display_pg(pg);
446 		if (ret == -1)
447 			scfdie();
448 
449 		/*
450 		 * In normal usage, i.e. against the running snapshot,
451 		 * we must iterate over the current non-persistent
452 		 * pg's.
453 		 */
454 		if (sflag == 0 && snap != NULL) {
455 			scf_iter_reset(iter);
456 			if (scf_iter_instance_pgs_composed(iter, ent.u.inst,
457 			    NULL) == -1)
458 				scfdie();
459 			while ((ret = scf_iter_next_pg(iter, pg)) == 1) {
460 				uint32_t flags;
461 
462 				if (scf_pg_get_flags(pg, &flags) == -1)
463 					scfdie();
464 				if (flags & SCF_PG_FLAG_NONPERSISTENT)
465 					display_pg(pg);
466 			}
467 		}
468 		if (ret == -1)
469 			scfdie();
470 
471 		scf_iter_destroy(iter);
472 		scf_pg_destroy(pg);
473 
474 		return;
475 	}
476 
477 	if ((pg = scf_pg_create(hndl)) == NULL ||
478 	    (prop = scf_property_create(hndl)) == NULL)
479 		scfdie();
480 
481 	if (ent.type == ENT_INSTANCE && snapshot != NULL)
482 		snap = get_snapshot(ent.u.inst, snapshot);
483 
484 	for (spn = uu_list_first(prop_list);
485 	    spn != NULL;
486 	    spn = uu_list_next(prop_list, spn)) {
487 		if (ent.type == ENT_INSTANCE) {
488 			if (Cflag)
489 				ret = scf_instance_get_pg(ent.u.inst,
490 				    spn->spn_comp1, pg);
491 			else
492 				ret = scf_instance_get_pg_composed(ent.u.inst,
493 				    snap, spn->spn_comp1, pg);
494 			err = scf_error();
495 
496 			/*
497 			 * If we didn't find it in the specified snapshot, use
498 			 * the current values if the pg is nonpersistent.
499 			 */
500 			if (ret == -1 && !Cflag &&snap != NULL && err ==
501 			    SCF_ERROR_NOT_FOUND) {
502 				ret = scf_instance_get_pg_composed(
503 				    ent.u.inst, NULL, spn->spn_comp1,
504 				    pg);
505 
506 				if (ret == 0) {
507 					uint32_t flags;
508 
509 					if (scf_pg_get_flags(pg, &flags) == -1)
510 						scfdie();
511 					if ((flags & SCF_PG_FLAG_NONPERSISTENT)
512 					    == 0) {
513 						ret = -1;
514 					}
515 				}
516 			}
517 		} else {
518 			/*
519 			 * If we are displaying properties for a service,
520 			 * treat it as though it were a composed, current
521 			 * lookup. (implicit cflag) However, if a snapshot
522 			 * was specified, fail.
523 			 */
524 			if (sflag)
525 				die(gettext("Only instances have "
526 				    "snapshots.\n"));
527 			ret = scf_entity_get_pg(ent, spn->spn_comp1, pg);
528 			err = scf_error();
529 		}
530 		if (ret == -1) {
531 			if (err != SCF_ERROR_NOT_FOUND)
532 				scfdie();
533 
534 			if (PRINT_NOPROP_ERRORS) {
535 				char *buf;
536 
537 				buf = safe_malloc(max_scf_fmri_length + 1);
538 				if (scf_entity_to_fmri(ent, buf,
539 				    max_scf_fmri_length + 1) == -1)
540 					scfdie();
541 
542 				uu_warn(gettext("Couldn't find property group "
543 				    "`%s' for %s `%s'.\n"), spn->spn_comp1,
544 				    SCF_ENTITY_TYPE_NAME(ent), buf);
545 
546 				free(buf);
547 			}
548 
549 			noprop_common_action();
550 
551 			continue;
552 		}
553 
554 		if (spn->spn_comp2 == NULL) {
555 			if (!quiet)
556 				display_pg(pg);
557 			continue;
558 		}
559 
560 		if (scf_pg_get_property(pg, spn->spn_comp2, prop) == -1) {
561 			if (scf_error() != SCF_ERROR_NOT_FOUND)
562 				scfdie();
563 
564 			if (PRINT_NOPROP_ERRORS) {
565 				char *buf;
566 
567 				buf = safe_malloc(max_scf_fmri_length + 1);
568 				if (scf_entity_to_fmri(ent, buf,
569 				    max_scf_fmri_length + 1) == -1)
570 					scfdie();
571 
572 				/* FMRI syntax knowledge */
573 				uu_warn(gettext("Couldn't find property "
574 				    "`%s/%s' for %s `%s'.\n"), spn->spn_comp1,
575 				    spn->spn_comp2, SCF_ENTITY_TYPE_NAME(ent),
576 				    buf);
577 
578 				free(buf);
579 			}
580 
581 			noprop_common_action();
582 
583 			continue;
584 		}
585 
586 		if (!quiet)
587 			display_prop(pg, prop);
588 	}
589 
590 	scf_property_destroy(prop);
591 	scf_pg_destroy(pg);
592 	if (snap)
593 		scf_snapshot_destroy(snap);
594 }
595 
596 /*
597  * Without -p options, just call display_pg().  Otherwise display_prop() the
598  * named properties of the property group.
599  */
600 static void
process_pg(scf_propertygroup_t * pg)601 process_pg(scf_propertygroup_t *pg)
602 {
603 	scf_property_t *prop;
604 	svcprop_prop_node_t *spn;
605 
606 	if (uu_list_first(prop_list) == NULL) {
607 		if (quiet)
608 			return;
609 
610 		display_pg(pg);
611 		return;
612 	}
613 
614 	prop = scf_property_create(hndl);
615 	if (prop == NULL)
616 		scfdie();
617 
618 	for (spn = uu_list_first(prop_list);
619 	    spn != NULL;
620 	    spn = uu_list_next(prop_list, spn)) {
621 		if (spn->spn_comp2 != NULL) {
622 			char *buf;
623 
624 			buf = safe_malloc(max_scf_fmri_length + 1);
625 			if (scf_pg_to_fmri(pg, buf, max_scf_fmri_length + 1) ==
626 			    -1)
627 				scfdie();
628 
629 			uu_xdie(UU_EXIT_USAGE, gettext("-p argument `%s/%s' "
630 			    "has too many components for property "
631 			    "group `%s'.\n"), spn->spn_comp1, spn->spn_comp2,
632 			    buf);
633 
634 			free(buf);
635 		}
636 
637 		if (scf_pg_get_property(pg, spn->spn_comp1, prop) == 0) {
638 			if (!quiet)
639 				display_prop(pg, prop);
640 			continue;
641 		}
642 
643 		if (scf_error() != SCF_ERROR_NOT_FOUND)
644 			scfdie();
645 
646 		if (PRINT_NOPROP_ERRORS) {
647 			char *buf;
648 
649 			buf = safe_malloc(max_scf_fmri_length + 1);
650 			if (scf_pg_to_fmri(pg, buf, max_scf_fmri_length + 1) ==
651 			    -1)
652 				scfdie();
653 
654 			uu_warn(gettext("Couldn't find property `%s' in "
655 			    "property group `%s'.\n"), spn->spn_comp1, buf);
656 
657 			free(buf);
658 		}
659 
660 		noprop_common_action();
661 	}
662 }
663 
664 /*
665  * If there are -p options, show the error.  Otherwise just call
666  * display_prop().
667  */
668 static void
process_prop(scf_propertygroup_t * pg,scf_property_t * prop)669 process_prop(scf_propertygroup_t *pg, scf_property_t *prop)
670 {
671 	if (uu_list_first(prop_list) != NULL) {
672 		uu_warn(gettext("The -p option cannot be used with property "
673 		    "operands.\n"));
674 		usage();
675 	}
676 
677 	if (quiet)
678 		return;
679 
680 	display_prop(pg, prop);
681 }
682 
683 /* Decode an operand & dispatch. */
684 /* ARGSUSED */
685 static int
process_fmri(void * unused,scf_walkinfo_t * wip)686 process_fmri(void *unused, scf_walkinfo_t *wip)
687 {
688 	scf_entityp_t ent;
689 
690 	/* Multiple matches imply multiple entities. */
691 	if (wip->count > 1)
692 		types = fmris = 1;
693 
694 	if (wip->prop != NULL) {
695 		process_prop(wip->pg, wip->prop);
696 	} else if (wip->pg != NULL) {
697 		process_pg(wip->pg);
698 	} else if (wip->inst != NULL) {
699 		SCF_ENTITY_SET_TO_INSTANCE(ent, wip->inst);
700 		process_ent(ent);
701 	} else {
702 		/* scf_walk_fmri() won't let this happen */
703 		assert(wip->svc != NULL);
704 		SCF_ENTITY_SET_TO_SERVICE(ent, wip->svc);
705 		process_ent(ent);
706 	}
707 
708 	return (0);
709 }
710 
711 static void
add_prop(char * property)712 add_prop(char *property)
713 {
714 	svcprop_prop_node_t *p, *last;
715 	char *slash;
716 
717 	const char * const invalid_component_emsg =
718 	    gettext("Invalid component name `%s'.\n");
719 
720 	/* FMRI syntax knowledge. */
721 	slash = strchr(property, '/');
722 	if (slash != NULL) {
723 		if (strchr(slash + 1, '/') != NULL) {
724 			uu_warn(gettext("-p argument `%s' has too many "
725 			    "components.\n"), property);
726 			usage();
727 		}
728 	}
729 
730 	if (slash != NULL)
731 		*slash = '\0';
732 
733 	p = safe_malloc(sizeof (svcprop_prop_node_t));
734 	uu_list_node_init(p, &p->spn_list_node, prop_pool);
735 
736 	p->spn_comp1 = property;
737 	p->spn_comp2 = (slash == NULL) ? NULL : slash + 1;
738 
739 	if (uu_check_name(p->spn_comp1, UU_NAME_DOMAIN) == -1)
740 		uu_xdie(UU_EXIT_USAGE, invalid_component_emsg, p->spn_comp1);
741 	if (p->spn_comp2 != NULL &&
742 	    uu_check_name(p->spn_comp2, UU_NAME_DOMAIN) == -1)
743 		uu_xdie(UU_EXIT_USAGE, invalid_component_emsg, p->spn_comp2);
744 
745 	last = uu_list_last(prop_list);
746 	if (last != NULL) {
747 		if ((last->spn_comp2 == NULL) ^ (p->spn_comp2 == NULL)) {
748 			/*
749 			 * The -p options have mixed numbers of components.
750 			 * If they both turn out to be valid, then the
751 			 * single-component ones will specify property groups,
752 			 * so we need to turn on types to keep the output of
753 			 * display_prop() consistent with display_pg().
754 			 */
755 			types = 1;
756 		}
757 	}
758 
759 	(void) uu_list_insert_after(prop_list, NULL, p);
760 }
761 
762 
763 /*
764  * Wait for a property group or property change.
765  *
766  * Extract a pg and optionally a property name from fmri & prop_list.
767  * _scf_pg_wait() for the pg, and display_pg(pg) or display_prop(pg, prop)
768  * when it returns.
769  */
770 /* ARGSUSED */
771 static int
do_wait(void * unused,scf_walkinfo_t * wip)772 do_wait(void *unused, scf_walkinfo_t *wip)
773 {
774 	scf_property_t *prop;
775 	scf_propertygroup_t *lpg, *pg;
776 	const char *propname;
777 	svcprop_prop_node_t *p;
778 
779 	const char *emsg_not_found = gettext("Not found.\n");
780 
781 	if ((lpg = scf_pg_create(hndl)) == NULL ||
782 	    (prop = scf_property_create(hndl)) == NULL)
783 		scfdie();
784 
785 	if (wip->prop != NULL) {
786 		if (uu_list_numnodes(prop_list) > 0)
787 			uu_xdie(UU_EXIT_USAGE, gettext("-p cannot be used with "
788 			    "property FMRIs.\n"));
789 		pg = wip->pg;
790 
791 		assert(strrchr(wip->fmri, '/') != NULL);
792 		propname = strrchr(wip->fmri, '/') + 1;
793 
794 	} else if (wip->pg != NULL) {
795 		p = uu_list_first(prop_list);
796 
797 		if (p != NULL) {
798 			if (p->spn_comp2 != NULL)
799 				uu_xdie(UU_EXIT_USAGE, gettext("-p argument "
800 				    "\"%s/%s\" has too many components for "
801 				    "property group %s.\n"),
802 				    p->spn_comp1, p->spn_comp2, wip->fmri);
803 
804 			propname = p->spn_comp1;
805 
806 			if (scf_pg_get_property(wip->pg, propname, prop) !=
807 			    SCF_SUCCESS) {
808 				switch (scf_error()) {
809 				case SCF_ERROR_INVALID_ARGUMENT:
810 					uu_xdie(UU_EXIT_USAGE,
811 					    gettext("Invalid property name "
812 					    "\"%s\".\n"), propname);
813 
814 					/* NOTREACHED */
815 
816 				case SCF_ERROR_NOT_FOUND:
817 					die(emsg_not_found);
818 
819 					/* NOTREACHED */
820 
821 				default:
822 					scfdie();
823 				}
824 			}
825 		} else {
826 			propname = NULL;
827 		}
828 
829 		pg = wip->pg;
830 
831 	} else if (wip->inst != NULL) {
832 
833 		p = uu_list_first(prop_list);
834 		if (p == NULL)
835 			uu_xdie(UU_EXIT_USAGE,
836 			    gettext("Cannot wait for an instance.\n"));
837 
838 		if (scf_instance_get_pg(wip->inst, p->spn_comp1, lpg) !=
839 		    SCF_SUCCESS) {
840 			switch (scf_error()) {
841 			case SCF_ERROR_INVALID_ARGUMENT:
842 				uu_xdie(UU_EXIT_USAGE, gettext("Invalid "
843 				    "property group name \"%s\".\n"),
844 				    p->spn_comp1);
845 
846 			case SCF_ERROR_NOT_FOUND:
847 				die(emsg_not_found);
848 
849 				/* NOTREACHED */
850 
851 			default:
852 				scfdie();
853 			}
854 		}
855 
856 		propname = p->spn_comp2;
857 
858 		if (propname != NULL) {
859 			if (scf_pg_get_property(lpg, propname, prop) !=
860 			    SCF_SUCCESS) {
861 				switch (scf_error()) {
862 				case SCF_ERROR_INVALID_ARGUMENT:
863 					uu_xdie(UU_EXIT_USAGE,
864 					    gettext("Invalid property name "
865 					    "\"%s\".\n"), propname);
866 
867 				case SCF_ERROR_NOT_FOUND:
868 					die(emsg_not_found);
869 
870 					/* NOTREACHED */
871 
872 				default:
873 					scfdie();
874 				}
875 			}
876 		}
877 
878 		pg = lpg;
879 
880 	} else if (wip->svc != NULL) {
881 
882 		p = uu_list_first(prop_list);
883 		if (p == NULL)
884 			uu_xdie(UU_EXIT_USAGE,
885 			    gettext("Cannot wait for a service.\n"));
886 
887 		if (scf_service_get_pg(wip->svc, p->spn_comp1, lpg) !=
888 		    SCF_SUCCESS) {
889 			switch (scf_error()) {
890 			case SCF_ERROR_INVALID_ARGUMENT:
891 				uu_xdie(UU_EXIT_USAGE, gettext("Invalid "
892 				    "property group name \"%s\".\n"),
893 				    p->spn_comp1);
894 
895 			case SCF_ERROR_NOT_FOUND:
896 				die(emsg_not_found);
897 
898 			default:
899 				scfdie();
900 			}
901 		}
902 
903 		propname = p->spn_comp2;
904 
905 		if (propname != NULL) {
906 			if (scf_pg_get_property(lpg, propname, prop) !=
907 			    SCF_SUCCESS) {
908 				switch (scf_error()) {
909 				case SCF_ERROR_INVALID_ARGUMENT:
910 					uu_xdie(UU_EXIT_USAGE,
911 					    gettext("Invalid property name "
912 					    "\"%s\".\n"), propname);
913 
914 					/* NOTREACHED */
915 
916 				case SCF_ERROR_NOT_FOUND:
917 					die(emsg_not_found);
918 
919 					/* NOTREACHED */
920 
921 				default:
922 					scfdie();
923 				}
924 			}
925 		}
926 
927 		pg = lpg;
928 
929 	} else {
930 		uu_xdie(UU_EXIT_USAGE, gettext("FMRI must specify an entity, "
931 		    "property group, or property.\n"));
932 	}
933 
934 	for (;;) {
935 		int ret;
936 
937 		ret = _scf_pg_wait(pg, -1);
938 		if (ret != SCF_SUCCESS)
939 			scfdie();
940 
941 		ret = scf_pg_update(pg);
942 		if (ret < 0) {
943 			if (scf_error() != SCF_ERROR_DELETED)
944 				scfdie();
945 
946 			die(emsg_not_found);
947 		}
948 		if (ret == SCF_COMPLETE)
949 			break;
950 	}
951 
952 	if (propname != NULL) {
953 		if (scf_pg_get_property(pg, propname, prop) == SCF_SUCCESS) {
954 			if (!quiet)
955 				display_prop(pg, prop);
956 		} else {
957 			if (scf_error() != SCF_ERROR_NOT_FOUND)
958 				scfdie();
959 
960 			if (PRINT_NOPROP_ERRORS)
961 				uu_warn(emsg_not_found);
962 
963 			return_code = UU_EXIT_FATAL;
964 		}
965 	} else {
966 		if (!quiet)
967 			display_pg(pg);
968 	}
969 
970 	scf_property_destroy(prop);
971 	scf_pg_destroy(lpg);
972 
973 	return (0);
974 }
975 
976 /*
977  * These functions replace uu_warn() and uu_die() when the quiet (-q) option is
978  * used, and silently ignore any output.
979  */
980 
981 /*ARGSUSED*/
982 static void
quiet_warn(const char * fmt,...)983 quiet_warn(const char *fmt, ...)
984 {
985 	/* Do nothing */
986 }
987 
988 /*ARGSUSED*/
989 static void
quiet_die(const char * fmt,...)990 quiet_die(const char *fmt, ...)
991 {
992 	exit(UU_EXIT_FATAL);
993 }
994 
995 int
main(int argc,char * argv[])996 main(int argc, char *argv[])
997 {
998 	int c;
999 	scf_walk_callback callback;
1000 	int flags;
1001 	int err;
1002 
1003 	(void) setlocale(LC_ALL, "");
1004 	(void) textdomain(TEXT_DOMAIN);
1005 
1006 	return_code = UU_EXIT_OK;
1007 
1008 	(void) uu_setpname(argv[0]);
1009 
1010 	prop_pool = uu_list_pool_create("properties",
1011 	    sizeof (svcprop_prop_node_t),
1012 	    offsetof(svcprop_prop_node_t, spn_list_node), NULL, 0);
1013 	if (prop_pool == NULL)
1014 		uu_die("%s\n", uu_strerror(uu_error()));
1015 
1016 	prop_list = uu_list_create(prop_pool, NULL, 0);
1017 
1018 	hndl = scf_handle_create(SCF_VERSION);
1019 	if (hndl == NULL)
1020 		scfdie();
1021 
1022 	while ((c = getopt(argc, argv, "Ccfp:qs:tvwz:")) != -1) {
1023 		switch (c) {
1024 		case 'C':
1025 			if (cflag || sflag || wait)
1026 				usage();	/* Not with -c, -s or -w */
1027 			Cflag++;
1028 			snapshot = NULL;
1029 			break;
1030 
1031 		case 'c':
1032 			if (Cflag || sflag || wait)
1033 				usage();	/* Not with -C, -s or -w */
1034 			cflag++;
1035 			snapshot = NULL;
1036 			break;
1037 
1038 		case 'f':
1039 			types = 1;
1040 			fmris = 1;
1041 			break;
1042 
1043 		case 'p':
1044 			add_prop(optarg);
1045 			break;
1046 
1047 		case 'q':
1048 			quiet = 1;
1049 			warn = quiet_warn;
1050 			die = quiet_die;
1051 			break;
1052 
1053 		case 's':
1054 			if (Cflag || cflag || wait)
1055 				usage();	/* Not with -C, -c or -w */
1056 			snapshot = optarg;
1057 			sflag++;
1058 			break;
1059 
1060 		case 't':
1061 			types = 1;
1062 			break;
1063 
1064 		case 'v':
1065 			verbose = 1;
1066 			break;
1067 
1068 		case 'w':
1069 			if (Cflag || cflag || sflag)
1070 				usage();	/* Not with -C, -c or -s */
1071 			wait = 1;
1072 			break;
1073 
1074 		case 'z': {
1075 			scf_value_t *zone;
1076 			scf_handle_t *h = hndl;
1077 
1078 			if (getzoneid() != GLOBAL_ZONEID)
1079 				uu_die(gettext("svcprop -z may only be used "
1080 				    "from the global zone\n"));
1081 
1082 			if ((zone = scf_value_create(h)) == NULL)
1083 				scfdie();
1084 
1085 			if (scf_value_set_astring(zone, optarg) != SCF_SUCCESS)
1086 				scfdie();
1087 
1088 			if (scf_handle_decorate(h, "zone", zone) != SCF_SUCCESS)
1089 				uu_die(gettext("invalid zone '%s'\n"), optarg);
1090 
1091 			scf_value_destroy(zone);
1092 			break;
1093 		}
1094 
1095 		case '?':
1096 			switch (optopt) {
1097 			case 'p':
1098 				usage();
1099 
1100 			default:
1101 				break;
1102 			}
1103 
1104 			/* FALLTHROUGH */
1105 
1106 		default:
1107 			usage();
1108 		}
1109 	}
1110 
1111 	if (optind == argc)
1112 		usage();
1113 
1114 	max_scf_name_length = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
1115 	max_scf_value_length = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
1116 	max_scf_fmri_length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
1117 	if (max_scf_name_length == -1 || max_scf_value_length == -1 ||
1118 	    max_scf_fmri_length == -1)
1119 		scfdie();
1120 
1121 	if (scf_handle_bind(hndl) == -1)
1122 		die(gettext("Could not connect to configuration repository: "
1123 		    "%s.\n"), scf_strerror(scf_error()));
1124 
1125 	flags = SCF_WALK_PROPERTY | SCF_WALK_SERVICE | SCF_WALK_EXPLICIT;
1126 
1127 	if (wait) {
1128 		if (uu_list_numnodes(prop_list) > 1)
1129 			usage();
1130 
1131 		if (argc - optind > 1)
1132 			usage();
1133 
1134 		callback = do_wait;
1135 
1136 	} else {
1137 		callback = process_fmri;
1138 
1139 		flags |= SCF_WALK_MULTIPLE;
1140 	}
1141 
1142 	if ((err = scf_walk_fmri(hndl, argc - optind, argv + optind, flags,
1143 	    callback, NULL, &return_code, warn)) != 0) {
1144 		warn(gettext("failed to iterate over instances: %s\n"),
1145 		    scf_strerror(err));
1146 		return_code = UU_EXIT_FATAL;
1147 	}
1148 
1149 	scf_handle_destroy(hndl);
1150 
1151 	return (return_code);
1152 }
1153