xref: /illumos-gate/usr/src/cmd/svc/svcs/svcs.c (revision 48bbca816818409505a6e214d0911fda44e622e3)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright (c) 2011, Joyent, Inc. All rights reserved.
25  * Copyright (c) 2015, 2016 by Delphix. All rights reserved.
26  */
27 
28 /*
29  * svcs - display attributes of service instances
30  *
31  * We have two output formats and six instance selection mechanisms.  The
32  * primary output format is a line of attributes (selected by -o), possibly
33  * followed by process description lines (if -p is specified), for each
34  * instance selected.  The columns available to display are described by the
35  * struct column columns array.  The columns to actually display are kept in
36  * the opt_columns array as indicies into the columns array.  The selection
37  * mechanisms available for this format are service FMRIs (selects all child
38  * instances), instance FMRIs, instance FMRI glob patterns, instances with
39  * a certain restarter (-R), dependencies of instances (-d), and dependents of
40  * instances (-D).  Since the lines must be sorted (per -sS), we'll just stick
41  * each into a data structure and print them in order when we're done.  To
42  * avoid listing the same instance twice (when -d and -D aren't given), we'll
43  * use a hash table of FMRIs to record that we've listed (added to the tree)
44  * an instance.
45  *
46  * The secondary output format (-l "long") is a paragraph of text for the
47  * services or instances selected.  Not needing to be sorted, it's implemented
48  * by just calling print_detailed() for each FMRI given.
49  */
50 
51 #include "svcs.h"
52 #include "notify_params.h"
53 
54 /* Get the byteorder macros to ease sorting. */
55 #include <sys/types.h>
56 #include <netinet/in.h>
57 #include <inttypes.h>
58 
59 #include <sys/contract.h>
60 #include <sys/ctfs.h>
61 #include <sys/stat.h>
62 
63 #include <assert.h>
64 #include <errno.h>
65 #include <fcntl.h>
66 #include <fnmatch.h>
67 #include <libcontract.h>
68 #include <libcontract_priv.h>
69 #include <libintl.h>
70 #include <libscf.h>
71 #include <libscf_priv.h>
72 #include <libuutil.h>
73 #include <libnvpair.h>
74 #include <locale.h>
75 #include <procfs.h>
76 #include <stdarg.h>
77 #include <stdio.h>
78 #include <stdlib.h>
79 #include <strings.h>
80 #include <time.h>
81 #include <libzonecfg.h>
82 #include <zone.h>
83 
84 #ifndef TEXT_DOMAIN
85 #define	TEXT_DOMAIN	"SUNW_OST_OSCMD"
86 #endif /* TEXT_DOMAIN */
87 
88 #define	LEGACY_UNKNOWN	"unknown"
89 
90 /* Flags for pg_get_single_val() */
91 #define	EMPTY_OK	0x01
92 #define	MULTI_OK	0x02
93 
94 
95 /*
96  * An AVL-storable node for output lines and the keys to sort them by.
97  */
98 struct avl_string {
99 	uu_avl_node_t	node;
100 	char		*key;
101 	char		*str;
102 };
103 
104 /*
105  * For lists of parsed restarter FMRIs.
106  */
107 struct pfmri_list {
108 	const char		*scope;
109 	const char		*service;
110 	const char		*instance;
111 	struct pfmri_list	*next;
112 };
113 
114 
115 /*
116  * Globals
117  */
118 scf_handle_t *h;
119 static scf_propertygroup_t *g_pg;
120 static scf_property_t *g_prop;
121 static scf_value_t *g_val;
122 
123 static size_t line_sz;			/* Bytes in the header line. */
124 static size_t sortkey_sz;		/* Bytes in sort keys. */
125 static uu_avl_pool_t *lines_pool;
126 static uu_avl_t *lines;			/* Output lines. */
127 int exit_status;
128 ssize_t max_scf_name_length;
129 ssize_t max_scf_value_length;
130 ssize_t max_scf_fmri_length;
131 static ssize_t max_scf_type_length;
132 static time_t now;
133 static struct pfmri_list *restarters = NULL;
134 static int first_paragraph = 1;		/* For -l mode. */
135 static char *common_name_buf;		/* Sized for maximal length value. */
136 char *locale;				/* Current locale. */
137 char *g_zonename;			/* zone being operated upon */
138 
139 /*
140  * Pathname storage for path generated from the fmri.
141  * Used for reading the ctid and (start) pid files for an inetd service.
142  */
143 static char genfmri_filename[MAXPATHLEN] = "";
144 
145 /* Options */
146 static int *opt_columns = NULL;		/* Indices into columns to display. */
147 static int opt_cnum = 0;
148 static int opt_processes = 0;		/* Print processes? */
149 static int *opt_sort = NULL;		/* Indices into columns to sort. */
150 static int opt_snum = 0;
151 static int opt_nstate_shown = 0;	/* Will nstate be shown? */
152 static int opt_verbose = 0;
153 static char *opt_zone;			/* zone selected, if any */
154 
155 /* Minimize string constants. */
156 static const char * const scf_property_state = SCF_PROPERTY_STATE;
157 static const char * const scf_property_next_state = SCF_PROPERTY_NEXT_STATE;
158 static const char * const scf_property_contract = SCF_PROPERTY_CONTRACT;
159 
160 
161 /*
162  * Utility functions
163  */
164 
165 /*
166  * For unexpected libscf errors.  The ending newline is necessary to keep
167  * uu_die() from appending the errno error.
168  */
169 #ifndef NDEBUG
170 void
171 do_scfdie(const char *file, int line)
172 {
173 	uu_die(gettext("%s:%d: Unexpected libscf error: %s.  Exiting.\n"),
174 	    file, line, scf_strerror(scf_error()));
175 }
176 #else
177 void
178 scfdie(void)
179 {
180 	uu_die(gettext("Unexpected libscf error: %s.  Exiting.\n"),
181 	    scf_strerror(scf_error()));
182 }
183 #endif
184 
185 void *
186 safe_malloc(size_t sz)
187 {
188 	void *ptr;
189 
190 	ptr = malloc(sz);
191 	if (ptr == NULL)
192 		uu_die(gettext("Out of memory"));
193 
194 	return (ptr);
195 }
196 
197 char *
198 safe_strdup(const char *str)
199 {
200 	char *cp;
201 
202 	cp = strdup(str);
203 	if (cp == NULL)
204 		uu_die(gettext("Out of memory.\n"));
205 
206 	return (cp);
207 }
208 
209 /*
210  * FMRI hashtable.  For uniquifing listings.
211  */
212 
213 struct ht_elem {
214 	const char	*fmri;
215 	struct ht_elem	*next;
216 };
217 
218 static struct ht_elem	**ht_buckets = NULL;
219 static uint_t		ht_buckets_num = 0;
220 static uint_t		ht_num;
221 
222 static void
223 ht_free(void)
224 {
225 	struct ht_elem *elem, *next;
226 	int i;
227 
228 	for (i = 0; i < ht_buckets_num; i++) {
229 		for (elem = ht_buckets[i]; elem != NULL; elem = next) {
230 			next = elem->next;
231 			free((char *)elem->fmri);
232 			free(elem);
233 		}
234 	}
235 
236 	free(ht_buckets);
237 	ht_buckets_num = 0;
238 	ht_buckets = NULL;
239 }
240 
241 static void
242 ht_init(void)
243 {
244 	assert(ht_buckets == NULL);
245 
246 	ht_buckets_num = 8;
247 	ht_buckets = safe_malloc(sizeof (*ht_buckets) * ht_buckets_num);
248 	bzero(ht_buckets, sizeof (*ht_buckets) * ht_buckets_num);
249 	ht_num = 0;
250 }
251 
252 static uint_t
253 ht_hash_fmri(const char *fmri)
254 {
255 	uint_t h = 0, g;
256 	const char *p, *k;
257 
258 	/* All FMRIs begin with svc:/, so skip that part. */
259 	assert(strncmp(fmri, "svc:/", sizeof ("svc:/") - 1) == 0);
260 	k = fmri + sizeof ("svc:/") - 1;
261 
262 	/*
263 	 * Generic hash function from uts/common/os/modhash.c.
264 	 */
265 	for (p = k; *p != '\0'; ++p) {
266 		h = (h << 4) + *p;
267 		if ((g = (h & 0xf0000000)) != 0) {
268 			h ^= (g >> 24);
269 			h ^= g;
270 		}
271 	}
272 
273 	return (h);
274 }
275 
276 static void
277 ht_grow()
278 {
279 	uint_t new_ht_buckets_num;
280 	struct ht_elem **new_ht_buckets;
281 	int i;
282 
283 	new_ht_buckets_num = ht_buckets_num * 2;
284 	assert(new_ht_buckets_num > ht_buckets_num);
285 	new_ht_buckets =
286 	    safe_malloc(sizeof (*new_ht_buckets) * new_ht_buckets_num);
287 	bzero(new_ht_buckets, sizeof (*new_ht_buckets) * new_ht_buckets_num);
288 
289 	for (i = 0; i < ht_buckets_num; ++i) {
290 		struct ht_elem *elem, *next;
291 
292 		for (elem = ht_buckets[i]; elem != NULL; elem = next) {
293 			uint_t h;
294 
295 			next = elem->next;
296 
297 			h = ht_hash_fmri(elem->fmri);
298 
299 			elem->next =
300 			    new_ht_buckets[h & (new_ht_buckets_num - 1)];
301 			new_ht_buckets[h & (new_ht_buckets_num - 1)] = elem;
302 		}
303 	}
304 
305 	free(ht_buckets);
306 
307 	ht_buckets = new_ht_buckets;
308 	ht_buckets_num = new_ht_buckets_num;
309 }
310 
311 /*
312  * Add an FMRI to the hash table.  Returns 1 if it was already there,
313  * 0 otherwise.
314  */
315 static int
316 ht_add(const char *fmri)
317 {
318 	uint_t h;
319 	struct ht_elem *elem;
320 
321 	h = ht_hash_fmri(fmri);
322 
323 	elem = ht_buckets[h & (ht_buckets_num - 1)];
324 
325 	for (; elem != NULL; elem = elem->next) {
326 		if (strcmp(elem->fmri, fmri) == 0)
327 			return (1);
328 	}
329 
330 	/* Grow when average chain length is over 3. */
331 	if (ht_num > 3 * ht_buckets_num)
332 		ht_grow();
333 
334 	++ht_num;
335 
336 	elem = safe_malloc(sizeof (*elem));
337 	elem->fmri = strdup(fmri);
338 	elem->next = ht_buckets[h & (ht_buckets_num - 1)];
339 	ht_buckets[h & (ht_buckets_num - 1)] = elem;
340 
341 	return (0);
342 }
343 
344 
345 
346 /*
347  * Convenience libscf wrapper functions.
348  */
349 
350 /*
351  * Get the single value of the named property in the given property group,
352  * which must have type ty, and put it in *vp.  If ty is SCF_TYPE_ASTRING, vp
353  * is taken to be a char **, and sz is the size of the buffer.  sz is unused
354  * otherwise.  Return 0 on success, -1 if the property doesn't exist, has the
355  * wrong type, or doesn't have a single value.  If flags has EMPTY_OK, don't
356  * complain if the property has no values (but return nonzero).  If flags has
357  * MULTI_OK and the property has multiple values, succeed with E2BIG.
358  */
359 int
360 pg_get_single_val(scf_propertygroup_t *pg, const char *propname, scf_type_t ty,
361     void *vp, size_t sz, uint_t flags)
362 {
363 	char *buf, root[MAXPATHLEN];
364 	size_t buf_sz;
365 	int ret = -1, r;
366 	boolean_t multi = B_FALSE;
367 
368 	assert((flags & ~(EMPTY_OK | MULTI_OK)) == 0);
369 
370 	if (scf_pg_get_property(pg, propname, g_prop) == -1) {
371 		if (scf_error() != SCF_ERROR_NOT_FOUND)
372 			scfdie();
373 
374 		goto out;
375 	}
376 
377 	if (scf_property_is_type(g_prop, ty) != SCF_SUCCESS) {
378 		if (scf_error() == SCF_ERROR_TYPE_MISMATCH)
379 			goto misconfigured;
380 		scfdie();
381 	}
382 
383 	if (scf_property_get_value(g_prop, g_val) != SCF_SUCCESS) {
384 		switch (scf_error()) {
385 		case SCF_ERROR_NOT_FOUND:
386 			if (flags & EMPTY_OK)
387 				goto out;
388 			goto misconfigured;
389 
390 		case SCF_ERROR_CONSTRAINT_VIOLATED:
391 			if (flags & MULTI_OK) {
392 				multi = B_TRUE;
393 				break;
394 			}
395 			goto misconfigured;
396 
397 		case SCF_ERROR_PERMISSION_DENIED:
398 		default:
399 			scfdie();
400 		}
401 	}
402 
403 	switch (ty) {
404 	case SCF_TYPE_ASTRING:
405 		r = scf_value_get_astring(g_val, vp, sz) > 0 ? SCF_SUCCESS : -1;
406 		break;
407 
408 	case SCF_TYPE_BOOLEAN:
409 		r = scf_value_get_boolean(g_val, (uint8_t *)vp);
410 		break;
411 
412 	case SCF_TYPE_COUNT:
413 		r = scf_value_get_count(g_val, (uint64_t *)vp);
414 		break;
415 
416 	case SCF_TYPE_INTEGER:
417 		r = scf_value_get_integer(g_val, (int64_t *)vp);
418 		break;
419 
420 	case SCF_TYPE_TIME: {
421 		int64_t sec;
422 		int32_t ns;
423 		r = scf_value_get_time(g_val, &sec, &ns);
424 		((struct timeval *)vp)->tv_sec = sec;
425 		((struct timeval *)vp)->tv_usec = ns / 1000;
426 		break;
427 	}
428 
429 	case SCF_TYPE_USTRING:
430 		r = scf_value_get_ustring(g_val, vp, sz) > 0 ? SCF_SUCCESS : -1;
431 		break;
432 
433 	default:
434 #ifndef NDEBUG
435 		uu_warn("%s:%d: Unknown type %d.\n", __FILE__, __LINE__, ty);
436 #endif
437 		abort();
438 	}
439 	if (r != SCF_SUCCESS)
440 		scfdie();
441 
442 	ret = multi ? E2BIG : 0;
443 	goto out;
444 
445 misconfigured:
446 	buf_sz = max_scf_fmri_length + 1;
447 	buf = safe_malloc(buf_sz);
448 	if (scf_property_to_fmri(g_prop, buf, buf_sz) == -1)
449 		scfdie();
450 
451 	uu_warn(gettext("Property \"%s\" is misconfigured.\n"), buf);
452 
453 	free(buf);
454 
455 out:
456 	if (ret != 0 || g_zonename == NULL ||
457 	    (strcmp(propname, SCF_PROPERTY_LOGFILE) != 0 &&
458 	    strcmp(propname, SCF_PROPERTY_ALT_LOGFILE) != 0))
459 		return (ret);
460 
461 	/*
462 	 * If we're here, we have a log file and we have specified a zone.
463 	 * As a convenience, we're going to prepend the zone path to the
464 	 * name of the log file.
465 	 */
466 	root[0] = '\0';
467 	(void) zone_get_rootpath(g_zonename, root, sizeof (root));
468 	(void) strlcat(root, vp, sizeof (root));
469 	(void) snprintf(vp, sz, "%s", root);
470 
471 	return (ret);
472 }
473 
474 static scf_snapshot_t *
475 get_running_snapshot(scf_instance_t *inst)
476 {
477 	scf_snapshot_t *snap;
478 
479 	snap = scf_snapshot_create(h);
480 	if (snap == NULL)
481 		scfdie();
482 
483 	if (scf_instance_get_snapshot(inst, "running", snap) == 0)
484 		return (snap);
485 
486 	if (scf_error() != SCF_ERROR_NOT_FOUND)
487 		scfdie();
488 
489 	scf_snapshot_destroy(snap);
490 	return (NULL);
491 }
492 
493 /*
494  * As pg_get_single_val(), except look the property group up in an
495  * instance.  If "use_running" is set, and the running snapshot exists,
496  * do a composed lookup there.  Otherwise, do an (optionally composed)
497  * lookup on the current values.  Note that lookups using snapshots are
498  * always composed.
499  */
500 int
501 inst_get_single_val(scf_instance_t *inst, const char *pgname,
502     const char *propname, scf_type_t ty, void *vp, size_t sz, uint_t flags,
503     int use_running, int composed)
504 {
505 	scf_snapshot_t *snap = NULL;
506 	int r;
507 
508 	if (use_running)
509 		snap = get_running_snapshot(inst);
510 	if (composed || use_running)
511 		r = scf_instance_get_pg_composed(inst, snap, pgname, g_pg);
512 	else
513 		r = scf_instance_get_pg(inst, pgname, g_pg);
514 	if (snap)
515 		scf_snapshot_destroy(snap);
516 	if (r == -1)
517 		return (-1);
518 
519 	r = pg_get_single_val(g_pg, propname, ty, vp, sz, flags);
520 
521 	return (r);
522 }
523 
524 static int
525 instance_enabled(scf_instance_t *inst, boolean_t temp)
526 {
527 	uint8_t b;
528 
529 	if (inst_get_single_val(inst,
530 	    temp ? SCF_PG_GENERAL_OVR : SCF_PG_GENERAL, SCF_PROPERTY_ENABLED,
531 	    SCF_TYPE_BOOLEAN, &b, 0, 0, 0, 0) != 0)
532 		return (-1);
533 
534 	return (b ? 1 : 0);
535 }
536 
537 /*
538  * Get a string property from the restarter property group of the given
539  * instance.  Return an empty string on normal problems.
540  */
541 static void
542 get_restarter_string_prop(scf_instance_t *inst, const char *pname,
543     char *buf, size_t buf_sz)
544 {
545 	if (inst_get_single_val(inst, SCF_PG_RESTARTER, pname,
546 	    SCF_TYPE_ASTRING, buf, buf_sz, 0, 0, 1) != 0)
547 		*buf = '\0';
548 }
549 
550 static int
551 get_restarter_time_prop(scf_instance_t *inst, const char *pname,
552     struct timeval *tvp, int ok_if_empty)
553 {
554 	int r;
555 
556 	r = inst_get_single_val(inst, SCF_PG_RESTARTER, pname, SCF_TYPE_TIME,
557 	    tvp, NULL, ok_if_empty ? EMPTY_OK : 0, 0, 1);
558 
559 	return (r == 0 ? 0 : -1);
560 }
561 
562 static int
563 get_restarter_count_prop(scf_instance_t *inst, const char *pname, uint64_t *cp,
564     uint_t flags)
565 {
566 	return (inst_get_single_val(inst, SCF_PG_RESTARTER, pname,
567 	    SCF_TYPE_COUNT, cp, 0, flags, 0, 1));
568 }
569 
570 
571 /*
572  * Generic functions
573  */
574 
575 /*
576  * Return an array of pids associated with the given contract id.
577  * Returned pids are added to the end of the pidsp array.
578  */
579 static void
580 ctid_to_pids(uint64_t c, pid_t **pidsp, uint_t *np)
581 {
582 	ct_stathdl_t ctst;
583 	uint_t m;
584 	int fd;
585 	int r, err;
586 	pid_t *pids;
587 
588 	fd = contract_open(c, NULL, "status", O_RDONLY);
589 	if (fd < 0)
590 		return;
591 
592 	err = ct_status_read(fd, CTD_ALL, &ctst);
593 	if (err != 0) {
594 		uu_warn(gettext("Could not read status of contract "
595 		    "%ld: %s.\n"), c, strerror(err));
596 		(void) close(fd);
597 		return;
598 	}
599 
600 	(void) close(fd);
601 
602 	r = ct_pr_status_get_members(ctst, &pids, &m);
603 	assert(r == 0);
604 
605 	if (m == 0) {
606 		ct_status_free(ctst);
607 		return;
608 	}
609 
610 	*pidsp = realloc(*pidsp, (*np + m) * sizeof (*pidsp));
611 	if (*pidsp == NULL)
612 		uu_die(gettext("Out of memory"));
613 
614 	bcopy(pids, *pidsp + *np, m * sizeof (*pids));
615 	*np += m;
616 
617 	ct_status_free(ctst);
618 }
619 
620 static int
621 propvals_to_pids(scf_propertygroup_t *pg, const char *pname, pid_t **pidsp,
622     uint_t *np, scf_property_t *prop, scf_value_t *val, scf_iter_t *iter)
623 {
624 	scf_type_t ty;
625 	uint64_t c;
626 	int r;
627 
628 	if (scf_pg_get_property(pg, pname, prop) != 0) {
629 		if (scf_error() != SCF_ERROR_NOT_FOUND)
630 			scfdie();
631 
632 		return (ENOENT);
633 	}
634 
635 	if (scf_property_type(prop, &ty) != 0)
636 		scfdie();
637 
638 	if (ty != SCF_TYPE_COUNT)
639 		return (EINVAL);
640 
641 	if (scf_iter_property_values(iter, prop) != 0)
642 		scfdie();
643 
644 	for (;;) {
645 		r = scf_iter_next_value(iter, val);
646 		if (r == -1)
647 			scfdie();
648 		if (r == 0)
649 			break;
650 
651 		if (scf_value_get_count(val, &c) != 0)
652 			scfdie();
653 
654 		ctid_to_pids(c, pidsp, np);
655 	}
656 
657 	return (0);
658 }
659 
660 /*
661  * Check if instance has general/restarter property that matches
662  * given string.  Restarter string must be in canonified form.
663  * Returns 0 for success; -1 otherwise.
664  */
665 static int
666 check_for_restarter(scf_instance_t *inst, const char *restarter)
667 {
668 	char	*fmri_buf;
669 	char	*fmri_buf_canonified = NULL;
670 	int	ret = -1;
671 
672 	if (inst == NULL)
673 		return (-1);
674 
675 	/* Get restarter */
676 	fmri_buf = safe_malloc(max_scf_fmri_length + 1);
677 	if (inst_get_single_val(inst, SCF_PG_GENERAL,
678 	    SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, fmri_buf,
679 	    max_scf_fmri_length + 1, 0, 0, 1) != 0)
680 		goto out;
681 
682 	fmri_buf_canonified = safe_malloc(max_scf_fmri_length + 1);
683 	if (scf_canonify_fmri(fmri_buf, fmri_buf_canonified,
684 	    (max_scf_fmri_length + 1)) < 0)
685 		goto out;
686 
687 	if (strcmp(fmri_buf, restarter) == 0)
688 		ret = 0;
689 
690 out:
691 	free(fmri_buf);
692 	if (fmri_buf_canonified)
693 		free(fmri_buf_canonified);
694 	return (ret);
695 }
696 
697 /*
698  * Common code that is used by ctids_by_restarter and pids_by_restarter.
699  * Checks for a common restarter and if one is available, it generates
700  * the appropriate filename using wip->fmri and stores that in the
701  * global genfmri_filename.
702  *
703  * Restarters currently supported are: svc:/network/inetd:default
704  * If a restarter specific action is available, then restarter_spec
705  * is set to 1.  If a restarter specific action is not available, then
706  * restarter_spec is set to 0 and a -1 is returned.
707  *
708  * Returns:
709  * 0 if success: restarter specific action found and filename generated
710  * -1 if restarter specific action not found,
711  *    if restarter specific action found but an error was encountered
712  *    during the generation of the wip->fmri based filename
713  */
714 static int
715 common_by_restarter(scf_instance_t *inst, const char *fmri,
716     int *restarter_specp)
717 {
718 	int		ret = -1;
719 	int		r;
720 
721 	/* Check for inetd specific restarter */
722 	if (check_for_restarter(inst, "svc:/network/inetd:default") != 0) {
723 		*restarter_specp = 0;
724 		return (ret);
725 	}
726 
727 	*restarter_specp = 1;
728 
729 	/* Get the ctid filename associated with this instance */
730 	r = gen_filenms_from_fmri(fmri, "ctid", genfmri_filename, NULL);
731 
732 	switch (r) {
733 	case 0:
734 		break;
735 
736 	case -1:
737 		/*
738 		 * Unable to get filename from fmri.  Print warning
739 		 * and return failure with no ctids.
740 		 */
741 		uu_warn(gettext("Unable to read contract ids for %s -- "
742 		    "FMRI is too long\n"), fmri);
743 		return (ret);
744 
745 	case -2:
746 		/*
747 		 * The directory didn't exist, so no contracts.
748 		 * Return failure with no ctids.
749 		 */
750 		return (ret);
751 
752 	default:
753 		uu_warn(gettext("%s:%d: gen_filenms_from_fmri() failed with "
754 		    "unknown error %d\n"), __FILE__, __LINE__, r);
755 		abort();
756 	}
757 
758 	return (0);
759 
760 }
761 
762 /*
763  * Get or print a contract id using a restarter specific action.
764  *
765  * If the print_flag is not set, this routine gets the single contract
766  * id associated with this instance.
767  * If the print flag is set, then print each contract id found.
768  *
769  * Returns:
770  * 0 if success: restarter specific action found and used with no error
771  * -1 if restarter specific action not found
772  * -1 if restarter specific action found, but there was a failure
773  * -1 if print flag is not set and no contract id is found or multiple
774  *    contract ids were found
775  * E2BIG if print flag is not set, MULTI_OK bit in flag is set and multiple
776  *    contract ids were found
777  */
778 static int
779 ctids_by_restarter(scf_walkinfo_t *wip, uint64_t *cp, int print_flag,
780     uint_t flags, int *restarter_specp, void (*callback_header)(),
781     void (*callback_ctid)(uint64_t))
782 {
783 	FILE		*fp;
784 	int		ret = -1;
785 	int		fscanf_ret;
786 	uint64_t	cp2;
787 	int		rest_ret;
788 
789 	/* Check if callbacks are needed and were passed in */
790 	if (print_flag) {
791 		if ((callback_header == NULL) || (callback_ctid == NULL))
792 			return (ret);
793 	}
794 
795 	/* Check for restarter specific action and generation of filename */
796 	rest_ret = common_by_restarter(wip->inst, wip->fmri, restarter_specp);
797 	if (rest_ret != 0)
798 		return (rest_ret);
799 
800 	/*
801 	 * If fopen fails, then ctid file hasn't been created yet.
802 	 * If print_flag is set, this is ok; otherwise fail.
803 	 */
804 	if ((fp = fopen(genfmri_filename, "r")) == NULL) {
805 		if (print_flag)
806 			return (0);
807 		goto out;
808 	}
809 
810 	if (print_flag) {
811 		/*
812 		 * Print all contract ids that are found.
813 		 * First callback to print ctid header.
814 		 */
815 		callback_header();
816 
817 		/* fscanf may not set errno, so be sure to clear it first */
818 		errno = 0;
819 		while ((fscanf_ret = fscanf(fp, "%llu", cp)) == 1) {
820 			/* Callback to print contract id */
821 			callback_ctid(*cp);
822 			errno = 0;
823 		}
824 		/* EOF is not a failure when no errno. */
825 		if ((fscanf_ret != EOF) || (errno != 0)) {
826 			uu_die(gettext("Unable to read ctid file for %s"),
827 			    wip->fmri);
828 		}
829 		(void) putchar('\n');
830 		ret = 0;
831 	} else {
832 		/* Must find 1 ctid or fail */
833 		if (fscanf(fp, "%llu", cp) == 1) {
834 			/* If 2nd ctid found - fail */
835 			if (fscanf(fp, "%llu", &cp2) == 1) {
836 				if (flags & MULTI_OK)
837 					ret = E2BIG;
838 			} else {
839 				/* Success - found only 1 ctid */
840 				ret = 0;
841 			}
842 		}
843 	}
844 	(void) fclose(fp);
845 
846 out:
847 	return (ret);
848 }
849 
850 /*
851  * Get the process ids associated with an instance using a restarter
852  * specific action.
853  *
854  * Returns:
855  *	0 if success: restarter specific action found and used with no error
856  *	-1 restarter specific action not found or if failure
857  */
858 static int
859 pids_by_restarter(scf_instance_t *inst, const char *fmri,
860     pid_t **pids, uint_t *np, int *restarter_specp)
861 {
862 	uint64_t	c;
863 	FILE		*fp;
864 	int		fscanf_ret;
865 	int		rest_ret;
866 
867 	/* Check for restarter specific action and generation of filename */
868 	rest_ret = common_by_restarter(inst, fmri, restarter_specp);
869 	if (rest_ret != 0)
870 		return (rest_ret);
871 
872 	/*
873 	 * If fopen fails with ENOENT then the ctid file hasn't been
874 	 * created yet so return success.
875 	 * For all other errors - fail with uu_die.
876 	 */
877 	if ((fp = fopen(genfmri_filename, "r")) == NULL) {
878 		if (errno == ENOENT)
879 			return (0);
880 		uu_die(gettext("Unable to open ctid file for %s"), fmri);
881 	}
882 
883 	/* fscanf may not set errno, so be sure to clear it first */
884 	errno = 0;
885 	while ((fscanf_ret = fscanf(fp, "%llu", &c)) == 1) {
886 		if (c == 0) {
887 			(void) fclose(fp);
888 			uu_die(gettext("ctid file for %s has corrupt data"),
889 			    fmri);
890 		}
891 		ctid_to_pids(c, pids, np);
892 		errno = 0;
893 	}
894 	/* EOF is not a failure when no errno. */
895 	if ((fscanf_ret != EOF) || (errno != 0)) {
896 		uu_die(gettext("Unable to read ctid file for %s"), fmri);
897 	}
898 
899 	(void) fclose(fp);
900 	return (0);
901 }
902 
903 static int
904 instance_processes(scf_instance_t *inst, const char *fmri,
905     pid_t **pids, uint_t *np)
906 {
907 	scf_iter_t *iter;
908 	int ret;
909 	int restarter_spec;
910 
911 	/* Use the restarter specific get pids routine, if available. */
912 	ret = pids_by_restarter(inst, fmri, pids, np, &restarter_spec);
913 	if (restarter_spec == 1)
914 		return (ret);
915 
916 	if ((iter = scf_iter_create(h)) == NULL)
917 		scfdie();
918 
919 	if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) == 0) {
920 		*pids = NULL;
921 		*np = 0;
922 
923 		(void) propvals_to_pids(g_pg, scf_property_contract, pids, np,
924 		    g_prop, g_val, iter);
925 
926 		(void) propvals_to_pids(g_pg, SCF_PROPERTY_TRANSIENT_CONTRACT,
927 		    pids, np, g_prop, g_val, iter);
928 
929 		ret = 0;
930 	} else {
931 		if (scf_error() != SCF_ERROR_NOT_FOUND)
932 			scfdie();
933 
934 		ret = -1;
935 	}
936 
937 	scf_iter_destroy(iter);
938 
939 	return (ret);
940 }
941 
942 static int
943 get_psinfo(pid_t pid, psinfo_t *psip)
944 {
945 	char path[100];
946 	int fd;
947 
948 	(void) snprintf(path, sizeof (path), "/proc/%lu/psinfo", pid);
949 
950 	fd = open64(path, O_RDONLY);
951 	if (fd < 0)
952 		return (-1);
953 
954 	if (read(fd, psip, sizeof (*psip)) < 0)
955 		uu_die(gettext("Could not read info for process %lu"), pid);
956 
957 	(void) close(fd);
958 
959 	return (0);
960 }
961 
962 
963 
964 /*
965  * Column sprint and sortkey functions
966  */
967 
968 struct column {
969 	const char *name;
970 	int width;
971 
972 	/*
973 	 * This function should write the value for the column into buf, and
974 	 * grow or allocate buf accordingly.  It should always write at least
975 	 * width bytes, blanking unused bytes with spaces.  If the field is
976 	 * greater than the column width we allow it to overlap other columns.
977 	 * In particular, it shouldn't write any null bytes.  (Though an extra
978 	 * null byte past the end is currently tolerated.)  If the property
979 	 * group is non-NULL, then we are dealing with a legacy service.
980 	 */
981 	void (*sprint)(char **, scf_walkinfo_t *);
982 
983 	int sortkey_width;
984 
985 	/*
986 	 * This function should write sortkey_width bytes into buf which will
987 	 * cause memcmp() to sort it properly.  (Unlike sprint() above,
988 	 * however, an extra null byte may overrun the buffer.)  The second
989 	 * argument controls whether the results are sorted in forward or
990 	 * reverse order.
991 	 */
992 	void (*get_sortkey)(char *, int, scf_walkinfo_t *);
993 };
994 
995 static void
996 reverse_bytes(char *buf, size_t len)
997 {
998 	int i;
999 
1000 	for (i = 0; i < len; ++i)
1001 		buf[i] = ~buf[i];
1002 }
1003 
1004 /* CTID */
1005 #define	CTID_COLUMN_WIDTH		6
1006 #define	CTID_COLUMN_BUFSIZE		20	/* max ctid_t + space + \0 */
1007 
1008 static void
1009 sprint_ctid(char **buf, scf_walkinfo_t *wip)
1010 {
1011 	int r;
1012 	uint64_t c;
1013 	size_t newsize = (*buf ? strlen(*buf) : 0) + CTID_COLUMN_BUFSIZE;
1014 	char *newbuf = safe_malloc(newsize);
1015 	int restarter_spec;
1016 
1017 	/*
1018 	 * Use the restarter specific get pids routine, if available.
1019 	 * Only check for non-legacy services (wip->pg == 0).
1020 	 */
1021 	if (wip->pg != NULL) {
1022 		r = pg_get_single_val(wip->pg, scf_property_contract,
1023 		    SCF_TYPE_COUNT, &c, 0, EMPTY_OK | MULTI_OK);
1024 	} else {
1025 		r = ctids_by_restarter(wip, &c, 0, MULTI_OK, &restarter_spec,
1026 		    NULL, NULL);
1027 		if (restarter_spec == 0) {
1028 			/* No restarter specific routine */
1029 			r = get_restarter_count_prop(wip->inst,
1030 			    scf_property_contract, &c, EMPTY_OK | MULTI_OK);
1031 		}
1032 	}
1033 
1034 	if (r == 0)
1035 		(void) snprintf(newbuf, newsize, "%s%*lu ",
1036 		    *buf ? *buf : "", CTID_COLUMN_WIDTH, (ctid_t)c);
1037 	else if (r == E2BIG)
1038 		(void) snprintf(newbuf, newsize, "%s%*lu* ",
1039 		    *buf ? *buf : "", CTID_COLUMN_WIDTH - 1, (ctid_t)c);
1040 	else
1041 		(void) snprintf(newbuf, newsize, "%s%*s ",
1042 		    *buf ? *buf : "", CTID_COLUMN_WIDTH, "-");
1043 	if (*buf)
1044 		free(*buf);
1045 	*buf = newbuf;
1046 }
1047 
1048 #define	CTID_SORTKEY_WIDTH		(sizeof (uint64_t))
1049 
1050 static void
1051 sortkey_ctid(char *buf, int reverse, scf_walkinfo_t *wip)
1052 {
1053 	int r;
1054 	uint64_t c;
1055 	int restarter_spec;
1056 
1057 	/*
1058 	 * Use the restarter specific get pids routine, if available.
1059 	 * Only check for non-legacy services (wip->pg == 0).
1060 	 */
1061 	if (wip->pg != NULL) {
1062 		r = pg_get_single_val(wip->pg, scf_property_contract,
1063 		    SCF_TYPE_COUNT, &c, 0, EMPTY_OK);
1064 	} else {
1065 		r = ctids_by_restarter(wip, &c, 0, MULTI_OK, &restarter_spec,
1066 		    NULL, NULL);
1067 		if (restarter_spec == 0) {
1068 			/* No restarter specific routine */
1069 			r = get_restarter_count_prop(wip->inst,
1070 			    scf_property_contract, &c, EMPTY_OK);
1071 		}
1072 	}
1073 
1074 	if (r == 0) {
1075 		/*
1076 		 * Use the id itself, but it must be big-endian for this to
1077 		 * work.
1078 		 */
1079 		c = BE_64(c);
1080 
1081 		bcopy(&c, buf, CTID_SORTKEY_WIDTH);
1082 	} else {
1083 		bzero(buf, CTID_SORTKEY_WIDTH);
1084 	}
1085 
1086 	if (reverse)
1087 		reverse_bytes(buf, CTID_SORTKEY_WIDTH);
1088 }
1089 
1090 /* DESC */
1091 #define	DESC_COLUMN_WIDTH	100
1092 
1093 static void
1094 sprint_desc(char **buf, scf_walkinfo_t *wip)
1095 {
1096 	char *x;
1097 	size_t newsize;
1098 	char *newbuf;
1099 
1100 	if (common_name_buf == NULL)
1101 		common_name_buf = safe_malloc(max_scf_value_length + 1);
1102 
1103 	bzero(common_name_buf, max_scf_value_length + 1);
1104 
1105 	if (wip->pg != NULL) {
1106 		common_name_buf[0] = '-';
1107 	} else if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, locale,
1108 	    SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0,
1109 	    1, 1) == -1 &&
1110 	    inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, "C",
1111 	    SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0,
1112 	    1, 1) == -1) {
1113 		common_name_buf[0] = '-';
1114 	}
1115 
1116 	/*
1117 	 * Collapse multi-line tm_common_name values into a single line.
1118 	 */
1119 	for (x = common_name_buf; *x != '\0'; x++)
1120 		if (*x == '\n')
1121 			*x = ' ';
1122 
1123 	if (strlen(common_name_buf) > DESC_COLUMN_WIDTH)
1124 		newsize = (*buf ? strlen(*buf) : 0) +
1125 		    strlen(common_name_buf) + 1;
1126 	else
1127 		newsize = (*buf ? strlen(*buf) : 0) + DESC_COLUMN_WIDTH + 1;
1128 	newbuf = safe_malloc(newsize);
1129 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1130 	    DESC_COLUMN_WIDTH, common_name_buf);
1131 	if (*buf)
1132 		free(*buf);
1133 	*buf = newbuf;
1134 }
1135 
1136 /* ARGSUSED */
1137 static void
1138 sortkey_desc(char *buf, int reverse, scf_walkinfo_t *wip)
1139 {
1140 	bzero(buf, DESC_COLUMN_WIDTH);
1141 }
1142 
1143 /* State columns (STATE, NSTATE, S, N, SN, STA, NSTA) */
1144 
1145 static char
1146 state_to_char(const char *state)
1147 {
1148 	if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0)
1149 		return ('u');
1150 
1151 	if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0)
1152 		return ('0');
1153 
1154 	if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0)
1155 		return ('1');
1156 
1157 	if (strcmp(state, SCF_STATE_STRING_MAINT) == 0)
1158 		return ('m');
1159 
1160 	if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0)
1161 		return ('d');
1162 
1163 	if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0)
1164 		return ('D');
1165 
1166 	if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0)
1167 		return ('L');
1168 
1169 	return ('?');
1170 }
1171 
1172 /* Return true if inst is transitioning. */
1173 static int
1174 transitioning(scf_instance_t *inst)
1175 {
1176 	char nstate_name[MAX_SCF_STATE_STRING_SZ];
1177 
1178 	get_restarter_string_prop(inst, scf_property_next_state, nstate_name,
1179 	    sizeof (nstate_name));
1180 
1181 	return (state_to_char(nstate_name) != '?');
1182 }
1183 
1184 /* ARGSUSED */
1185 static void
1186 sortkey_states(const char *pname, char *buf, int reverse, scf_walkinfo_t *wip)
1187 {
1188 	char state_name[MAX_SCF_STATE_STRING_SZ];
1189 
1190 	/*
1191 	 * Lower numbers are printed first, so these are arranged from least
1192 	 * interesting ("legacy run") to most interesting (unknown).
1193 	 */
1194 	if (wip->pg == NULL) {
1195 		get_restarter_string_prop(wip->inst, pname, state_name,
1196 		    sizeof (state_name));
1197 
1198 		if (strcmp(state_name, SCF_STATE_STRING_ONLINE) == 0)
1199 			*buf = 2;
1200 		else if (strcmp(state_name, SCF_STATE_STRING_DEGRADED) == 0)
1201 			*buf = 3;
1202 		else if (strcmp(state_name, SCF_STATE_STRING_OFFLINE) == 0)
1203 			*buf = 4;
1204 		else if (strcmp(state_name, SCF_STATE_STRING_MAINT) == 0)
1205 			*buf = 5;
1206 		else if (strcmp(state_name, SCF_STATE_STRING_DISABLED) == 0)
1207 			*buf = 1;
1208 		else if (strcmp(state_name, SCF_STATE_STRING_UNINIT) == 0)
1209 			*buf = 6;
1210 		else
1211 			*buf = 7;
1212 	} else
1213 		*buf = 0;
1214 
1215 	if (reverse)
1216 		*buf = 255 - *buf;
1217 }
1218 
1219 static void
1220 sprint_state(char **buf, scf_walkinfo_t *wip)
1221 {
1222 	char state_name[MAX_SCF_STATE_STRING_SZ + 1];
1223 	size_t newsize;
1224 	char *newbuf;
1225 
1226 	if (wip->pg == NULL) {
1227 		get_restarter_string_prop(wip->inst, scf_property_state,
1228 		    state_name, sizeof (state_name));
1229 
1230 		/* Don't print blank fields, to ease parsing. */
1231 		if (state_name[0] == '\0') {
1232 			state_name[0] = '-';
1233 			state_name[1] = '\0';
1234 		}
1235 
1236 		if (!opt_nstate_shown && transitioning(wip->inst)) {
1237 			/* Append an asterisk if nstate is valid. */
1238 			(void) strcat(state_name, "*");
1239 		}
1240 	} else
1241 		(void) strcpy(state_name, SCF_STATE_STRING_LEGACY);
1242 
1243 	newsize = (*buf ? strlen(*buf) : 0) + MAX_SCF_STATE_STRING_SZ + 2;
1244 	newbuf = safe_malloc(newsize);
1245 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1246 	    MAX_SCF_STATE_STRING_SZ + 1, state_name);
1247 
1248 	if (*buf)
1249 		free(*buf);
1250 	*buf = newbuf;
1251 }
1252 
1253 static void
1254 sortkey_state(char *buf, int reverse, scf_walkinfo_t *wip)
1255 {
1256 	sortkey_states(scf_property_state, buf, reverse, wip);
1257 }
1258 
1259 static void
1260 sprint_nstate(char **buf, scf_walkinfo_t *wip)
1261 {
1262 	char next_state_name[MAX_SCF_STATE_STRING_SZ];
1263 	boolean_t blank = 0;
1264 	size_t newsize;
1265 	char *newbuf;
1266 
1267 	if (wip->pg == NULL) {
1268 		get_restarter_string_prop(wip->inst, scf_property_next_state,
1269 		    next_state_name, sizeof (next_state_name));
1270 
1271 		/* Don't print blank fields, to ease parsing. */
1272 		if (next_state_name[0] == '\0' ||
1273 		    strcmp(next_state_name, SCF_STATE_STRING_NONE) == 0)
1274 			blank = 1;
1275 	} else
1276 		blank = 1;
1277 
1278 	if (blank) {
1279 		next_state_name[0] = '-';
1280 		next_state_name[1] = '\0';
1281 	}
1282 
1283 	newsize = (*buf ? strlen(*buf) : 0) + MAX_SCF_STATE_STRING_SZ + 1;
1284 	newbuf = safe_malloc(newsize);
1285 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1286 	    MAX_SCF_STATE_STRING_SZ - 1, next_state_name);
1287 	if (*buf)
1288 		free(*buf);
1289 	*buf = newbuf;
1290 }
1291 
1292 static void
1293 sortkey_nstate(char *buf, int reverse, scf_walkinfo_t *wip)
1294 {
1295 	sortkey_states(scf_property_next_state, buf, reverse, wip);
1296 }
1297 
1298 static void
1299 sprint_s(char **buf, scf_walkinfo_t *wip)
1300 {
1301 	char tmp[3];
1302 	char state_name[MAX_SCF_STATE_STRING_SZ];
1303 	size_t newsize = (*buf ? strlen(*buf) : 0) + 4;
1304 	char *newbuf = safe_malloc(newsize);
1305 
1306 	if (wip->pg == NULL) {
1307 		get_restarter_string_prop(wip->inst, scf_property_state,
1308 		    state_name, sizeof (state_name));
1309 		tmp[0] = state_to_char(state_name);
1310 
1311 		if (!opt_nstate_shown && transitioning(wip->inst))
1312 			tmp[1] = '*';
1313 		else
1314 			tmp[1] = ' ';
1315 	} else {
1316 		tmp[0] = 'L';
1317 		tmp[1] = ' ';
1318 	}
1319 	tmp[2] = ' ';
1320 	(void) snprintf(newbuf, newsize, "%s%-*s", *buf ? *buf : "",
1321 	    3, tmp);
1322 	if (*buf)
1323 		free(*buf);
1324 	*buf = newbuf;
1325 }
1326 
1327 static void
1328 sprint_n(char **buf, scf_walkinfo_t *wip)
1329 {
1330 	char tmp[2];
1331 	size_t newsize = (*buf ? strlen(*buf) : 0) + 3;
1332 	char *newbuf = safe_malloc(newsize);
1333 	char nstate_name[MAX_SCF_STATE_STRING_SZ];
1334 
1335 	if (wip->pg == NULL) {
1336 		get_restarter_string_prop(wip->inst, scf_property_next_state,
1337 		    nstate_name, sizeof (nstate_name));
1338 
1339 		if (strcmp(nstate_name, SCF_STATE_STRING_NONE) == 0)
1340 			tmp[0] = '-';
1341 		else
1342 			tmp[0] = state_to_char(nstate_name);
1343 	} else
1344 		tmp[0] = '-';
1345 
1346 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1347 	    2, tmp);
1348 	if (*buf)
1349 		free(*buf);
1350 	*buf = newbuf;
1351 }
1352 
1353 static void
1354 sprint_sn(char **buf, scf_walkinfo_t *wip)
1355 {
1356 	char tmp[3];
1357 	size_t newsize = (*buf ? strlen(*buf) : 0) + 4;
1358 	char *newbuf = safe_malloc(newsize);
1359 	char nstate_name[MAX_SCF_STATE_STRING_SZ];
1360 	char state_name[MAX_SCF_STATE_STRING_SZ];
1361 
1362 	if (wip->pg == NULL) {
1363 		get_restarter_string_prop(wip->inst, scf_property_state,
1364 		    state_name, sizeof (state_name));
1365 		get_restarter_string_prop(wip->inst, scf_property_next_state,
1366 		    nstate_name, sizeof (nstate_name));
1367 		tmp[0] = state_to_char(state_name);
1368 
1369 		if (strcmp(nstate_name, SCF_STATE_STRING_NONE) == 0)
1370 			tmp[1] = '-';
1371 		else
1372 			tmp[1] = state_to_char(nstate_name);
1373 	} else {
1374 		tmp[0] = 'L';
1375 		tmp[1] = '-';
1376 	}
1377 
1378 	tmp[2] = ' ';
1379 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1380 	    3, tmp);
1381 	if (*buf)
1382 		free(*buf);
1383 	*buf = newbuf;
1384 }
1385 
1386 /* ARGSUSED */
1387 static void
1388 sortkey_sn(char *buf, int reverse, scf_walkinfo_t *wip)
1389 {
1390 	sortkey_state(buf, reverse, wip);
1391 	sortkey_nstate(buf + 1, reverse, wip);
1392 }
1393 
1394 static const char *
1395 state_abbrev(const char *state)
1396 {
1397 	if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0)
1398 		return ("UN");
1399 	if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0)
1400 		return ("OFF");
1401 	if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0)
1402 		return ("ON");
1403 	if (strcmp(state, SCF_STATE_STRING_MAINT) == 0)
1404 		return ("MNT");
1405 	if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0)
1406 		return ("DIS");
1407 	if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0)
1408 		return ("DGD");
1409 	if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0)
1410 		return ("LRC");
1411 
1412 	return ("?");
1413 }
1414 
1415 static void
1416 sprint_sta(char **buf, scf_walkinfo_t *wip)
1417 {
1418 	char state_name[MAX_SCF_STATE_STRING_SZ];
1419 	char sta[5];
1420 	size_t newsize = (*buf ? strlen(*buf) : 0) + 6;
1421 	char *newbuf = safe_malloc(newsize);
1422 
1423 	if (wip->pg == NULL)
1424 		get_restarter_string_prop(wip->inst, scf_property_state,
1425 		    state_name, sizeof (state_name));
1426 	else
1427 		(void) strcpy(state_name, SCF_STATE_STRING_LEGACY);
1428 
1429 	(void) strcpy(sta, state_abbrev(state_name));
1430 
1431 	if (wip->pg == NULL && !opt_nstate_shown && transitioning(wip->inst))
1432 		(void) strcat(sta, "*");
1433 
1434 	(void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", sta);
1435 	if (*buf)
1436 		free(*buf);
1437 	*buf = newbuf;
1438 }
1439 
1440 static void
1441 sprint_nsta(char **buf, scf_walkinfo_t *wip)
1442 {
1443 	char state_name[MAX_SCF_STATE_STRING_SZ];
1444 	size_t newsize = (*buf ? strlen(*buf) : 0) + 6;
1445 	char *newbuf = safe_malloc(newsize);
1446 
1447 	if (wip->pg == NULL)
1448 		get_restarter_string_prop(wip->inst, scf_property_next_state,
1449 		    state_name, sizeof (state_name));
1450 	else
1451 		(void) strcpy(state_name, SCF_STATE_STRING_NONE);
1452 
1453 	if (strcmp(state_name, SCF_STATE_STRING_NONE) == 0)
1454 		(void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "",
1455 		    "-");
1456 	else
1457 		(void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "",
1458 		    state_abbrev(state_name));
1459 	if (*buf)
1460 		free(*buf);
1461 	*buf = newbuf;
1462 }
1463 
1464 /* FMRI */
1465 #define	FMRI_COLUMN_WIDTH	50
1466 static void
1467 sprint_fmri(char **buf, scf_walkinfo_t *wip)
1468 {
1469 	char *fmri_buf = safe_malloc(max_scf_fmri_length + 1);
1470 	size_t newsize;
1471 	char *newbuf;
1472 
1473 	if (wip->pg == NULL) {
1474 		if (scf_instance_to_fmri(wip->inst, fmri_buf,
1475 		    max_scf_fmri_length + 1) == -1)
1476 			scfdie();
1477 	} else {
1478 		(void) strcpy(fmri_buf, SCF_FMRI_LEGACY_PREFIX);
1479 		if (pg_get_single_val(wip->pg, SCF_LEGACY_PROPERTY_NAME,
1480 		    SCF_TYPE_ASTRING, fmri_buf +
1481 		    sizeof (SCF_FMRI_LEGACY_PREFIX) - 1,
1482 		    max_scf_fmri_length + 1 -
1483 		    (sizeof (SCF_FMRI_LEGACY_PREFIX) - 1), 0) != 0)
1484 			(void) strcat(fmri_buf, LEGACY_UNKNOWN);
1485 	}
1486 
1487 	if (strlen(fmri_buf) > FMRI_COLUMN_WIDTH)
1488 		newsize = (*buf ? strlen(*buf) : 0) + strlen(fmri_buf) + 2;
1489 	else
1490 		newsize = (*buf ? strlen(*buf) : 0) + FMRI_COLUMN_WIDTH + 2;
1491 	newbuf = safe_malloc(newsize);
1492 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1493 	    FMRI_COLUMN_WIDTH, fmri_buf);
1494 	free(fmri_buf);
1495 	if (*buf)
1496 		free(*buf);
1497 	*buf = newbuf;
1498 }
1499 
1500 static void
1501 sortkey_fmri(char *buf, int reverse, scf_walkinfo_t *wip)
1502 {
1503 	char *tmp = NULL;
1504 
1505 	sprint_fmri(&tmp, wip);
1506 	bcopy(tmp, buf, FMRI_COLUMN_WIDTH);
1507 	free(tmp);
1508 	if (reverse)
1509 		reverse_bytes(buf, FMRI_COLUMN_WIDTH);
1510 }
1511 
1512 /* Component columns */
1513 #define	COMPONENT_COLUMN_WIDTH	20
1514 static void
1515 sprint_scope(char **buf, scf_walkinfo_t *wip)
1516 {
1517 	char *scope_buf = safe_malloc(max_scf_name_length + 1);
1518 	size_t newsize = (*buf ? strlen(*buf) : 0) + COMPONENT_COLUMN_WIDTH + 2;
1519 	char *newbuf = safe_malloc(newsize);
1520 
1521 	assert(wip->scope != NULL);
1522 
1523 	if (scf_scope_get_name(wip->scope, scope_buf, max_scf_name_length) < 0)
1524 		scfdie();
1525 
1526 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1527 	    COMPONENT_COLUMN_WIDTH, scope_buf);
1528 	if (*buf)
1529 		free(*buf);
1530 	*buf = newbuf;
1531 	free(scope_buf);
1532 }
1533 
1534 static void
1535 sortkey_scope(char *buf, int reverse, scf_walkinfo_t *wip)
1536 {
1537 	char *tmp = NULL;
1538 
1539 	sprint_scope(&tmp, wip);
1540 	bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH);
1541 	free(tmp);
1542 	if (reverse)
1543 		reverse_bytes(buf, COMPONENT_COLUMN_WIDTH);
1544 }
1545 
1546 static void
1547 sprint_service(char **buf, scf_walkinfo_t *wip)
1548 {
1549 	char *svc_buf = safe_malloc(max_scf_name_length + 1);
1550 	char *newbuf;
1551 	size_t newsize;
1552 
1553 	if (wip->pg == NULL) {
1554 		if (scf_service_get_name(wip->svc, svc_buf,
1555 		    max_scf_name_length + 1) < 0)
1556 			scfdie();
1557 	} else {
1558 		if (pg_get_single_val(wip->pg, "name", SCF_TYPE_ASTRING,
1559 		    svc_buf, max_scf_name_length + 1, EMPTY_OK) != 0)
1560 			(void) strcpy(svc_buf, LEGACY_UNKNOWN);
1561 	}
1562 
1563 
1564 	if (strlen(svc_buf) > COMPONENT_COLUMN_WIDTH)
1565 		newsize = (*buf ? strlen(*buf) : 0) + strlen(svc_buf) + 2;
1566 	else
1567 		newsize = (*buf ? strlen(*buf) : 0) +
1568 		    COMPONENT_COLUMN_WIDTH + 2;
1569 	newbuf = safe_malloc(newsize);
1570 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1571 	    COMPONENT_COLUMN_WIDTH, svc_buf);
1572 	free(svc_buf);
1573 	if (*buf)
1574 		free(*buf);
1575 	*buf = newbuf;
1576 }
1577 
1578 static void
1579 sortkey_service(char *buf, int reverse, scf_walkinfo_t *wip)
1580 {
1581 	char *tmp = NULL;
1582 
1583 	sprint_service(&tmp, wip);
1584 	bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH);
1585 	free(tmp);
1586 	if (reverse)
1587 		reverse_bytes(buf, COMPONENT_COLUMN_WIDTH);
1588 }
1589 
1590 /* INST */
1591 static void
1592 sprint_instance(char **buf, scf_walkinfo_t *wip)
1593 {
1594 	char *tmp = safe_malloc(max_scf_name_length + 1);
1595 	size_t newsize = (*buf ? strlen(*buf) : 0) + COMPONENT_COLUMN_WIDTH + 2;
1596 	char *newbuf = safe_malloc(newsize);
1597 
1598 	if (wip->pg == NULL) {
1599 		if (scf_instance_get_name(wip->inst, tmp,
1600 		    max_scf_name_length + 1) < 0)
1601 			scfdie();
1602 	} else {
1603 		tmp[0] = '-';
1604 		tmp[1] = '\0';
1605 	}
1606 
1607 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1608 	    COMPONENT_COLUMN_WIDTH, tmp);
1609 	if (*buf)
1610 		free(*buf);
1611 	*buf = newbuf;
1612 	free(tmp);
1613 }
1614 
1615 static void
1616 sortkey_instance(char *buf, int reverse, scf_walkinfo_t *wip)
1617 {
1618 	char *tmp = NULL;
1619 
1620 	sprint_instance(&tmp, wip);
1621 	bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH);
1622 	free(tmp);
1623 	if (reverse)
1624 		reverse_bytes(buf, COMPONENT_COLUMN_WIDTH);
1625 }
1626 
1627 /* STIME */
1628 #define	STIME_COLUMN_WIDTH		8
1629 #define	FORMAT_TIME			"%k:%M:%S"
1630 #define	FORMAT_DATE			"%b_%d  "
1631 #define	FORMAT_YEAR			"%Y    "
1632 
1633 /*
1634  * sprint_stime() will allocate a new buffer and snprintf the services's
1635  * state timestamp.  If the timestamp is unavailable for some reason
1636  * a '-' is given instead.
1637  */
1638 static void
1639 sprint_stime(char **buf, scf_walkinfo_t *wip)
1640 {
1641 	int r;
1642 	struct timeval tv;
1643 	time_t then;
1644 	struct tm *tm;
1645 	char st_buf[STIME_COLUMN_WIDTH + 1];
1646 	size_t newsize = (*buf ? strlen(*buf) : 0) + STIME_COLUMN_WIDTH + 2;
1647 	char *newbuf = safe_malloc(newsize);
1648 
1649 	if (wip->pg == NULL) {
1650 		r = get_restarter_time_prop(wip->inst,
1651 		    SCF_PROPERTY_STATE_TIMESTAMP, &tv, 0);
1652 	} else {
1653 		r = pg_get_single_val(wip->pg, SCF_PROPERTY_STATE_TIMESTAMP,
1654 		    SCF_TYPE_TIME, &tv, NULL, 0);
1655 	}
1656 
1657 	if (r != 0) {
1658 		/*
1659 		 * There's something amiss with our service
1660 		 * so we'll print a '-' for STIME.
1661 		 */
1662 		(void) snprintf(newbuf, newsize, "%s%-*s", *buf ? *buf : "",
1663 		    STIME_COLUMN_WIDTH + 1, "-");
1664 	} else {
1665 		/* tv should be valid so we'll format it */
1666 		then = (time_t)tv.tv_sec;
1667 
1668 		tm = localtime(&then);
1669 		/*
1670 		 * Print time if started within the past 24 hours, print date
1671 		 * if within the past 12 months or, finally, print year if
1672 		 * started greater than 12 months ago.
1673 		 */
1674 		if (now - then < 24 * 60 * 60) {
1675 			(void) strftime(st_buf, sizeof (st_buf),
1676 			    gettext(FORMAT_TIME), tm);
1677 		} else if (now - then < 12 * 30 * 24 * 60 * 60) {
1678 			(void) strftime(st_buf, sizeof (st_buf),
1679 			    gettext(FORMAT_DATE), tm);
1680 		} else {
1681 			(void) strftime(st_buf, sizeof (st_buf),
1682 			    gettext(FORMAT_YEAR), tm);
1683 		}
1684 		(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1685 		    STIME_COLUMN_WIDTH + 1, st_buf);
1686 	}
1687 	if (*buf)
1688 		free(*buf);
1689 	*buf = newbuf;
1690 }
1691 
1692 #define	STIME_SORTKEY_WIDTH		(sizeof (uint64_t) + sizeof (uint32_t))
1693 
1694 /* ARGSUSED */
1695 static void
1696 sortkey_stime(char *buf, int reverse, scf_walkinfo_t *wip)
1697 {
1698 	struct timeval tv;
1699 	int r;
1700 
1701 	if (wip->pg == NULL)
1702 		r = get_restarter_time_prop(wip->inst,
1703 		    SCF_PROPERTY_STATE_TIMESTAMP, &tv, 0);
1704 	else
1705 		r = pg_get_single_val(wip->pg, SCF_PROPERTY_STATE_TIMESTAMP,
1706 		    SCF_TYPE_TIME, &tv, NULL, 0);
1707 
1708 	if (r == 0) {
1709 		int64_t sec;
1710 		int32_t us;
1711 
1712 		/* Stick it straight into the buffer. */
1713 		sec = tv.tv_sec;
1714 		us = tv.tv_usec;
1715 
1716 		sec = BE_64(sec);
1717 		us = BE_32(us);
1718 		bcopy(&sec, buf, sizeof (sec));
1719 		bcopy(&us, buf + sizeof (sec), sizeof (us));
1720 	} else {
1721 		bzero(buf, STIME_SORTKEY_WIDTH);
1722 	}
1723 
1724 	if (reverse)
1725 		reverse_bytes(buf, STIME_SORTKEY_WIDTH);
1726 }
1727 
1728 /* ZONE */
1729 #define	ZONE_COLUMN_WIDTH	16
1730 /*ARGSUSED*/
1731 static void
1732 sprint_zone(char **buf, scf_walkinfo_t *wip)
1733 {
1734 	size_t newsize;
1735 	char *newbuf, *zonename = g_zonename, b[ZONENAME_MAX];
1736 
1737 	if (zonename == NULL) {
1738 		zoneid_t zoneid = getzoneid();
1739 
1740 		if (getzonenamebyid(zoneid, b, sizeof (b)) < 0)
1741 			uu_die(gettext("could not determine zone name"));
1742 
1743 		zonename = b;
1744 	}
1745 
1746 	if (strlen(zonename) > ZONE_COLUMN_WIDTH)
1747 		newsize = (*buf ? strlen(*buf) : 0) + strlen(zonename) + 2;
1748 	else
1749 		newsize = (*buf ? strlen(*buf) : 0) + ZONE_COLUMN_WIDTH + 2;
1750 
1751 	newbuf = safe_malloc(newsize);
1752 	(void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "",
1753 	    ZONE_COLUMN_WIDTH, zonename);
1754 
1755 	if (*buf)
1756 		free(*buf);
1757 	*buf = newbuf;
1758 }
1759 
1760 static void
1761 sortkey_zone(char *buf, int reverse, scf_walkinfo_t *wip)
1762 {
1763 	char *tmp = NULL;
1764 
1765 	sprint_zone(&tmp, wip);
1766 	bcopy(tmp, buf, ZONE_COLUMN_WIDTH);
1767 	free(tmp);
1768 	if (reverse)
1769 		reverse_bytes(buf, ZONE_COLUMN_WIDTH);
1770 }
1771 
1772 /*
1773  * Information about columns which can be displayed.  If you add something,
1774  * check MAX_COLUMN_NAME_LENGTH_STR & update description_of_column() below.
1775  */
1776 static const struct column columns[] = {
1777 	{ "CTID", CTID_COLUMN_WIDTH, sprint_ctid,
1778 		CTID_SORTKEY_WIDTH, sortkey_ctid },
1779 	{ "DESC", DESC_COLUMN_WIDTH, sprint_desc,
1780 		DESC_COLUMN_WIDTH, sortkey_desc },
1781 	{ "FMRI", FMRI_COLUMN_WIDTH, sprint_fmri,
1782 		FMRI_COLUMN_WIDTH, sortkey_fmri },
1783 	{ "INST", COMPONENT_COLUMN_WIDTH, sprint_instance,
1784 		COMPONENT_COLUMN_WIDTH, sortkey_instance },
1785 	{ "N", 1,  sprint_n, 1, sortkey_nstate },
1786 	{ "NSTA", 4, sprint_nsta, 1, sortkey_nstate },
1787 	{ "NSTATE", MAX_SCF_STATE_STRING_SZ - 1, sprint_nstate,
1788 		1, sortkey_nstate },
1789 	{ "S", 2, sprint_s, 1, sortkey_state },
1790 	{ "SCOPE", COMPONENT_COLUMN_WIDTH, sprint_scope,
1791 		COMPONENT_COLUMN_WIDTH, sortkey_scope },
1792 	{ "SN", 2, sprint_sn, 2, sortkey_sn },
1793 	{ "SVC", COMPONENT_COLUMN_WIDTH, sprint_service,
1794 		COMPONENT_COLUMN_WIDTH, sortkey_service },
1795 	{ "STA", 4, sprint_sta, 1, sortkey_state },
1796 	{ "STATE", MAX_SCF_STATE_STRING_SZ - 1 + 1, sprint_state,
1797 		1, sortkey_state },
1798 	{ "STIME", STIME_COLUMN_WIDTH, sprint_stime,
1799 		STIME_SORTKEY_WIDTH, sortkey_stime },
1800 	{ "ZONE", ZONE_COLUMN_WIDTH, sprint_zone,
1801 		ZONE_COLUMN_WIDTH, sortkey_zone },
1802 };
1803 
1804 #define	MAX_COLUMN_NAME_LENGTH_STR	"6"
1805 
1806 static const int ncolumns = sizeof (columns) / sizeof (columns[0]);
1807 
1808 /*
1809  * Necessary thanks to gettext() & xgettext.
1810  */
1811 static const char *
1812 description_of_column(int c)
1813 {
1814 	const char *s = NULL;
1815 
1816 	switch (c) {
1817 	case 0:
1818 		s = gettext("contract ID for service (see contract(4))");
1819 		break;
1820 	case 1:
1821 		s = gettext("human-readable description of the service");
1822 		break;
1823 	case 2:
1824 		s = gettext("Fault Managed Resource Identifier for service");
1825 		break;
1826 	case 3:
1827 		s = gettext("portion of the FMRI indicating service instance");
1828 		break;
1829 	case 4:
1830 		s = gettext("abbreviation for next state (if in transition)");
1831 		break;
1832 	case 5:
1833 		s = gettext("abbreviation for next state (if in transition)");
1834 		break;
1835 	case 6:
1836 		s = gettext("name for next state (if in transition)");
1837 		break;
1838 	case 7:
1839 		s = gettext("abbreviation for current state");
1840 		break;
1841 	case 8:
1842 		s = gettext("name for scope associated with service");
1843 		break;
1844 	case 9:
1845 		s = gettext("abbreviation for current state and next state");
1846 		break;
1847 	case 10:
1848 		s = gettext("portion of the FMRI representing service name");
1849 		break;
1850 	case 11:
1851 		s = gettext("abbreviation for current state");
1852 		break;
1853 	case 12:
1854 		s = gettext("name for current state");
1855 		break;
1856 	case 13:
1857 		s = gettext("time of last state change");
1858 		break;
1859 	case 14:
1860 		s = gettext("name of zone");
1861 		break;
1862 	}
1863 
1864 	assert(s != NULL);
1865 	return (s);
1866 }
1867 
1868 
1869 static void
1870 print_usage(const char *progname, FILE *f, boolean_t do_exit)
1871 {
1872 	(void) fprintf(f, gettext(
1873 	    "Usage: %1$s [-aHpv] [-o col[,col ... ]] [-R restarter] "
1874 	    "[-sS col] [-Z | -z zone ]\n            [<service> ...]\n"
1875 	    "       %1$s -d | -D [-Hpv] [-o col[,col ... ]] [-sS col] "
1876 	    "[-Z | -z zone ]\n            [<service> ...]\n"
1877 	    "       %1$s [-l | -L] [-Z | -z zone] <service> ...\n"
1878 	    "       %1$s -x [-v] [-Z | -z zone] [<service> ...]\n"
1879 	    "       %1$s -?\n"), progname);
1880 
1881 	if (do_exit)
1882 		exit(UU_EXIT_USAGE);
1883 }
1884 
1885 #define	argserr(progname)	print_usage(progname, stderr, B_TRUE)
1886 
1887 static void
1888 print_help(const char *progname)
1889 {
1890 	int i;
1891 
1892 	print_usage(progname, stdout, B_FALSE);
1893 
1894 	(void) printf(gettext("\n"
1895 	"\t-a  list all service instances rather than "
1896 	"only those that are enabled\n"
1897 	"\t-d  list dependencies of the specified service(s)\n"
1898 	"\t-D  list dependents of the specified service(s)\n"
1899 	"\t-H  omit header line from output\n"
1900 	"\t-l  list detailed information about the specified service(s)\n"
1901 	"\t-L  list the log file associated with the specified service(s)\n"
1902 	"\t-o  list only the specified columns in the output\n"
1903 	"\t-p  list process IDs and names associated with each service\n"
1904 	"\t-R  list only those services with the specified restarter\n"
1905 	"\t-s  sort output in ascending order by the specified column(s)\n"
1906 	"\t-S  sort output in descending order by the specified column(s)\n"
1907 	"\t-v  list verbose information appropriate to the type of output\n"
1908 	"\t-x  explain the status of services that might require maintenance,\n"
1909 	"\t    or explain the status of the specified service(s)\n"
1910 	"\t-z  from global zone, show services in a specified zone\n"
1911 	"\t-Z  from global zone, show services in all zones\n"
1912 	"\n\t"
1913 	"Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n"
1914 	"\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n"
1915 	"\n"
1916 	"\t%1$s [opts] svc:/network/smtp:sendmail\n"
1917 	"\t%1$s [opts] network/smtp:sendmail\n"
1918 	"\t%1$s [opts] network/*mail\n"
1919 	"\t%1$s [opts] network/smtp\n"
1920 	"\t%1$s [opts] smtp:sendmail\n"
1921 	"\t%1$s [opts] smtp\n"
1922 	"\t%1$s [opts] sendmail\n"
1923 	"\n\t"
1924 	"Columns for output or sorting can be specified using these names:\n"
1925 	"\n"), progname);
1926 
1927 	for (i = 0; i < ncolumns; i++) {
1928 		(void) printf("\t%-" MAX_COLUMN_NAME_LENGTH_STR "s  %s\n",
1929 		    columns[i].name, description_of_column(i));
1930 	}
1931 }
1932 
1933 
1934 /*
1935  * A getsubopt()-like function which returns an index into the columns table.
1936  * On success, *optionp is set to point to the next sub-option, or the
1937  * terminating null if there are none.
1938  */
1939 static int
1940 getcolumnopt(char **optionp)
1941 {
1942 	char *str = *optionp, *cp;
1943 	int i;
1944 
1945 	assert(optionp != NULL);
1946 	assert(*optionp != NULL);
1947 
1948 	cp = strchr(*optionp, ',');
1949 	if (cp != NULL)
1950 		*cp = '\0';
1951 
1952 	for (i = 0; i < ncolumns; ++i) {
1953 		if (strcasecmp(str, columns[i].name) == 0) {
1954 			if (cp != NULL)
1955 				*optionp = cp + 1;
1956 			else
1957 				*optionp = strchr(*optionp, '\0');
1958 
1959 			return (i);
1960 		}
1961 	}
1962 
1963 	return (-1);
1964 }
1965 
1966 static void
1967 print_header()
1968 {
1969 	int i;
1970 	char *line_buf, *cp;
1971 
1972 	line_buf = safe_malloc(line_sz);
1973 	cp = line_buf;
1974 	for (i = 0; i < opt_cnum; ++i) {
1975 		const struct column * const colp = &columns[opt_columns[i]];
1976 
1977 		(void) snprintf(cp, colp->width + 1, "%-*s", colp->width,
1978 		    colp->name);
1979 		cp += colp->width;
1980 		*cp++ = ' ';
1981 	}
1982 
1983 	/* Trim the trailing whitespace */
1984 	--cp;
1985 	while (*cp == ' ')
1986 		--cp;
1987 	*(cp+1) = '\0';
1988 	(void) puts(line_buf);
1989 
1990 	free(line_buf);
1991 }
1992 
1993 
1994 
1995 /*
1996  * Long listing (-l) functions.
1997  */
1998 
1999 static int
2000 pidcmp(const void *l, const void *r)
2001 {
2002 	pid_t lp = *(pid_t *)l, rp = *(pid_t *)r;
2003 
2004 	if (lp < rp)
2005 		return (-1);
2006 	if (lp > rp)
2007 		return (1);
2008 	return (0);
2009 }
2010 
2011 /*
2012  * This is the strlen() of the longest label ("description"), plus intercolumn
2013  * space.
2014  */
2015 #define	DETAILED_WIDTH	(11 + 2)
2016 
2017 /*
2018  * Callback routine to print header for contract id.
2019  * Called by ctids_by_restarter and print_detailed.
2020  */
2021 static void
2022 print_ctid_header()
2023 {
2024 	(void) printf("%-*s", DETAILED_WIDTH, "contract_id");
2025 }
2026 
2027 /*
2028  * Callback routine to print a contract id.
2029  * Called by ctids_by_restarter and print_detailed.
2030  */
2031 static void
2032 print_ctid_detailed(uint64_t c)
2033 {
2034 	(void) printf("%lu ", (ctid_t)c);
2035 }
2036 
2037 static void
2038 detailed_list_processes(scf_walkinfo_t *wip)
2039 {
2040 	uint64_t c;
2041 	pid_t *pids;
2042 	uint_t i, n;
2043 	psinfo_t psi;
2044 
2045 	if (get_restarter_count_prop(wip->inst, scf_property_contract, &c,
2046 	    EMPTY_OK) != 0)
2047 		return;
2048 
2049 	if (instance_processes(wip->inst, wip->fmri, &pids, &n) != 0)
2050 		return;
2051 
2052 	qsort(pids, n, sizeof (*pids), pidcmp);
2053 
2054 	for (i = 0; i < n; ++i) {
2055 		(void) printf("%-*s%lu", DETAILED_WIDTH, gettext("process"),
2056 		    pids[i]);
2057 
2058 		if (get_psinfo(pids[i], &psi) == 0)
2059 			(void) printf(" %.*s", PRARGSZ, psi.pr_psargs);
2060 
2061 		(void) putchar('\n');
2062 	}
2063 
2064 	free(pids);
2065 }
2066 
2067 /*
2068  * Determines the state of a dependency.  If the FMRI specifies a file, then we
2069  * fake up a state based on whether we can access the file.
2070  */
2071 static void
2072 get_fmri_state(char *fmri, char *state, size_t state_sz)
2073 {
2074 	char *lfmri;
2075 	const char *svc_name, *inst_name, *pg_name, *path;
2076 	scf_service_t *svc;
2077 	scf_instance_t *inst;
2078 	scf_iter_t *iter;
2079 
2080 	lfmri = safe_strdup(fmri);
2081 
2082 	/*
2083 	 * Check for file:// dependencies
2084 	 */
2085 	if (scf_parse_file_fmri(lfmri, NULL, &path) == SCF_SUCCESS) {
2086 		struct stat64 statbuf;
2087 		const char *msg;
2088 
2089 		if (stat64(path, &statbuf) == 0)
2090 			msg = "online";
2091 		else if (errno == ENOENT)
2092 			msg = "absent";
2093 		else
2094 			msg = "unknown";
2095 
2096 		(void) strlcpy(state, msg, state_sz);
2097 		return;
2098 	}
2099 
2100 	/*
2101 	 * scf_parse_file_fmri() may have overwritten part of the string, so
2102 	 * copy it back.
2103 	 */
2104 	(void) strcpy(lfmri, fmri);
2105 
2106 	if (scf_parse_svc_fmri(lfmri, NULL, &svc_name, &inst_name,
2107 	    &pg_name, NULL) != SCF_SUCCESS) {
2108 		free(lfmri);
2109 		(void) strlcpy(state, "invalid", state_sz);
2110 		return;
2111 	}
2112 
2113 	free(lfmri);
2114 
2115 	if (svc_name == NULL || pg_name != NULL) {
2116 		(void) strlcpy(state, "invalid", state_sz);
2117 		return;
2118 	}
2119 
2120 	if (inst_name != NULL) {
2121 		/* instance: get state */
2122 		inst = scf_instance_create(h);
2123 		if (inst == NULL)
2124 			scfdie();
2125 
2126 		if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL,
2127 		    NULL, SCF_DECODE_FMRI_EXACT) == SCF_SUCCESS)
2128 			get_restarter_string_prop(inst, scf_property_state,
2129 			    state, state_sz);
2130 		else {
2131 			switch (scf_error()) {
2132 			case SCF_ERROR_INVALID_ARGUMENT:
2133 				(void) strlcpy(state, "invalid", state_sz);
2134 				break;
2135 			case SCF_ERROR_NOT_FOUND:
2136 				(void) strlcpy(state, "absent", state_sz);
2137 				break;
2138 
2139 			default:
2140 				scfdie();
2141 			}
2142 		}
2143 
2144 		scf_instance_destroy(inst);
2145 		return;
2146 	}
2147 
2148 	/*
2149 	 * service: If only one instance, use that state.  Otherwise, say
2150 	 * "multiple".
2151 	 */
2152 	if ((svc = scf_service_create(h)) == NULL ||
2153 	    (inst = scf_instance_create(h)) == NULL ||
2154 	    (iter = scf_iter_create(h)) == NULL)
2155 		scfdie();
2156 
2157 	if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL,
2158 	    SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) {
2159 		switch (scf_error()) {
2160 		case SCF_ERROR_INVALID_ARGUMENT:
2161 			(void) strlcpy(state, "invalid", state_sz);
2162 			goto out;
2163 		case SCF_ERROR_NOT_FOUND:
2164 			(void) strlcpy(state, "absent", state_sz);
2165 			goto out;
2166 
2167 		default:
2168 			scfdie();
2169 		}
2170 	}
2171 
2172 	if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS)
2173 		scfdie();
2174 
2175 	switch (scf_iter_next_instance(iter, inst)) {
2176 	case 0:
2177 		(void) strlcpy(state, "absent", state_sz);
2178 		goto out;
2179 
2180 	case 1:
2181 		break;
2182 
2183 	default:
2184 		scfdie();
2185 	}
2186 
2187 	/* Get the state in case this is the only instance. */
2188 	get_restarter_string_prop(inst, scf_property_state, state, state_sz);
2189 
2190 	switch (scf_iter_next_instance(iter, inst)) {
2191 	case 0:
2192 		break;
2193 
2194 	case 1:
2195 		/* Nope, multiple instances. */
2196 		(void) strlcpy(state, "multiple", state_sz);
2197 		goto out;
2198 
2199 	default:
2200 		scfdie();
2201 	}
2202 
2203 out:
2204 	scf_iter_destroy(iter);
2205 	scf_instance_destroy(inst);
2206 	scf_service_destroy(svc);
2207 }
2208 
2209 static void
2210 print_application_properties(scf_walkinfo_t *wip, scf_snapshot_t *snap)
2211 {
2212 	scf_iter_t *pg_iter, *prop_iter, *val_iter;
2213 	scf_propertygroup_t *pg;
2214 	scf_property_t *prop;
2215 	scf_value_t *val;
2216 	scf_pg_tmpl_t *pt;
2217 	scf_prop_tmpl_t *prt;
2218 	char *pg_name_buf = safe_malloc(max_scf_name_length + 1);
2219 	char *prop_name_buf = safe_malloc(max_scf_name_length + 1);
2220 	char *snap_name = safe_malloc(max_scf_name_length + 1);
2221 	char *val_buf = safe_malloc(max_scf_value_length + 1);
2222 	char *desc, *cp;
2223 	scf_type_t type;
2224 	int i, j, k;
2225 	uint8_t vis;
2226 
2227 	if ((pg_iter = scf_iter_create(h)) == NULL ||
2228 	    (prop_iter = scf_iter_create(h)) == NULL ||
2229 	    (val_iter = scf_iter_create(h)) == NULL ||
2230 	    (val = scf_value_create(h)) == NULL ||
2231 	    (prop = scf_property_create(h)) == NULL ||
2232 	    (pt = scf_tmpl_pg_create(h)) == NULL ||
2233 	    (prt = scf_tmpl_prop_create(h)) == NULL ||
2234 	    (pg = scf_pg_create(h)) == NULL)
2235 		scfdie();
2236 
2237 	if (scf_iter_instance_pgs_typed_composed(pg_iter, wip->inst, snap,
2238 	    SCF_PG_APP_DEFAULT) == -1)
2239 		scfdie();
2240 
2241 	/*
2242 	 * Format for output:
2243 	 *	pg (pgtype)
2244 	 *	 description
2245 	 *	pg/prop (proptype) = <value> <value>
2246 	 *	 description
2247 	 */
2248 	while ((i = scf_iter_next_pg(pg_iter, pg)) == 1) {
2249 		int tmpl = 0;
2250 
2251 		if (scf_pg_get_name(pg, pg_name_buf, max_scf_name_length) < 0)
2252 			scfdie();
2253 		if (scf_snapshot_get_name(snap, snap_name,
2254 		    max_scf_name_length) < 0)
2255 			scfdie();
2256 
2257 		if (scf_tmpl_get_by_pg_name(wip->fmri, snap_name, pg_name_buf,
2258 		    SCF_PG_APP_DEFAULT, pt, 0) == 0)
2259 			tmpl = 1;
2260 		else
2261 			tmpl = 0;
2262 
2263 		(void) printf("%s (%s)\n", pg_name_buf, SCF_PG_APP_DEFAULT);
2264 
2265 		if (tmpl == 1 && scf_tmpl_pg_description(pt, NULL, &desc) > 0) {
2266 			(void) printf("  %s\n", desc);
2267 			free(desc);
2268 		}
2269 
2270 		if (scf_iter_pg_properties(prop_iter, pg) == -1)
2271 			scfdie();
2272 		while ((j = scf_iter_next_property(prop_iter, prop)) == 1) {
2273 			if (scf_property_get_name(prop, prop_name_buf,
2274 			    max_scf_name_length) < 0)
2275 				scfdie();
2276 			if (scf_property_type(prop, &type) == -1)
2277 				scfdie();
2278 
2279 			if ((tmpl == 1) &&
2280 			    (scf_tmpl_get_by_prop(pt, prop_name_buf, prt,
2281 			    0) != 0))
2282 				tmpl = 0;
2283 
2284 			if (tmpl == 1 &&
2285 			    scf_tmpl_prop_visibility(prt, &vis) != -1 &&
2286 			    vis == SCF_TMPL_VISIBILITY_HIDDEN)
2287 				continue;
2288 
2289 			(void) printf("%s/%s (%s) = ", pg_name_buf,
2290 			    prop_name_buf, scf_type_to_string(type));
2291 
2292 			if (scf_iter_property_values(val_iter, prop) == -1)
2293 				scfdie();
2294 
2295 			while ((k = scf_iter_next_value(val_iter, val)) == 1) {
2296 				if (scf_value_get_as_string(val, val_buf,
2297 				    max_scf_value_length + 1) < 0)
2298 					scfdie();
2299 				if (strpbrk(val_buf, " \t\n\"()") != NULL) {
2300 					(void) printf("\"");
2301 					for (cp = val_buf; *cp != '\0'; ++cp) {
2302 						if (*cp == '"' || *cp == '\\')
2303 							(void) putc('\\',
2304 							    stdout);
2305 
2306 						(void) putc(*cp, stdout);
2307 					}
2308 					(void) printf("\"");
2309 				} else {
2310 					(void) printf("%s ", val_buf);
2311 				}
2312 			}
2313 
2314 			(void) printf("\n");
2315 
2316 			if (k == -1)
2317 				scfdie();
2318 
2319 			if (tmpl == 1 && scf_tmpl_prop_description(prt, NULL,
2320 			    &desc) > 0) {
2321 				(void) printf("  %s\n", desc);
2322 				free(desc);
2323 			}
2324 		}
2325 		if (j == -1)
2326 			scfdie();
2327 	}
2328 	if (i == -1)
2329 		scfdie();
2330 
2331 
2332 	scf_iter_destroy(pg_iter);
2333 	scf_iter_destroy(prop_iter);
2334 	scf_iter_destroy(val_iter);
2335 	scf_value_destroy(val);
2336 	scf_property_destroy(prop);
2337 	scf_tmpl_pg_destroy(pt);
2338 	scf_tmpl_prop_destroy(prt);
2339 	scf_pg_destroy(pg);
2340 	free(pg_name_buf);
2341 	free(prop_name_buf);
2342 	free(snap_name);
2343 	free(val_buf);
2344 }
2345 
2346 static void
2347 print_detailed_dependency(scf_propertygroup_t *pg)
2348 {
2349 	scf_property_t *eprop;
2350 	scf_iter_t *iter;
2351 	scf_type_t ty;
2352 	char *val_buf;
2353 	int i;
2354 
2355 	if ((eprop = scf_property_create(h)) == NULL ||
2356 	    (iter = scf_iter_create(h)) == NULL)
2357 		scfdie();
2358 
2359 	val_buf = safe_malloc(max_scf_value_length + 1);
2360 
2361 	if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, eprop) !=
2362 	    SCF_SUCCESS ||
2363 	    scf_property_type(eprop, &ty) != SCF_SUCCESS ||
2364 	    ty != SCF_TYPE_FMRI)
2365 		return;
2366 
2367 	(void) printf("%-*s", DETAILED_WIDTH, gettext("dependency"));
2368 
2369 	/* Print the grouping */
2370 	if (pg_get_single_val(pg, SCF_PROPERTY_GROUPING, SCF_TYPE_ASTRING,
2371 	    val_buf, max_scf_value_length + 1, 0) == 0)
2372 		(void) fputs(val_buf, stdout);
2373 	else
2374 		(void) putchar('?');
2375 
2376 	(void) putchar('/');
2377 
2378 	if (pg_get_single_val(pg, SCF_PROPERTY_RESTART_ON, SCF_TYPE_ASTRING,
2379 	    val_buf, max_scf_value_length + 1, 0) == 0)
2380 		(void) fputs(val_buf, stdout);
2381 	else
2382 		(void) putchar('?');
2383 
2384 	/* Print the dependency entities. */
2385 	if (scf_iter_property_values(iter, eprop) == -1)
2386 		scfdie();
2387 
2388 	while ((i = scf_iter_next_value(iter, g_val)) == 1) {
2389 		char state[MAX_SCF_STATE_STRING_SZ];
2390 
2391 		if (scf_value_get_astring(g_val, val_buf,
2392 		    max_scf_value_length + 1) < 0)
2393 			scfdie();
2394 
2395 		(void) putchar(' ');
2396 		(void) fputs(val_buf, stdout);
2397 
2398 		/* Print the state. */
2399 		state[0] = '-';
2400 		state[1] = '\0';
2401 
2402 		get_fmri_state(val_buf, state, sizeof (state));
2403 
2404 		(void) printf(" (%s)", state);
2405 	}
2406 	if (i == -1)
2407 		scfdie();
2408 
2409 	(void) putchar('\n');
2410 
2411 	free(val_buf);
2412 	scf_iter_destroy(iter);
2413 	scf_property_destroy(eprop);
2414 }
2415 
2416 /* ARGSUSED */
2417 static int
2418 print_detailed(void *unused, scf_walkinfo_t *wip)
2419 {
2420 	scf_snapshot_t *snap;
2421 	scf_propertygroup_t *rpg;
2422 	scf_iter_t *pg_iter;
2423 
2424 	char *buf;
2425 	char *timebuf;
2426 	size_t tbsz;
2427 	int ret;
2428 	uint64_t c;
2429 	int temp, perm;
2430 	struct timeval tv;
2431 	time_t stime;
2432 	struct tm *tmp;
2433 	int restarter_spec;
2434 	int restarter_ret;
2435 
2436 	const char * const fmt = "%-*s%s\n";
2437 
2438 	assert(wip->pg == NULL);
2439 
2440 	rpg = scf_pg_create(h);
2441 	if (rpg == NULL)
2442 		scfdie();
2443 
2444 	if (first_paragraph)
2445 		first_paragraph = 0;
2446 	else
2447 		(void) putchar('\n');
2448 
2449 	buf = safe_malloc(max_scf_fmri_length + 1);
2450 
2451 	if (scf_instance_to_fmri(wip->inst, buf, max_scf_fmri_length + 1) != -1)
2452 		(void) printf(fmt, DETAILED_WIDTH, "fmri", buf);
2453 
2454 	if (common_name_buf == NULL)
2455 		common_name_buf = safe_malloc(max_scf_value_length + 1);
2456 
2457 	if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, locale,
2458 	    SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 1, 1)
2459 	    == 0)
2460 		(void) printf(fmt, DETAILED_WIDTH, gettext("name"),
2461 		    common_name_buf);
2462 	else if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, "C",
2463 	    SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 1, 1)
2464 	    == 0)
2465 		(void) printf(fmt, DETAILED_WIDTH, gettext("name"),
2466 		    common_name_buf);
2467 
2468 	if (g_zonename != NULL)
2469 		(void) printf(fmt, DETAILED_WIDTH, gettext("zone"), g_zonename);
2470 
2471 	/*
2472 	 * Synthesize an 'enabled' property that hides the enabled_ovr
2473 	 * implementation from the user.  If the service has been temporarily
2474 	 * set to a state other than its permanent value, alert the user with
2475 	 * a '(temporary)' message.
2476 	 */
2477 	perm = instance_enabled(wip->inst, B_FALSE);
2478 	temp = instance_enabled(wip->inst, B_TRUE);
2479 	if (temp != -1) {
2480 		if (temp != perm)
2481 			(void) printf(gettext("%-*s%s (temporary)\n"),
2482 			    DETAILED_WIDTH, gettext("enabled"),
2483 			    temp ? gettext("true") : gettext("false"));
2484 		else
2485 			(void) printf(fmt, DETAILED_WIDTH,
2486 			    gettext("enabled"), temp ? gettext("true") :
2487 			    gettext("false"));
2488 	} else if (perm != -1) {
2489 		(void) printf(fmt, DETAILED_WIDTH, gettext("enabled"),
2490 		    perm ? gettext("true") : gettext("false"));
2491 	}
2492 
2493 	/*
2494 	 * Property values may be longer than max_scf_fmri_length, but these
2495 	 * shouldn't be, so we'll just reuse buf.  The user can use svcprop if
2496 	 * they suspect something fishy.
2497 	 */
2498 	if (scf_instance_get_pg(wip->inst, SCF_PG_RESTARTER, rpg) != 0) {
2499 		if (scf_error() != SCF_ERROR_NOT_FOUND)
2500 			scfdie();
2501 
2502 		scf_pg_destroy(rpg);
2503 		rpg = NULL;
2504 	}
2505 
2506 	if (rpg) {
2507 		if (pg_get_single_val(rpg, scf_property_state, SCF_TYPE_ASTRING,
2508 		    buf, max_scf_fmri_length + 1, 0) == 0)
2509 			(void) printf(fmt, DETAILED_WIDTH, gettext("state"),
2510 			    buf);
2511 
2512 		if (pg_get_single_val(rpg, scf_property_next_state,
2513 		    SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0)
2514 			(void) printf(fmt, DETAILED_WIDTH,
2515 			    gettext("next_state"), buf);
2516 
2517 		if (pg_get_single_val(rpg, SCF_PROPERTY_STATE_TIMESTAMP,
2518 		    SCF_TYPE_TIME, &tv, NULL, 0) == 0) {
2519 			stime = tv.tv_sec;
2520 			tmp = localtime(&stime);
2521 			for (tbsz = 50; ; tbsz *= 2) {
2522 				timebuf = safe_malloc(tbsz);
2523 				if (strftime(timebuf, tbsz, NULL, tmp) != 0)
2524 					break;
2525 				free(timebuf);
2526 			}
2527 			(void) printf(fmt, DETAILED_WIDTH,
2528 			    gettext("state_time"),
2529 			    timebuf);
2530 			free(timebuf);
2531 		}
2532 
2533 		if (pg_get_single_val(rpg, SCF_PROPERTY_ALT_LOGFILE,
2534 		    SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0)
2535 			(void) printf(fmt, DETAILED_WIDTH,
2536 			    gettext("alt_logfile"), buf);
2537 
2538 		if (pg_get_single_val(rpg, SCF_PROPERTY_LOGFILE,
2539 		    SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0)
2540 			(void) printf(fmt, DETAILED_WIDTH, gettext("logfile"),
2541 			    buf);
2542 	}
2543 
2544 	if (inst_get_single_val(wip->inst, SCF_PG_GENERAL,
2545 	    SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, buf,
2546 	    max_scf_fmri_length + 1, 0, 0, 1) == 0)
2547 		(void) printf(fmt, DETAILED_WIDTH, gettext("restarter"), buf);
2548 	else
2549 		(void) printf(fmt, DETAILED_WIDTH, gettext("restarter"),
2550 		    SCF_SERVICE_STARTD);
2551 
2552 	free(buf);
2553 
2554 	/*
2555 	 * Use the restarter specific routine to print the ctids, if available.
2556 	 * If restarter specific action is available and it fails, then die.
2557 	 */
2558 	restarter_ret = ctids_by_restarter(wip, &c, 1, 0,
2559 	    &restarter_spec, print_ctid_header, print_ctid_detailed);
2560 	if (restarter_spec == 1) {
2561 		if (restarter_ret != 0)
2562 			uu_die(gettext("Unable to get restarter for %s"),
2563 			    wip->fmri);
2564 		goto restarter_common;
2565 	}
2566 
2567 	if (rpg) {
2568 		scf_iter_t *iter;
2569 
2570 		if ((iter = scf_iter_create(h)) == NULL)
2571 			scfdie();
2572 
2573 		if (scf_pg_get_property(rpg, scf_property_contract, g_prop) ==
2574 		    0) {
2575 			if (scf_property_is_type(g_prop, SCF_TYPE_COUNT) == 0) {
2576 
2577 				/* Callback to print ctid header */
2578 				print_ctid_header();
2579 
2580 				if (scf_iter_property_values(iter, g_prop) != 0)
2581 					scfdie();
2582 
2583 				for (;;) {
2584 					ret = scf_iter_next_value(iter, g_val);
2585 					if (ret == -1)
2586 						scfdie();
2587 					if (ret == 0)
2588 						break;
2589 
2590 					if (scf_value_get_count(g_val, &c) != 0)
2591 						scfdie();
2592 
2593 					/* Callback to print contract id. */
2594 					print_ctid_detailed(c);
2595 				}
2596 
2597 				(void) putchar('\n');
2598 			} else {
2599 				if (scf_error() != SCF_ERROR_TYPE_MISMATCH)
2600 					scfdie();
2601 			}
2602 		} else {
2603 			if (scf_error() != SCF_ERROR_NOT_FOUND)
2604 				scfdie();
2605 		}
2606 
2607 		scf_iter_destroy(iter);
2608 	} else {
2609 		if (scf_error() != SCF_ERROR_NOT_FOUND)
2610 			scfdie();
2611 	}
2612 
2613 restarter_common:
2614 	scf_pg_destroy(rpg);
2615 
2616 	/* Dependencies. */
2617 	if ((pg_iter = scf_iter_create(h)) == NULL)
2618 		scfdie();
2619 
2620 	snap = get_running_snapshot(wip->inst);
2621 
2622 	if (scf_iter_instance_pgs_typed_composed(pg_iter, wip->inst, snap,
2623 	    SCF_GROUP_DEPENDENCY) != SCF_SUCCESS)
2624 		scfdie();
2625 
2626 	while ((ret = scf_iter_next_pg(pg_iter, g_pg)) == 1)
2627 		print_detailed_dependency(g_pg);
2628 	if (ret == -1)
2629 		scfdie();
2630 
2631 	scf_iter_destroy(pg_iter);
2632 
2633 	if (opt_processes)
2634 		detailed_list_processes(wip);
2635 
2636 	/* "application" type property groups */
2637 	if (opt_verbose == 1)
2638 		print_application_properties(wip, snap);
2639 
2640 	scf_snapshot_destroy(snap);
2641 
2642 	return (0);
2643 }
2644 
2645 /* ARGSUSED */
2646 static int
2647 print_log(void *unused, scf_walkinfo_t *wip)
2648 {
2649 	scf_propertygroup_t *rpg;
2650 	char buf[MAXPATHLEN];
2651 
2652 	if ((rpg = scf_pg_create(h)) == NULL)
2653 		scfdie();
2654 
2655 	if (scf_instance_get_pg(wip->inst, SCF_PG_RESTARTER, rpg) != 0) {
2656 		if (scf_error() != SCF_ERROR_NOT_FOUND)
2657 			scfdie();
2658 
2659 		goto out;
2660 	}
2661 
2662 	if (pg_get_single_val(rpg, SCF_PROPERTY_LOGFILE,
2663 	    SCF_TYPE_ASTRING, buf, sizeof (buf), 0) == 0) {
2664 		(void) printf("%s\n", buf);
2665 	}
2666 
2667 out:
2668 	scf_pg_destroy(rpg);
2669 
2670 	return (0);
2671 }
2672 
2673 int
2674 qsort_str_compare(const void *p1, const void *p2)
2675 {
2676 	return (strcmp((const char *)p1, (const char *)p2));
2677 }
2678 
2679 /*
2680  * get_notify_param_classes()
2681  * return the fma classes that don't have a tag in fma_tags[], otherwise NULL
2682  */
2683 static char **
2684 get_notify_param_classes()
2685 {
2686 	scf_handle_t		*h = _scf_handle_create_and_bind(SCF_VERSION);
2687 	scf_instance_t		*inst = scf_instance_create(h);
2688 	scf_snapshot_t		*snap = scf_snapshot_create(h);
2689 	scf_snaplevel_t		*slvl = scf_snaplevel_create(h);
2690 	scf_propertygroup_t	*pg = scf_pg_create(h);
2691 	scf_iter_t		*iter = scf_iter_create(h);
2692 	int size = 4;
2693 	int n = 0;
2694 	size_t sz = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
2695 	int err;
2696 	char *pgname = safe_malloc(sz);
2697 	char **buf = safe_malloc(size * sizeof (char *));
2698 
2699 	if (h == NULL || inst == NULL || snap == NULL || slvl == NULL ||
2700 	    pg == NULL || iter == NULL) {
2701 		uu_die(gettext("Failed object creation: %s\n"),
2702 		    scf_strerror(scf_error()));
2703 	}
2704 
2705 	if (scf_handle_decode_fmri(h, SCF_NOTIFY_PARAMS_INST, NULL, NULL, inst,
2706 	    NULL, NULL, SCF_DECODE_FMRI_EXACT) != 0)
2707 		uu_die(gettext("Failed to decode %s: %s\n"),
2708 		    SCF_NOTIFY_PARAMS_INST, scf_strerror(scf_error()));
2709 
2710 	if (scf_instance_get_snapshot(inst, "running", snap) != 0)
2711 		uu_die(gettext("Failed to get snapshot: %s\n"),
2712 		    scf_strerror(scf_error()));
2713 
2714 	if (scf_snapshot_get_base_snaplevel(snap, slvl) != 0)
2715 		uu_die(gettext("Failed to get base snaplevel: %s\n"),
2716 		    scf_strerror(scf_error()));
2717 
2718 	if (scf_iter_snaplevel_pgs_typed(iter, slvl,
2719 	    SCF_NOTIFY_PARAMS_PG_TYPE) != 0)
2720 		uu_die(gettext("Failed to get iterator: %s\n"),
2721 		    scf_strerror(scf_error()));
2722 
2723 	while ((err = scf_iter_next_pg(iter, pg)) == 1) {
2724 		char *c;
2725 
2726 		if (scf_pg_get_name(pg, pgname, sz) == -1)
2727 			uu_die(gettext("Failed to get pg name: %s\n"),
2728 			    scf_strerror(scf_error()));
2729 		if ((c = strrchr(pgname, ',')) != NULL)
2730 			*c = '\0';
2731 		if (has_fma_tag(pgname))
2732 			continue;
2733 		if (!is_fma_token(pgname))
2734 			/*
2735 			 * We don't emmit a warning here so that we don't
2736 			 * pollute the output
2737 			 */
2738 			continue;
2739 
2740 		if (n + 1 >= size) {
2741 			size *= 2;
2742 			buf = realloc(buf, size * sizeof (char *));
2743 			if (buf == NULL)
2744 				uu_die(gettext("Out of memory.\n"));
2745 		}
2746 		buf[n] = safe_strdup(pgname);
2747 		++n;
2748 	}
2749 	/*
2750 	 * NULL terminate buf
2751 	 */
2752 	buf[n] = NULL;
2753 	if (err == -1)
2754 		uu_die(gettext("Failed to iterate pgs: %s\n"),
2755 		    scf_strerror(scf_error()));
2756 
2757 	/* sort the classes */
2758 	qsort((void *)buf, n, sizeof (char *), qsort_str_compare);
2759 
2760 	free(pgname);
2761 	scf_iter_destroy(iter);
2762 	scf_pg_destroy(pg);
2763 	scf_snaplevel_destroy(slvl);
2764 	scf_snapshot_destroy(snap);
2765 	scf_instance_destroy(inst);
2766 	scf_handle_destroy(h);
2767 
2768 	return (buf);
2769 }
2770 
2771 /*
2772  * get_fma_notify_params()
2773  * populates an nvlist_t with notifycation parameters for a given FMA class
2774  * returns 0 if the nvlist is populated, 1 otherwise;
2775  */
2776 int
2777 get_fma_notify_params(nvlist_t *nvl, const char *class)
2778 {
2779 	if (_scf_get_fma_notify_params(class, nvl, 0) != 0) {
2780 		/*
2781 		 * if the preferences have just been deleted
2782 		 * or does not exist, just skip.
2783 		 */
2784 		if (scf_error() != SCF_ERROR_NOT_FOUND &&
2785 		    scf_error() != SCF_ERROR_DELETED)
2786 			uu_warn(gettext(
2787 			    "Failed get_fma_notify_params %s\n"),
2788 			    scf_strerror(scf_error()));
2789 
2790 		return (1);
2791 	}
2792 
2793 	return (0);
2794 }
2795 
2796 /*
2797  * print_notify_fma()
2798  * outputs the notification paramets of FMA events.
2799  * It first outputs classes in fma_tags[], then outputs the other classes
2800  * sorted alphabetically
2801  */
2802 static void
2803 print_notify_fma(void)
2804 {
2805 	nvlist_t *nvl;
2806 	char **tmp = NULL;
2807 	char **classes, *p;
2808 	const char *class;
2809 	uint32_t i;
2810 
2811 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
2812 		uu_die(gettext("Out of memory.\n"));
2813 
2814 	for (i = 0; (class = get_fma_class(i)) != NULL; ++i) {
2815 		if (get_fma_notify_params(nvl, class) == 0)
2816 			listnotify_print(nvl, get_fma_tag(i));
2817 	}
2818 
2819 	if ((classes = get_notify_param_classes()) == NULL)
2820 		goto cleanup;
2821 
2822 	tmp = classes;
2823 	for (p = *tmp; p; ++tmp, p = *tmp) {
2824 		if (get_fma_notify_params(nvl, p) == 0)
2825 			listnotify_print(nvl, re_tag(p));
2826 
2827 		free(p);
2828 	}
2829 
2830 	free(classes);
2831 
2832 cleanup:
2833 	nvlist_free(nvl);
2834 }
2835 
2836 /*
2837  * print_notify_fmri()
2838  * prints notifycation parameters for an SMF instance.
2839  */
2840 static void
2841 print_notify_fmri(const char *fmri)
2842 {
2843 	nvlist_t *nvl;
2844 
2845 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
2846 		uu_die(gettext("Out of memory.\n"));
2847 
2848 	if (_scf_get_svc_notify_params(fmri, nvl, SCF_TRANSITION_ALL, 0, 0) !=
2849 	    SCF_SUCCESS) {
2850 		if (scf_error() != SCF_ERROR_NOT_FOUND &&
2851 		    scf_error() != SCF_ERROR_DELETED)
2852 			uu_warn(gettext(
2853 			    "Failed _scf_get_svc_notify_params: %s\n"),
2854 			    scf_strerror(scf_error()));
2855 	} else {
2856 		if (strcmp(SCF_INSTANCE_GLOBAL, fmri) == 0)
2857 			safe_printf(
2858 			    gettext("System wide notification parameters:\n"));
2859 		safe_printf("%s:\n", fmri);
2860 		listnotify_print(nvl, NULL);
2861 	}
2862 	nvlist_free(nvl);
2863 }
2864 
2865 /*
2866  * print_notify_special()
2867  * prints notification parameters for FMA events and system wide SMF state
2868  * transitions parameters
2869  */
2870 static void
2871 print_notify_special()
2872 {
2873 	safe_printf("Notification parameters for FMA Events\n");
2874 	print_notify_fma();
2875 	print_notify_fmri(SCF_INSTANCE_GLOBAL);
2876 }
2877 
2878 /*
2879  * print_notify()
2880  * callback function to print notification parameters for SMF state transition
2881  * instances. It skips global and notify-params instances as they should be
2882  * printed by print_notify_special()
2883  */
2884 /* ARGSUSED */
2885 static int
2886 print_notify(void *unused, scf_walkinfo_t *wip)
2887 {
2888 	if (strcmp(SCF_INSTANCE_GLOBAL, wip->fmri) == 0 ||
2889 	    strcmp(SCF_NOTIFY_PARAMS_INST, wip->fmri) == 0)
2890 		return (0);
2891 
2892 	print_notify_fmri(wip->fmri);
2893 
2894 	return (0);
2895 }
2896 
2897 /*
2898  * Append a one-lined description of each process in inst's contract(s) and
2899  * return the augmented string.
2900  */
2901 static char *
2902 add_processes(scf_walkinfo_t *wip, char *line, scf_propertygroup_t *lpg)
2903 {
2904 	pid_t *pids = NULL;
2905 	uint_t i, n = 0;
2906 
2907 	if (lpg == NULL) {
2908 		if (instance_processes(wip->inst, wip->fmri, &pids, &n) != 0)
2909 			return (line);
2910 	} else {
2911 		/* Legacy services */
2912 		scf_iter_t *iter;
2913 
2914 		if ((iter = scf_iter_create(h)) == NULL)
2915 			scfdie();
2916 
2917 		(void) propvals_to_pids(lpg, scf_property_contract, &pids, &n,
2918 		    g_prop, g_val, iter);
2919 
2920 		scf_iter_destroy(iter);
2921 	}
2922 
2923 	if (n == 0)
2924 		return (line);
2925 
2926 	qsort(pids, n, sizeof (*pids), pidcmp);
2927 
2928 	for (i = 0; i < n; ++i) {
2929 		char *cp, stime[9];
2930 		psinfo_t psi;
2931 		struct tm *tm;
2932 		int len = 1 + 15 + 8 + 3 + 6 + 1 + PRFNSZ;
2933 
2934 		if (get_psinfo(pids[i], &psi) != 0)
2935 			continue;
2936 
2937 		line = realloc(line, strlen(line) + len);
2938 		if (line == NULL)
2939 			uu_die(gettext("Out of memory.\n"));
2940 
2941 		cp = strchr(line, '\0');
2942 
2943 		tm = localtime(&psi.pr_start.tv_sec);
2944 
2945 		/*
2946 		 * Print time if started within the past 24 hours, print date
2947 		 * if within the past 12 months, print year if started greater
2948 		 * than 12 months ago.
2949 		 */
2950 		if (now - psi.pr_start.tv_sec < 24 * 60 * 60)
2951 			(void) strftime(stime, sizeof (stime),
2952 			    gettext(FORMAT_TIME), tm);
2953 		else if (now - psi.pr_start.tv_sec < 12 * 30 * 24 * 60 * 60)
2954 			(void) strftime(stime, sizeof (stime),
2955 			    gettext(FORMAT_DATE), tm);
2956 		else
2957 			(void) strftime(stime, sizeof (stime),
2958 			    gettext(FORMAT_YEAR), tm);
2959 
2960 		(void) snprintf(cp, len, "\n               %-8s   %6ld %.*s",
2961 		    stime, pids[i], PRFNSZ, psi.pr_fname);
2962 	}
2963 
2964 	free(pids);
2965 
2966 	return (line);
2967 }
2968 
2969 /*ARGSUSED*/
2970 static int
2971 list_instance(void *unused, scf_walkinfo_t *wip)
2972 {
2973 	struct avl_string *lp;
2974 	char *cp;
2975 	int i;
2976 	uu_avl_index_t idx;
2977 
2978 	/*
2979 	 * If the user has specified a restarter, check for a match first
2980 	 */
2981 	if (restarters != NULL) {
2982 		struct pfmri_list *rest;
2983 		int match;
2984 		char *restarter_fmri;
2985 		const char *scope_name, *svc_name, *inst_name, *pg_name;
2986 
2987 		/* legacy services don't have restarters */
2988 		if (wip->pg != NULL)
2989 			return (0);
2990 
2991 		restarter_fmri = safe_malloc(max_scf_fmri_length + 1);
2992 
2993 		if (inst_get_single_val(wip->inst, SCF_PG_GENERAL,
2994 		    SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, restarter_fmri,
2995 		    max_scf_fmri_length + 1, 0, 0, 1) != 0)
2996 			(void) strcpy(restarter_fmri, SCF_SERVICE_STARTD);
2997 
2998 		if (scf_parse_svc_fmri(restarter_fmri, &scope_name, &svc_name,
2999 		    &inst_name, &pg_name, NULL) != SCF_SUCCESS) {
3000 			free(restarter_fmri);
3001 			return (0);
3002 		}
3003 
3004 		match = 0;
3005 		for (rest = restarters; rest != NULL; rest = rest->next) {
3006 			if (strcmp(rest->scope, scope_name) == 0 &&
3007 			    strcmp(rest->service, svc_name) == 0 &&
3008 			    strcmp(rest->instance, inst_name) == 0)
3009 				match = 1;
3010 		}
3011 
3012 		free(restarter_fmri);
3013 
3014 		if (!match)
3015 			return (0);
3016 	}
3017 
3018 	if (wip->pg == NULL && ht_buckets != NULL && ht_add(wip->fmri)) {
3019 		/* It was already there. */
3020 		return (0);
3021 	}
3022 
3023 	lp = safe_malloc(sizeof (*lp));
3024 
3025 	lp->str = NULL;
3026 	for (i = 0; i < opt_cnum; ++i) {
3027 		columns[opt_columns[i]].sprint(&lp->str, wip);
3028 	}
3029 	cp = lp->str + strlen(lp->str);
3030 	cp--;
3031 	while (*cp == ' ')
3032 		cp--;
3033 	*(cp+1) = '\0';
3034 
3035 	/* If we're supposed to list the processes, too, do that now. */
3036 	if (opt_processes)
3037 		lp->str = add_processes(wip, lp->str, wip->pg);
3038 
3039 	/* Create the sort key. */
3040 	cp = lp->key = safe_malloc(sortkey_sz);
3041 	for (i = 0; i < opt_snum; ++i) {
3042 		int j = opt_sort[i] & 0xff;
3043 
3044 		assert(columns[j].get_sortkey != NULL);
3045 		columns[j].get_sortkey(cp, opt_sort[i] & ~0xff, wip);
3046 		cp += columns[j].sortkey_width;
3047 	}
3048 
3049 	/* Insert into AVL tree. */
3050 	uu_avl_node_init(lp, &lp->node, lines_pool);
3051 	(void) uu_avl_find(lines, lp, NULL, &idx);
3052 	uu_avl_insert(lines, lp, idx);
3053 
3054 	return (0);
3055 }
3056 
3057 static int
3058 list_if_enabled(void *unused, scf_walkinfo_t *wip)
3059 {
3060 	if (wip->pg != NULL ||
3061 	    instance_enabled(wip->inst, B_FALSE) == 1 ||
3062 	    instance_enabled(wip->inst, B_TRUE) == 1)
3063 		return (list_instance(unused, wip));
3064 
3065 	return (0);
3066 }
3067 
3068 /*
3069  * Service FMRI selection: Lookup and call list_instance() for the instances.
3070  * Instance FMRI selection: Lookup and call list_instance().
3071  *
3072  * Note: This is shoehorned into a walk_dependencies() callback prototype so
3073  * it can be used in list_dependencies.
3074  */
3075 static int
3076 list_svc_or_inst_fmri(void *complain, scf_walkinfo_t *wip)
3077 {
3078 	char *fmri;
3079 	const char *svc_name, *inst_name, *pg_name, *save;
3080 	scf_iter_t *iter;
3081 	int ret;
3082 
3083 	fmri = safe_strdup(wip->fmri);
3084 
3085 	if (scf_parse_svc_fmri(fmri, NULL, &svc_name, &inst_name, &pg_name,
3086 	    NULL) != SCF_SUCCESS) {
3087 		if (complain)
3088 			uu_warn(gettext("FMRI \"%s\" is invalid.\n"),
3089 			    wip->fmri);
3090 		exit_status = UU_EXIT_FATAL;
3091 		free(fmri);
3092 		return (0);
3093 	}
3094 
3095 	/*
3096 	 * Yes, this invalidates *_name, but we only care whether they're NULL
3097 	 * or not.
3098 	 */
3099 	free(fmri);
3100 
3101 	if (svc_name == NULL || pg_name != NULL) {
3102 		if (complain)
3103 			uu_warn(gettext("FMRI \"%s\" does not designate a "
3104 			    "service or instance.\n"), wip->fmri);
3105 		return (0);
3106 	}
3107 
3108 	if (inst_name != NULL) {
3109 		/* instance */
3110 		if (scf_handle_decode_fmri(h, wip->fmri, wip->scope, wip->svc,
3111 		    wip->inst, NULL, NULL, 0) != SCF_SUCCESS) {
3112 			if (scf_error() != SCF_ERROR_NOT_FOUND)
3113 				scfdie();
3114 
3115 			if (complain)
3116 				uu_warn(gettext(
3117 				    "Instance \"%s\" does not exist.\n"),
3118 				    wip->fmri);
3119 			return (0);
3120 		}
3121 
3122 		return (list_instance(NULL, wip));
3123 	}
3124 
3125 	/* service: Walk the instances. */
3126 	if (scf_handle_decode_fmri(h, wip->fmri, wip->scope, wip->svc, NULL,
3127 	    NULL, NULL, 0) != SCF_SUCCESS) {
3128 		if (scf_error() != SCF_ERROR_NOT_FOUND)
3129 			scfdie();
3130 
3131 		if (complain)
3132 			uu_warn(gettext("Service \"%s\" does not exist.\n"),
3133 			    wip->fmri);
3134 
3135 		exit_status = UU_EXIT_FATAL;
3136 
3137 		return (0);
3138 	}
3139 
3140 	iter = scf_iter_create(h);
3141 	if (iter == NULL)
3142 		scfdie();
3143 
3144 	if (scf_iter_service_instances(iter, wip->svc) != SCF_SUCCESS)
3145 		scfdie();
3146 
3147 	if ((fmri = malloc(max_scf_fmri_length + 1)) == NULL) {
3148 		scf_iter_destroy(iter);
3149 		exit_status = UU_EXIT_FATAL;
3150 		return (0);
3151 	}
3152 
3153 	save = wip->fmri;
3154 	wip->fmri = fmri;
3155 	while ((ret = scf_iter_next_instance(iter, wip->inst)) == 1) {
3156 		if (scf_instance_to_fmri(wip->inst, fmri,
3157 		    max_scf_fmri_length + 1) <= 0)
3158 			scfdie();
3159 		(void) list_instance(NULL, wip);
3160 	}
3161 	free(fmri);
3162 	wip->fmri = save;
3163 	if (ret == -1)
3164 		scfdie();
3165 
3166 	exit_status = UU_EXIT_OK;
3167 
3168 	scf_iter_destroy(iter);
3169 
3170 	return (0);
3171 }
3172 
3173 /*
3174  * Dependency selection: Straightforward since each instance lists the
3175  * services it depends on.
3176  */
3177 
3178 static void
3179 walk_dependencies(scf_walkinfo_t *wip, scf_walk_callback callback, void *data)
3180 {
3181 	scf_snapshot_t *snap;
3182 	scf_iter_t *iter, *viter;
3183 	int ret, vret;
3184 	char *dep;
3185 
3186 	assert(wip->inst != NULL);
3187 
3188 	if ((iter = scf_iter_create(h)) == NULL ||
3189 	    (viter = scf_iter_create(h)) == NULL)
3190 		scfdie();
3191 
3192 	snap = get_running_snapshot(wip->inst);
3193 
3194 	if (scf_iter_instance_pgs_typed_composed(iter, wip->inst, snap,
3195 	    SCF_GROUP_DEPENDENCY) != SCF_SUCCESS)
3196 		scfdie();
3197 
3198 	dep = safe_malloc(max_scf_value_length + 1);
3199 
3200 	while ((ret = scf_iter_next_pg(iter, g_pg)) == 1) {
3201 		scf_type_t ty;
3202 
3203 		/* Ignore exclude_any dependencies. */
3204 		if (scf_pg_get_property(g_pg, SCF_PROPERTY_GROUPING, g_prop) !=
3205 		    SCF_SUCCESS) {
3206 			if (scf_error() != SCF_ERROR_NOT_FOUND)
3207 				scfdie();
3208 
3209 			continue;
3210 		}
3211 
3212 		if (scf_property_type(g_prop, &ty) != SCF_SUCCESS)
3213 			scfdie();
3214 
3215 		if (ty != SCF_TYPE_ASTRING)
3216 			continue;
3217 
3218 		if (scf_property_get_value(g_prop, g_val) != SCF_SUCCESS) {
3219 			if (scf_error() != SCF_ERROR_CONSTRAINT_VIOLATED)
3220 				scfdie();
3221 
3222 			continue;
3223 		}
3224 
3225 		if (scf_value_get_astring(g_val, dep,
3226 		    max_scf_value_length + 1) < 0)
3227 			scfdie();
3228 
3229 		if (strcmp(dep, SCF_DEP_EXCLUDE_ALL) == 0)
3230 			continue;
3231 
3232 		if (scf_pg_get_property(g_pg, SCF_PROPERTY_ENTITIES, g_prop) !=
3233 		    SCF_SUCCESS) {
3234 			if (scf_error() != SCF_ERROR_NOT_FOUND)
3235 				scfdie();
3236 
3237 			continue;
3238 		}
3239 
3240 		if (scf_iter_property_values(viter, g_prop) != SCF_SUCCESS)
3241 			scfdie();
3242 
3243 		while ((vret = scf_iter_next_value(viter, g_val)) == 1) {
3244 			if (scf_value_get_astring(g_val, dep,
3245 			    max_scf_value_length + 1) < 0)
3246 				scfdie();
3247 
3248 			wip->fmri = dep;
3249 			if (callback(data, wip) != 0)
3250 				goto out;
3251 		}
3252 		if (vret == -1)
3253 			scfdie();
3254 	}
3255 	if (ret == -1)
3256 		scfdie();
3257 
3258 out:
3259 	scf_iter_destroy(viter);
3260 	scf_iter_destroy(iter);
3261 	scf_snapshot_destroy(snap);
3262 }
3263 
3264 static int
3265 list_dependencies(void *data, scf_walkinfo_t *wip)
3266 {
3267 	walk_dependencies(wip, list_svc_or_inst_fmri, data);
3268 	return (0);
3269 }
3270 
3271 
3272 /*
3273  * Dependent selection: The "providing" service's or instance's FMRI is parsed
3274  * into the provider_* variables, the instances are walked, and any instance
3275  * which lists an FMRI which parses to these components is selected.  This is
3276  * inefficient in the face of multiple operands, but that should be uncommon.
3277  */
3278 
3279 static char *provider_scope;
3280 static char *provider_svc;
3281 static char *provider_inst;	/* NULL for services */
3282 
3283 /*ARGSUSED*/
3284 static int
3285 check_against_provider(void *arg, scf_walkinfo_t *wip)
3286 {
3287 	char *cfmri;
3288 	const char *scope_name, *svc_name, *inst_name, *pg_name;
3289 	int *matchp = arg;
3290 
3291 	cfmri = safe_strdup(wip->fmri);
3292 
3293 	if (scf_parse_svc_fmri(cfmri, &scope_name, &svc_name, &inst_name,
3294 	    &pg_name, NULL) != SCF_SUCCESS) {
3295 		free(cfmri);
3296 		return (0);
3297 	}
3298 
3299 	if (svc_name == NULL || pg_name != NULL) {
3300 		free(cfmri);
3301 		return (0);
3302 	}
3303 
3304 	/*
3305 	 * If the user has specified an instance, then also match dependencies
3306 	 * on the service itself.
3307 	 */
3308 	*matchp = (strcmp(provider_scope, scope_name) == 0 &&
3309 	    strcmp(provider_svc, svc_name) == 0 &&
3310 	    (provider_inst == NULL ? (inst_name == NULL) :
3311 	    (inst_name == NULL || strcmp(provider_inst, inst_name) == 0)));
3312 
3313 	free(cfmri);
3314 
3315 	/* Stop on matches. */
3316 	return (*matchp);
3317 }
3318 
3319 static int
3320 list_if_dependent(void *unused, scf_walkinfo_t *wip)
3321 {
3322 	/* Only proceed if this instance depends on provider_*. */
3323 	int match = 0;
3324 
3325 	(void) walk_dependencies(wip, check_against_provider, &match);
3326 
3327 	if (match)
3328 		return (list_instance(unused, wip));
3329 
3330 	return (0);
3331 }
3332 
3333 /*ARGSUSED*/
3334 static int
3335 list_dependents(void *unused, scf_walkinfo_t *wip)
3336 {
3337 	char *save;
3338 	int ret;
3339 
3340 	if (scf_scope_get_name(wip->scope, provider_scope,
3341 	    max_scf_fmri_length) <= 0 ||
3342 	    scf_service_get_name(wip->svc, provider_svc,
3343 	    max_scf_fmri_length) <= 0)
3344 		scfdie();
3345 
3346 	save = provider_inst;
3347 	if (wip->inst == NULL)
3348 		provider_inst = NULL;
3349 	else if (scf_instance_get_name(wip->inst, provider_inst,
3350 	    max_scf_fmri_length) <= 0)
3351 		scfdie();
3352 
3353 	ret = scf_walk_fmri(h, 0, NULL, 0, list_if_dependent, NULL, NULL,
3354 	    uu_warn);
3355 
3356 	provider_inst = save;
3357 
3358 	return (ret);
3359 }
3360 
3361 /*
3362  * main() & helpers
3363  */
3364 
3365 static void
3366 add_sort_column(const char *col, int reverse)
3367 {
3368 	int i;
3369 
3370 	++opt_snum;
3371 
3372 	opt_sort = realloc(opt_sort, opt_snum * sizeof (*opt_sort));
3373 	if (opt_sort == NULL)
3374 		uu_die(gettext("Too many sort criteria: out of memory.\n"));
3375 
3376 	for (i = 0; i < ncolumns; ++i) {
3377 		if (strcasecmp(col, columns[i].name) == 0)
3378 			break;
3379 	}
3380 
3381 	if (i < ncolumns)
3382 		opt_sort[opt_snum - 1] = (reverse ? i | 0x100 : i);
3383 	else
3384 		uu_die(gettext("Unrecognized sort column \"%s\".\n"), col);
3385 
3386 	sortkey_sz += columns[i].sortkey_width;
3387 }
3388 
3389 static void
3390 add_restarter(const char *fmri)
3391 {
3392 	char *cfmri;
3393 	const char *pg_name;
3394 	struct pfmri_list *rest;
3395 
3396 	cfmri = safe_strdup(fmri);
3397 	rest = safe_malloc(sizeof (*rest));
3398 
3399 	if (scf_parse_svc_fmri(cfmri, &rest->scope, &rest->service,
3400 	    &rest->instance, &pg_name, NULL) != SCF_SUCCESS)
3401 		uu_die(gettext("Restarter FMRI \"%s\" is invalid.\n"), fmri);
3402 
3403 	if (rest->instance == NULL || pg_name != NULL)
3404 		uu_die(gettext("Restarter FMRI \"%s\" does not designate an "
3405 		    "instance.\n"), fmri);
3406 
3407 	rest->next = restarters;
3408 	restarters = rest;
3409 	return;
3410 
3411 err:
3412 	free(cfmri);
3413 	free(rest);
3414 }
3415 
3416 /* ARGSUSED */
3417 static int
3418 line_cmp(const void *l_arg, const void *r_arg, void *private)
3419 {
3420 	const struct avl_string *l = l_arg;
3421 	const struct avl_string *r = r_arg;
3422 
3423 	return (memcmp(l->key, r->key, sortkey_sz));
3424 }
3425 
3426 /* ARGSUSED */
3427 static int
3428 print_line(void *e, void *private)
3429 {
3430 	struct avl_string *lp = e;
3431 
3432 	(void) puts(lp->str);
3433 
3434 	return (UU_WALK_NEXT);
3435 }
3436 
3437 /* ARGSUSED */
3438 static void
3439 errignore(const char *str, ...)
3440 {}
3441 
3442 int
3443 main(int argc, char **argv)
3444 {
3445 	char opt, opt_mode;
3446 	int i, n;
3447 	char *columns_str = NULL;
3448 	char *cp;
3449 	const char *progname;
3450 	int err, missing = 1, ignored, *errarg;
3451 	uint_t nzents = 0, zent = 0;
3452 	zoneid_t *zids = NULL;
3453 	char zonename[ZONENAME_MAX];
3454 	void (*errfunc)(const char *, ...);
3455 
3456 	int show_all = 0;
3457 	int show_header = 1;
3458 	int show_zones = 0;
3459 
3460 	const char * const options = "aHpvno:R:s:S:dDlL?xZz:";
3461 
3462 	(void) setlocale(LC_ALL, "");
3463 
3464 	locale = setlocale(LC_MESSAGES, NULL);
3465 	if (locale) {
3466 		locale = safe_strdup(locale);
3467 		_scf_sanitize_locale(locale);
3468 	}
3469 
3470 	(void) textdomain(TEXT_DOMAIN);
3471 	progname = uu_setpname(argv[0]);
3472 
3473 	exit_status = UU_EXIT_OK;
3474 
3475 	max_scf_name_length = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
3476 	max_scf_value_length = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH);
3477 	max_scf_fmri_length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
3478 	max_scf_type_length = scf_limit(SCF_LIMIT_MAX_PG_TYPE_LENGTH);
3479 
3480 	if (max_scf_name_length == -1 || max_scf_value_length == -1 ||
3481 	    max_scf_fmri_length == -1 || max_scf_type_length == -1)
3482 		scfdie();
3483 
3484 	now = time(NULL);
3485 	assert(now != -1);
3486 
3487 	/*
3488 	 * opt_mode is the mode of operation.  0 for plain, 'd' for
3489 	 * dependencies, 'D' for dependents, and 'l' for detailed (long).  We
3490 	 * need to know now so we know which options are valid.
3491 	 */
3492 	opt_mode = 0;
3493 	while ((opt = getopt(argc, argv, options)) != -1) {
3494 		switch (opt) {
3495 		case '?':
3496 			if (optopt == '?') {
3497 				print_help(progname);
3498 				return (UU_EXIT_OK);
3499 			} else {
3500 				argserr(progname);
3501 				/* NOTREACHED */
3502 			}
3503 
3504 		case 'd':
3505 		case 'D':
3506 		case 'l':
3507 		case 'L':
3508 			if (opt_mode != 0)
3509 				argserr(progname);
3510 
3511 			opt_mode = opt;
3512 			break;
3513 
3514 		case 'n':
3515 			if (opt_mode != 0)
3516 				argserr(progname);
3517 
3518 			opt_mode = opt;
3519 			break;
3520 
3521 		case 'x':
3522 			if (opt_mode != 0)
3523 				argserr(progname);
3524 
3525 			opt_mode = opt;
3526 			break;
3527 
3528 		default:
3529 			break;
3530 		}
3531 	}
3532 
3533 	sortkey_sz = 0;
3534 
3535 	optind = 1;	/* Reset getopt() */
3536 	while ((opt = getopt(argc, argv, options)) != -1) {
3537 		switch (opt) {
3538 		case 'a':
3539 			if (opt_mode != 0)
3540 				argserr(progname);
3541 			show_all = 1;
3542 			break;
3543 
3544 		case 'H':
3545 			if (opt_mode == 'l' || opt_mode == 'x')
3546 				argserr(progname);
3547 			show_header = 0;
3548 			break;
3549 
3550 		case 'p':
3551 			if (opt_mode == 'x')
3552 				argserr(progname);
3553 			opt_processes = 1;
3554 			break;
3555 
3556 		case 'v':
3557 			opt_verbose = 1;
3558 			break;
3559 
3560 		case 'o':
3561 			if (opt_mode == 'l' || opt_mode == 'x')
3562 				argserr(progname);
3563 			columns_str = optarg;
3564 			break;
3565 
3566 		case 'R':
3567 			if (opt_mode != 0 || opt_mode == 'x')
3568 				argserr(progname);
3569 
3570 			add_restarter(optarg);
3571 			break;
3572 
3573 		case 's':
3574 		case 'S':
3575 			if (opt_mode != 0)
3576 				argserr(progname);
3577 
3578 			add_sort_column(optarg, optopt == 'S');
3579 			break;
3580 
3581 		case 'd':
3582 		case 'D':
3583 		case 'l':
3584 		case 'L':
3585 		case 'n':
3586 		case 'x':
3587 			assert(opt_mode == optopt);
3588 			break;
3589 
3590 		case 'z':
3591 			if (getzoneid() != GLOBAL_ZONEID)
3592 				uu_die(gettext("svcs -z may only be used from "
3593 				    "the global zone\n"));
3594 			if (show_zones)
3595 				argserr(progname);
3596 
3597 			opt_zone = optarg;
3598 			break;
3599 
3600 		case 'Z':
3601 			if (getzoneid() != GLOBAL_ZONEID)
3602 				uu_die(gettext("svcs -Z may only be used from "
3603 				    "the global zone\n"));
3604 			if (opt_zone != NULL)
3605 				argserr(progname);
3606 
3607 			show_zones = 1;
3608 			break;
3609 
3610 		case '?':
3611 			argserr(progname);
3612 			/* NOTREACHED */
3613 
3614 		default:
3615 			assert(0);
3616 			abort();
3617 		}
3618 	}
3619 
3620 	/*
3621 	 * -a is only meaningful when given no arguments
3622 	 */
3623 	if (show_all && optind != argc)
3624 		uu_warn(gettext("-a ignored when used with arguments.\n"));
3625 
3626 	while (show_zones) {
3627 		uint_t found;
3628 
3629 		if (zone_list(NULL, &nzents) != 0)
3630 			uu_die(gettext("could not get number of zones"));
3631 
3632 		if ((zids = malloc(nzents * sizeof (zoneid_t))) == NULL) {
3633 			uu_die(gettext("could not allocate array for "
3634 			    "%d zone IDs"), nzents);
3635 		}
3636 
3637 		found = nzents;
3638 
3639 		if (zone_list(zids, &found) != 0)
3640 			uu_die(gettext("could not get zone list"));
3641 
3642 		/*
3643 		 * If the number of zones has not changed between our calls to
3644 		 * zone_list(), we're done -- otherwise, we must free our array
3645 		 * of zone IDs and take another lap.
3646 		 */
3647 		if (found == nzents)
3648 			break;
3649 
3650 		free(zids);
3651 	}
3652 
3653 	argc -= optind;
3654 	argv += optind;
3655 
3656 again:
3657 	h = scf_handle_create(SCF_VERSION);
3658 	if (h == NULL)
3659 		scfdie();
3660 
3661 	if (opt_zone != NULL || zids != NULL) {
3662 		scf_value_t *zone;
3663 
3664 		assert(opt_zone == NULL || zids == NULL);
3665 
3666 		if (opt_zone == NULL) {
3667 			if (getzonenamebyid(zids[zent++],
3668 			    zonename, sizeof (zonename)) < 0) {
3669 				uu_warn(gettext("could not get name for "
3670 				    "zone %d; ignoring"), zids[zent - 1]);
3671 				goto nextzone;
3672 			}
3673 
3674 			g_zonename = zonename;
3675 		} else {
3676 			g_zonename = opt_zone;
3677 		}
3678 
3679 		if ((zone = scf_value_create(h)) == NULL)
3680 			scfdie();
3681 
3682 		if (scf_value_set_astring(zone, g_zonename) != SCF_SUCCESS)
3683 			scfdie();
3684 
3685 		if (scf_handle_decorate(h, "zone", zone) != SCF_SUCCESS)
3686 			uu_die(gettext("invalid zone '%s'\n"), g_zonename);
3687 
3688 		scf_value_destroy(zone);
3689 	}
3690 
3691 	if (scf_handle_bind(h) == -1) {
3692 		if (g_zonename != NULL) {
3693 			uu_warn(gettext("Could not bind to repository "
3694 			    "server for zone %s: %s\n"), g_zonename,
3695 			    scf_strerror(scf_error()));
3696 
3697 			if (!show_zones)
3698 				return (UU_EXIT_FATAL);
3699 
3700 			goto nextzone;
3701 		}
3702 
3703 		uu_die(gettext("Could not bind to repository server: %s.  "
3704 		    "Exiting.\n"), scf_strerror(scf_error()));
3705 	}
3706 
3707 	if ((g_pg = scf_pg_create(h)) == NULL ||
3708 	    (g_prop = scf_property_create(h)) == NULL ||
3709 	    (g_val = scf_value_create(h)) == NULL)
3710 		scfdie();
3711 
3712 	if (show_zones) {
3713 		/*
3714 		 * It's hard to avoid editorializing here, but suffice it to
3715 		 * say that scf_walk_fmri() takes an error handler, the
3716 		 * interface to which has been regrettably misdesigned:  the
3717 		 * handler itself takes exclusively a string -- even though
3718 		 * scf_walk_fmri() has detailed, programmatic knowledge
3719 		 * of the error condition at the time it calls its errfunc.
3720 		 * That is, only the error message and not the error semantics
3721 		 * are given to the handler.  This is poor interface at best,
3722 		 * but it is particularly problematic when we are talking to
3723 		 * multiple repository servers (as when we are iterating over
3724 		 * all zones) as we do not want to treat failure to find a
3725 		 * match in one zone as overall failure.  Ideally, we would
3726 		 * simply ignore SCF_MSG_PATTERN_NOINSTANCE and correctly
3727 		 * process the others, but alas, no such interface exists --
3728 		 * and we must settle for instead ignoring all errfunc-called
3729 		 * errors in the case that we are iterating over all zones...
3730 		 */
3731 		errfunc = errignore;
3732 		errarg = missing ? &missing : &ignored;
3733 		missing = 0;
3734 	} else {
3735 		errfunc = uu_warn;
3736 		errarg = &exit_status;
3737 	}
3738 
3739 	/*
3740 	 * If we're in long mode, take care of it now before we deal with the
3741 	 * sorting and the columns, since we won't use them anyway.
3742 	 */
3743 	if (opt_mode == 'l') {
3744 		if (argc == 0)
3745 			argserr(progname);
3746 
3747 		if ((err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE,
3748 		    print_detailed, NULL, errarg, errfunc)) != 0) {
3749 			uu_warn(gettext("failed to iterate over "
3750 			    "instances: %s\n"), scf_strerror(err));
3751 			exit_status = UU_EXIT_FATAL;
3752 		}
3753 
3754 		goto nextzone;
3755 	}
3756 
3757 	if (opt_mode == 'L') {
3758 		if ((err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE,
3759 		    print_log, NULL, &exit_status, uu_warn)) != 0) {
3760 			uu_warn(gettext("failed to iterate over "
3761 			    "instances: %s\n"), scf_strerror(err));
3762 			exit_status = UU_EXIT_FATAL;
3763 		}
3764 
3765 		goto nextzone;
3766 	}
3767 
3768 	if (opt_mode == 'n') {
3769 		print_notify_special();
3770 		if ((err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE,
3771 		    print_notify, NULL, errarg, errfunc)) != 0) {
3772 			uu_warn(gettext("failed to iterate over "
3773 			    "instances: %s\n"), scf_strerror(err));
3774 			exit_status = UU_EXIT_FATAL;
3775 		}
3776 
3777 		goto nextzone;
3778 	}
3779 
3780 	if (opt_mode == 'x') {
3781 		explain(opt_verbose, argc, argv);
3782 		goto nextzone;
3783 	}
3784 
3785 	if (columns_str == NULL) {
3786 		if (opt_snum == 0) {
3787 			if (show_zones)
3788 				add_sort_column("zone", 0);
3789 
3790 			/* Default sort. */
3791 			add_sort_column("state", 0);
3792 			add_sort_column("stime", 0);
3793 			add_sort_column("fmri", 0);
3794 		}
3795 
3796 		if (!opt_verbose) {
3797 			columns_str = safe_strdup(show_zones ?
3798 			    "zone,state,stime,fmri" : "state,stime,fmri");
3799 		} else {
3800 			columns_str = safe_strdup(show_zones ?
3801 			    "zone,state,nstate,stime,ctid,fmri" :
3802 			    "state,nstate,stime,ctid,fmri");
3803 		}
3804 	}
3805 
3806 	if (opt_columns == NULL) {
3807 		/* Decode columns_str into opt_columns. */
3808 		line_sz = 0;
3809 
3810 		opt_cnum = 1;
3811 		for (cp = columns_str; *cp != '\0'; ++cp)
3812 			if (*cp == ',')
3813 				++opt_cnum;
3814 
3815 		if (*columns_str == '\0')
3816 			uu_die(gettext("No columns specified.\n"));
3817 
3818 		opt_columns = malloc(opt_cnum * sizeof (*opt_columns));
3819 		if (opt_columns == NULL)
3820 			uu_die(gettext("Too many columns.\n"));
3821 
3822 		for (n = 0; *columns_str != '\0'; ++n) {
3823 			i = getcolumnopt(&columns_str);
3824 			if (i == -1)
3825 				uu_die(gettext("Unknown column \"%s\".\n"),
3826 				    columns_str);
3827 
3828 			if (strcmp(columns[i].name, "N") == 0 ||
3829 			    strcmp(columns[i].name, "SN") == 0 ||
3830 			    strcmp(columns[i].name, "NSTA") == 0 ||
3831 			    strcmp(columns[i].name, "NSTATE") == 0)
3832 				opt_nstate_shown = 1;
3833 
3834 			opt_columns[n] = i;
3835 			line_sz += columns[i].width + 1;
3836 		}
3837 
3838 		if ((lines_pool = uu_avl_pool_create("lines_pool",
3839 		    sizeof (struct avl_string), offsetof(struct avl_string,
3840 		    node), line_cmp, UU_AVL_DEBUG)) == NULL ||
3841 		    (lines = uu_avl_create(lines_pool, NULL, 0)) == NULL)
3842 			uu_die(gettext("Unexpected libuutil error: %s\n"),
3843 			    uu_strerror(uu_error()));
3844 	}
3845 
3846 	switch (opt_mode) {
3847 	case 0:
3848 		/*
3849 		 * If we already have a hash table (e.g., because we are
3850 		 * processing multiple zones), destroy it before creating
3851 		 * a new one.
3852 		 */
3853 		if (ht_buckets != NULL)
3854 			ht_free();
3855 
3856 		ht_init();
3857 
3858 		/* Always show all FMRIs when given arguments or restarters */
3859 		if (argc != 0 || restarters != NULL)
3860 			show_all =  1;
3861 
3862 		if ((err = scf_walk_fmri(h, argc, argv,
3863 		    SCF_WALK_MULTIPLE | SCF_WALK_LEGACY,
3864 		    show_all ? list_instance : list_if_enabled, NULL,
3865 		    errarg, errfunc)) != 0) {
3866 			uu_warn(gettext("failed to iterate over "
3867 			    "instances: %s\n"), scf_strerror(err));
3868 			exit_status = UU_EXIT_FATAL;
3869 		}
3870 		break;
3871 
3872 	case 'd':
3873 		if (argc == 0)
3874 			argserr(progname);
3875 
3876 		if ((err = scf_walk_fmri(h, argc, argv,
3877 		    SCF_WALK_MULTIPLE, list_dependencies, NULL,
3878 		    errarg, errfunc)) != 0) {
3879 			uu_warn(gettext("failed to iterate over "
3880 			    "instances: %s\n"), scf_strerror(err));
3881 			exit_status = UU_EXIT_FATAL;
3882 		}
3883 		break;
3884 
3885 	case 'D':
3886 		if (argc == 0)
3887 			argserr(progname);
3888 
3889 		provider_scope = safe_malloc(max_scf_fmri_length);
3890 		provider_svc = safe_malloc(max_scf_fmri_length);
3891 		provider_inst = safe_malloc(max_scf_fmri_length);
3892 
3893 		if ((err = scf_walk_fmri(h, argc, argv,
3894 		    SCF_WALK_MULTIPLE | SCF_WALK_SERVICE,
3895 		    list_dependents, NULL, &exit_status, uu_warn)) != 0) {
3896 			uu_warn(gettext("failed to iterate over "
3897 			    "instances: %s\n"), scf_strerror(err));
3898 			exit_status = UU_EXIT_FATAL;
3899 		}
3900 
3901 		free(provider_scope);
3902 		free(provider_svc);
3903 		free(provider_inst);
3904 		break;
3905 
3906 	case 'n':
3907 		break;
3908 
3909 	default:
3910 		assert(0);
3911 		abort();
3912 	}
3913 
3914 nextzone:
3915 	if (show_zones && zent < nzents && exit_status == 0) {
3916 		scf_handle_destroy(h);
3917 		goto again;
3918 	}
3919 
3920 	if (show_zones && exit_status == 0)
3921 		exit_status = missing;
3922 
3923 	if (opt_columns == NULL)
3924 		return (exit_status);
3925 
3926 	if (show_header)
3927 		print_header();
3928 
3929 	(void) uu_avl_walk(lines, print_line, NULL, 0);
3930 
3931 	return (exit_status);
3932 }
3933