17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 594501b61Sskamm * Common Development and Distribution License (the "License"). 694501b61Sskamm * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 203eae19d9Swesolows */ 213eae19d9Swesolows 223eae19d9Swesolows /* 237b209c2cSacruz * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate 277c478bd9Sstevel@tonic-gate /* 287c478bd9Sstevel@tonic-gate * svcs - display attributes of service instances 297c478bd9Sstevel@tonic-gate * 307c478bd9Sstevel@tonic-gate * We have two output formats and six instance selection mechanisms. The 317c478bd9Sstevel@tonic-gate * primary output format is a line of attributes (selected by -o), possibly 327c478bd9Sstevel@tonic-gate * followed by process description lines (if -p is specified), for each 337c478bd9Sstevel@tonic-gate * instance selected. The columns available to display are described by the 347c478bd9Sstevel@tonic-gate * struct column columns array. The columns to actually display are kept in 357c478bd9Sstevel@tonic-gate * the opt_columns array as indicies into the columns array. The selection 367c478bd9Sstevel@tonic-gate * mechanisms available for this format are service FMRIs (selects all child 377c478bd9Sstevel@tonic-gate * instances), instance FMRIs, instance FMRI glob patterns, instances with 387c478bd9Sstevel@tonic-gate * a certain restarter (-R), dependencies of instances (-d), and dependents of 397c478bd9Sstevel@tonic-gate * instances (-D). Since the lines must be sorted (per -sS), we'll just stick 407c478bd9Sstevel@tonic-gate * each into a data structure and print them in order when we're done. To 417c478bd9Sstevel@tonic-gate * avoid listing the same instance twice (when -d and -D aren't given), we'll 427c478bd9Sstevel@tonic-gate * use a hash table of FMRIs to record that we've listed (added to the tree) 437c478bd9Sstevel@tonic-gate * an instance. 447c478bd9Sstevel@tonic-gate * 457c478bd9Sstevel@tonic-gate * The secondary output format (-l "long") is a paragraph of text for the 467c478bd9Sstevel@tonic-gate * services or instances selected. Not needing to be sorted, it's implemented 477c478bd9Sstevel@tonic-gate * by just calling print_detailed() for each FMRI given. 487c478bd9Sstevel@tonic-gate */ 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate #include "svcs.h" 517c478bd9Sstevel@tonic-gate 527c478bd9Sstevel@tonic-gate /* Get the byteorder macros to ease sorting. */ 537c478bd9Sstevel@tonic-gate #include <sys/types.h> 547c478bd9Sstevel@tonic-gate #include <netinet/in.h> 557c478bd9Sstevel@tonic-gate #include <inttypes.h> 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate #include <sys/contract.h> 587c478bd9Sstevel@tonic-gate #include <sys/ctfs.h> 597c478bd9Sstevel@tonic-gate #include <sys/stat.h> 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate #include <assert.h> 627c478bd9Sstevel@tonic-gate #include <errno.h> 637c478bd9Sstevel@tonic-gate #include <fcntl.h> 647c478bd9Sstevel@tonic-gate #include <fnmatch.h> 657c478bd9Sstevel@tonic-gate #include <libcontract.h> 667c478bd9Sstevel@tonic-gate #include <libcontract_priv.h> 677c478bd9Sstevel@tonic-gate #include <libintl.h> 687c478bd9Sstevel@tonic-gate #include <libscf.h> 697c478bd9Sstevel@tonic-gate #include <libscf_priv.h> 707c478bd9Sstevel@tonic-gate #include <libuutil.h> 717c478bd9Sstevel@tonic-gate #include <locale.h> 727c478bd9Sstevel@tonic-gate #include <procfs.h> 737c478bd9Sstevel@tonic-gate #include <stdarg.h> 747c478bd9Sstevel@tonic-gate #include <stdio.h> 757c478bd9Sstevel@tonic-gate #include <stdlib.h> 767c478bd9Sstevel@tonic-gate #include <strings.h> 777c478bd9Sstevel@tonic-gate #include <time.h> 787c478bd9Sstevel@tonic-gate 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate #ifndef TEXT_DOMAIN 817c478bd9Sstevel@tonic-gate #define TEXT_DOMAIN "SUNW_OST_OSCMD" 827c478bd9Sstevel@tonic-gate #endif /* TEXT_DOMAIN */ 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate #define LEGACY_UNKNOWN "unknown" 857c478bd9Sstevel@tonic-gate 867c478bd9Sstevel@tonic-gate /* Flags for pg_get_single_val() */ 877c478bd9Sstevel@tonic-gate #define EMPTY_OK 0x01 887c478bd9Sstevel@tonic-gate #define MULTI_OK 0x02 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate /* 927c478bd9Sstevel@tonic-gate * An AVL-storable node for output lines and the keys to sort them by. 937c478bd9Sstevel@tonic-gate */ 947c478bd9Sstevel@tonic-gate struct avl_string { 957c478bd9Sstevel@tonic-gate uu_avl_node_t node; 967c478bd9Sstevel@tonic-gate char *key; 977c478bd9Sstevel@tonic-gate char *str; 987c478bd9Sstevel@tonic-gate }; 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate /* 1017c478bd9Sstevel@tonic-gate * For lists of parsed restarter FMRIs. 1027c478bd9Sstevel@tonic-gate */ 1037c478bd9Sstevel@tonic-gate struct pfmri_list { 1047c478bd9Sstevel@tonic-gate const char *scope; 1057c478bd9Sstevel@tonic-gate const char *service; 1067c478bd9Sstevel@tonic-gate const char *instance; 1077c478bd9Sstevel@tonic-gate struct pfmri_list *next; 1087c478bd9Sstevel@tonic-gate }; 1097c478bd9Sstevel@tonic-gate 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate /* 1127c478bd9Sstevel@tonic-gate * Globals 1137c478bd9Sstevel@tonic-gate */ 1147c478bd9Sstevel@tonic-gate scf_handle_t *h; 1157c478bd9Sstevel@tonic-gate static scf_propertygroup_t *g_pg; 1167c478bd9Sstevel@tonic-gate static scf_property_t *g_prop; 1177c478bd9Sstevel@tonic-gate static scf_value_t *g_val; 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate static size_t line_sz; /* Bytes in the header line. */ 1207c478bd9Sstevel@tonic-gate static size_t sortkey_sz; /* Bytes in sort keys. */ 1217c478bd9Sstevel@tonic-gate static uu_avl_pool_t *lines_pool; 1227c478bd9Sstevel@tonic-gate static uu_avl_t *lines; /* Output lines. */ 1237c478bd9Sstevel@tonic-gate int exit_status; 1247c478bd9Sstevel@tonic-gate ssize_t max_scf_name_length; 1257c478bd9Sstevel@tonic-gate ssize_t max_scf_value_length; 1267c478bd9Sstevel@tonic-gate ssize_t max_scf_fmri_length; 127*1f6eb021SLiane Praza static ssize_t max_scf_type_length; 1287c478bd9Sstevel@tonic-gate static time_t now; 1297c478bd9Sstevel@tonic-gate static struct pfmri_list *restarters = NULL; 1307c478bd9Sstevel@tonic-gate static int first_paragraph = 1; /* For -l mode. */ 1317c478bd9Sstevel@tonic-gate static char *common_name_buf; /* Sized for maximal length value. */ 1327c478bd9Sstevel@tonic-gate char *locale; /* Current locale. */ 1337c478bd9Sstevel@tonic-gate 13494501b61Sskamm /* 13594501b61Sskamm * Pathname storage for path generated from the fmri. 13694501b61Sskamm * Used for reading the ctid and (start) pid files for an inetd service. 13794501b61Sskamm */ 13894501b61Sskamm static char genfmri_filename[MAXPATHLEN] = ""; 13994501b61Sskamm 1407c478bd9Sstevel@tonic-gate /* Options */ 1417c478bd9Sstevel@tonic-gate static int *opt_columns = NULL; /* Indices into columns to display. */ 1427c478bd9Sstevel@tonic-gate static int opt_cnum = 0; 1437c478bd9Sstevel@tonic-gate static int opt_processes = 0; /* Print processes? */ 1447c478bd9Sstevel@tonic-gate static int *opt_sort = NULL; /* Indices into columns to sort. */ 1457c478bd9Sstevel@tonic-gate static int opt_snum = 0; 1467c478bd9Sstevel@tonic-gate static int opt_nstate_shown = 0; /* Will nstate be shown? */ 1477c478bd9Sstevel@tonic-gate static int opt_verbose = 0; 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate /* Minimize string constants. */ 1507c478bd9Sstevel@tonic-gate static const char * const scf_property_state = SCF_PROPERTY_STATE; 1517c478bd9Sstevel@tonic-gate static const char * const scf_property_next_state = SCF_PROPERTY_NEXT_STATE; 1527c478bd9Sstevel@tonic-gate static const char * const scf_property_contract = SCF_PROPERTY_CONTRACT; 1537c478bd9Sstevel@tonic-gate 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* 1567c478bd9Sstevel@tonic-gate * Utility functions 1577c478bd9Sstevel@tonic-gate */ 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate /* 1607c478bd9Sstevel@tonic-gate * For unexpected libscf errors. The ending newline is necessary to keep 1617c478bd9Sstevel@tonic-gate * uu_die() from appending the errno error. 1627c478bd9Sstevel@tonic-gate */ 1637c478bd9Sstevel@tonic-gate #ifndef NDEBUG 1647c478bd9Sstevel@tonic-gate void 1657c478bd9Sstevel@tonic-gate do_scfdie(const char *file, int line) 1667c478bd9Sstevel@tonic-gate { 1677c478bd9Sstevel@tonic-gate uu_die(gettext("%s:%d: Unexpected libscf error: %s. Exiting.\n"), 1687c478bd9Sstevel@tonic-gate file, line, scf_strerror(scf_error())); 1697c478bd9Sstevel@tonic-gate } 1707c478bd9Sstevel@tonic-gate #else 1717c478bd9Sstevel@tonic-gate void 1727c478bd9Sstevel@tonic-gate scfdie(void) 1737c478bd9Sstevel@tonic-gate { 1747c478bd9Sstevel@tonic-gate uu_die(gettext("Unexpected libscf error: %s. Exiting.\n"), 1757c478bd9Sstevel@tonic-gate scf_strerror(scf_error())); 1767c478bd9Sstevel@tonic-gate } 1777c478bd9Sstevel@tonic-gate #endif 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate void * 1807c478bd9Sstevel@tonic-gate safe_malloc(size_t sz) 1817c478bd9Sstevel@tonic-gate { 1827c478bd9Sstevel@tonic-gate void *ptr; 1837c478bd9Sstevel@tonic-gate 1847c478bd9Sstevel@tonic-gate ptr = malloc(sz); 1857c478bd9Sstevel@tonic-gate if (ptr == NULL) 1867c478bd9Sstevel@tonic-gate uu_die(gettext("Out of memory")); 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate return (ptr); 1897c478bd9Sstevel@tonic-gate } 1907c478bd9Sstevel@tonic-gate 1917c478bd9Sstevel@tonic-gate char * 1927c478bd9Sstevel@tonic-gate safe_strdup(const char *str) 1937c478bd9Sstevel@tonic-gate { 1947c478bd9Sstevel@tonic-gate char *cp; 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate cp = strdup(str); 1977c478bd9Sstevel@tonic-gate if (cp == NULL) 1987c478bd9Sstevel@tonic-gate uu_die(gettext("Out of memory.\n")); 1997c478bd9Sstevel@tonic-gate 2007c478bd9Sstevel@tonic-gate return (cp); 2017c478bd9Sstevel@tonic-gate } 2027c478bd9Sstevel@tonic-gate 2037c478bd9Sstevel@tonic-gate /* 2047c478bd9Sstevel@tonic-gate * FMRI hashtable. For uniquifing listings. 2057c478bd9Sstevel@tonic-gate */ 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate struct ht_elem { 2087c478bd9Sstevel@tonic-gate const char *fmri; 2097c478bd9Sstevel@tonic-gate struct ht_elem *next; 2107c478bd9Sstevel@tonic-gate }; 2117c478bd9Sstevel@tonic-gate 2127c478bd9Sstevel@tonic-gate static struct ht_elem **ht_buckets; 2137c478bd9Sstevel@tonic-gate static uint_t ht_buckets_num; 2147c478bd9Sstevel@tonic-gate static uint_t ht_num; 2157c478bd9Sstevel@tonic-gate 2167c478bd9Sstevel@tonic-gate static void 2177c478bd9Sstevel@tonic-gate ht_init() 2187c478bd9Sstevel@tonic-gate { 2197c478bd9Sstevel@tonic-gate ht_buckets_num = 8; 2207c478bd9Sstevel@tonic-gate ht_buckets = safe_malloc(sizeof (*ht_buckets) * ht_buckets_num); 2217c478bd9Sstevel@tonic-gate bzero(ht_buckets, sizeof (*ht_buckets) * ht_buckets_num); 2227c478bd9Sstevel@tonic-gate ht_num = 0; 2237c478bd9Sstevel@tonic-gate } 2247c478bd9Sstevel@tonic-gate 2257c478bd9Sstevel@tonic-gate static uint_t 2267c478bd9Sstevel@tonic-gate ht_hash_fmri(const char *fmri) 2277c478bd9Sstevel@tonic-gate { 2287c478bd9Sstevel@tonic-gate uint_t h = 0, g; 2297c478bd9Sstevel@tonic-gate const char *p, *k; 2307c478bd9Sstevel@tonic-gate 2317c478bd9Sstevel@tonic-gate /* All FMRIs begin with svc:/, so skip that part. */ 2327c478bd9Sstevel@tonic-gate assert(strncmp(fmri, "svc:/", sizeof ("svc:/") - 1) == 0); 2337c478bd9Sstevel@tonic-gate k = fmri + sizeof ("svc:/") - 1; 2347c478bd9Sstevel@tonic-gate 2357c478bd9Sstevel@tonic-gate /* 2367c478bd9Sstevel@tonic-gate * Generic hash function from uts/common/os/modhash.c. 2377c478bd9Sstevel@tonic-gate */ 2387c478bd9Sstevel@tonic-gate for (p = k; *p != '\0'; ++p) { 2397c478bd9Sstevel@tonic-gate h = (h << 4) + *p; 2407c478bd9Sstevel@tonic-gate if ((g = (h & 0xf0000000)) != 0) { 2417c478bd9Sstevel@tonic-gate h ^= (g >> 24); 2427c478bd9Sstevel@tonic-gate h ^= g; 2437c478bd9Sstevel@tonic-gate } 2447c478bd9Sstevel@tonic-gate } 2457c478bd9Sstevel@tonic-gate 2467c478bd9Sstevel@tonic-gate return (h); 2477c478bd9Sstevel@tonic-gate } 2487c478bd9Sstevel@tonic-gate 2497c478bd9Sstevel@tonic-gate static void 2507c478bd9Sstevel@tonic-gate ht_grow() 2517c478bd9Sstevel@tonic-gate { 2527c478bd9Sstevel@tonic-gate uint_t new_ht_buckets_num; 2537c478bd9Sstevel@tonic-gate struct ht_elem **new_ht_buckets; 2547c478bd9Sstevel@tonic-gate int i; 2557c478bd9Sstevel@tonic-gate 2567c478bd9Sstevel@tonic-gate new_ht_buckets_num = ht_buckets_num * 2; 2577c478bd9Sstevel@tonic-gate assert(new_ht_buckets_num > ht_buckets_num); 2587c478bd9Sstevel@tonic-gate new_ht_buckets = 2597c478bd9Sstevel@tonic-gate safe_malloc(sizeof (*new_ht_buckets) * new_ht_buckets_num); 2607c478bd9Sstevel@tonic-gate bzero(new_ht_buckets, sizeof (*new_ht_buckets) * new_ht_buckets_num); 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate for (i = 0; i < ht_buckets_num; ++i) { 2637c478bd9Sstevel@tonic-gate struct ht_elem *elem, *next; 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate for (elem = ht_buckets[i]; elem != NULL; elem = next) { 2667c478bd9Sstevel@tonic-gate uint_t h; 2677c478bd9Sstevel@tonic-gate 2687c478bd9Sstevel@tonic-gate next = elem->next; 2697c478bd9Sstevel@tonic-gate 2707c478bd9Sstevel@tonic-gate h = ht_hash_fmri(elem->fmri); 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate elem->next = 2737c478bd9Sstevel@tonic-gate new_ht_buckets[h & (new_ht_buckets_num - 1)]; 2747c478bd9Sstevel@tonic-gate new_ht_buckets[h & (new_ht_buckets_num - 1)] = elem; 2757c478bd9Sstevel@tonic-gate } 2767c478bd9Sstevel@tonic-gate } 2777c478bd9Sstevel@tonic-gate 2787c478bd9Sstevel@tonic-gate free(ht_buckets); 2797c478bd9Sstevel@tonic-gate 2807c478bd9Sstevel@tonic-gate ht_buckets = new_ht_buckets; 2817c478bd9Sstevel@tonic-gate ht_buckets_num = new_ht_buckets_num; 2827c478bd9Sstevel@tonic-gate } 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate /* 2857c478bd9Sstevel@tonic-gate * Add an FMRI to the hash table. Returns 1 if it was already there, 2867c478bd9Sstevel@tonic-gate * 0 otherwise. 2877c478bd9Sstevel@tonic-gate */ 2887c478bd9Sstevel@tonic-gate static int 2897c478bd9Sstevel@tonic-gate ht_add(const char *fmri) 2907c478bd9Sstevel@tonic-gate { 2917c478bd9Sstevel@tonic-gate uint_t h; 2927c478bd9Sstevel@tonic-gate struct ht_elem *elem; 2937c478bd9Sstevel@tonic-gate 2947c478bd9Sstevel@tonic-gate h = ht_hash_fmri(fmri); 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate elem = ht_buckets[h & (ht_buckets_num - 1)]; 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate for (; elem != NULL; elem = elem->next) { 2997c478bd9Sstevel@tonic-gate if (strcmp(elem->fmri, fmri) == 0) 3007c478bd9Sstevel@tonic-gate return (1); 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate /* Grow when average chain length is over 3. */ 3047c478bd9Sstevel@tonic-gate if (ht_num > 3 * ht_buckets_num) 3057c478bd9Sstevel@tonic-gate ht_grow(); 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate ++ht_num; 3087c478bd9Sstevel@tonic-gate 3097c478bd9Sstevel@tonic-gate elem = safe_malloc(sizeof (*elem)); 3107c478bd9Sstevel@tonic-gate elem->fmri = strdup(fmri); 3117c478bd9Sstevel@tonic-gate elem->next = ht_buckets[h & (ht_buckets_num - 1)]; 3127c478bd9Sstevel@tonic-gate ht_buckets[h & (ht_buckets_num - 1)] = elem; 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate return (0); 3157c478bd9Sstevel@tonic-gate } 3167c478bd9Sstevel@tonic-gate 3177c478bd9Sstevel@tonic-gate 3187c478bd9Sstevel@tonic-gate 3197c478bd9Sstevel@tonic-gate /* 3207c478bd9Sstevel@tonic-gate * Convenience libscf wrapper functions. 3217c478bd9Sstevel@tonic-gate */ 3227c478bd9Sstevel@tonic-gate 3237c478bd9Sstevel@tonic-gate /* 3247c478bd9Sstevel@tonic-gate * Get the single value of the named property in the given property group, 3257c478bd9Sstevel@tonic-gate * which must have type ty, and put it in *vp. If ty is SCF_TYPE_ASTRING, vp 3267c478bd9Sstevel@tonic-gate * is taken to be a char **, and sz is the size of the buffer. sz is unused 3277c478bd9Sstevel@tonic-gate * otherwise. Return 0 on success, -1 if the property doesn't exist, has the 3287c478bd9Sstevel@tonic-gate * wrong type, or doesn't have a single value. If flags has EMPTY_OK, don't 3297c478bd9Sstevel@tonic-gate * complain if the property has no values (but return nonzero). If flags has 3307c478bd9Sstevel@tonic-gate * MULTI_OK and the property has multiple values, succeed with E2BIG. 3317c478bd9Sstevel@tonic-gate */ 3327c478bd9Sstevel@tonic-gate int 3337c478bd9Sstevel@tonic-gate pg_get_single_val(scf_propertygroup_t *pg, const char *propname, scf_type_t ty, 3347c478bd9Sstevel@tonic-gate void *vp, size_t sz, uint_t flags) 3357c478bd9Sstevel@tonic-gate { 3367c478bd9Sstevel@tonic-gate char *buf; 3377c478bd9Sstevel@tonic-gate size_t buf_sz; 3387c478bd9Sstevel@tonic-gate int ret = -1, r; 3397c478bd9Sstevel@tonic-gate boolean_t multi = B_FALSE; 3407c478bd9Sstevel@tonic-gate 3417c478bd9Sstevel@tonic-gate assert((flags & ~(EMPTY_OK | MULTI_OK)) == 0); 3427c478bd9Sstevel@tonic-gate 3437c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, propname, g_prop) == -1) { 3447c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 3457c478bd9Sstevel@tonic-gate scfdie(); 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate goto out; 3487c478bd9Sstevel@tonic-gate } 3497c478bd9Sstevel@tonic-gate 3507c478bd9Sstevel@tonic-gate if (scf_property_is_type(g_prop, ty) != SCF_SUCCESS) { 3517c478bd9Sstevel@tonic-gate if (scf_error() == SCF_ERROR_TYPE_MISMATCH) 3527c478bd9Sstevel@tonic-gate goto misconfigured; 3537c478bd9Sstevel@tonic-gate scfdie(); 3547c478bd9Sstevel@tonic-gate } 3557c478bd9Sstevel@tonic-gate 3567c478bd9Sstevel@tonic-gate if (scf_property_get_value(g_prop, g_val) != SCF_SUCCESS) { 3577c478bd9Sstevel@tonic-gate switch (scf_error()) { 3587c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 3597c478bd9Sstevel@tonic-gate if (flags & EMPTY_OK) 3607c478bd9Sstevel@tonic-gate goto out; 3617c478bd9Sstevel@tonic-gate goto misconfigured; 3627c478bd9Sstevel@tonic-gate 3637c478bd9Sstevel@tonic-gate case SCF_ERROR_CONSTRAINT_VIOLATED: 3647c478bd9Sstevel@tonic-gate if (flags & MULTI_OK) { 3657c478bd9Sstevel@tonic-gate multi = B_TRUE; 3667c478bd9Sstevel@tonic-gate break; 3677c478bd9Sstevel@tonic-gate } 3687c478bd9Sstevel@tonic-gate goto misconfigured; 3697c478bd9Sstevel@tonic-gate 3703eae19d9Swesolows case SCF_ERROR_PERMISSION_DENIED: 3717c478bd9Sstevel@tonic-gate default: 3727c478bd9Sstevel@tonic-gate scfdie(); 3737c478bd9Sstevel@tonic-gate } 3747c478bd9Sstevel@tonic-gate } 3757c478bd9Sstevel@tonic-gate 3767c478bd9Sstevel@tonic-gate switch (ty) { 3777c478bd9Sstevel@tonic-gate case SCF_TYPE_ASTRING: 3787c478bd9Sstevel@tonic-gate r = scf_value_get_astring(g_val, vp, sz) > 0 ? SCF_SUCCESS : -1; 3797c478bd9Sstevel@tonic-gate break; 3807c478bd9Sstevel@tonic-gate 3817c478bd9Sstevel@tonic-gate case SCF_TYPE_BOOLEAN: 3827c478bd9Sstevel@tonic-gate r = scf_value_get_boolean(g_val, (uint8_t *)vp); 3837c478bd9Sstevel@tonic-gate break; 3847c478bd9Sstevel@tonic-gate 3857c478bd9Sstevel@tonic-gate case SCF_TYPE_COUNT: 3867c478bd9Sstevel@tonic-gate r = scf_value_get_count(g_val, (uint64_t *)vp); 3877c478bd9Sstevel@tonic-gate break; 3887c478bd9Sstevel@tonic-gate 3897c478bd9Sstevel@tonic-gate case SCF_TYPE_INTEGER: 3907c478bd9Sstevel@tonic-gate r = scf_value_get_integer(g_val, (int64_t *)vp); 3917c478bd9Sstevel@tonic-gate break; 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate case SCF_TYPE_TIME: { 3947c478bd9Sstevel@tonic-gate int64_t sec; 3957c478bd9Sstevel@tonic-gate int32_t ns; 3967c478bd9Sstevel@tonic-gate r = scf_value_get_time(g_val, &sec, &ns); 3977c478bd9Sstevel@tonic-gate ((struct timeval *)vp)->tv_sec = sec; 3987c478bd9Sstevel@tonic-gate ((struct timeval *)vp)->tv_usec = ns / 1000; 3997c478bd9Sstevel@tonic-gate break; 4007c478bd9Sstevel@tonic-gate } 4017c478bd9Sstevel@tonic-gate 4027c478bd9Sstevel@tonic-gate case SCF_TYPE_USTRING: 4037c478bd9Sstevel@tonic-gate r = scf_value_get_ustring(g_val, vp, sz) > 0 ? SCF_SUCCESS : -1; 4047c478bd9Sstevel@tonic-gate break; 4057c478bd9Sstevel@tonic-gate 4067c478bd9Sstevel@tonic-gate default: 4077c478bd9Sstevel@tonic-gate #ifndef NDEBUG 4087c478bd9Sstevel@tonic-gate uu_warn("%s:%d: Unknown type %d.\n", __FILE__, __LINE__, ty); 4097c478bd9Sstevel@tonic-gate #endif 4107c478bd9Sstevel@tonic-gate abort(); 4117c478bd9Sstevel@tonic-gate } 4127c478bd9Sstevel@tonic-gate if (r != SCF_SUCCESS) 4137c478bd9Sstevel@tonic-gate scfdie(); 4147c478bd9Sstevel@tonic-gate 4157c478bd9Sstevel@tonic-gate ret = multi ? E2BIG : 0; 4167c478bd9Sstevel@tonic-gate goto out; 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate misconfigured: 4197c478bd9Sstevel@tonic-gate buf_sz = max_scf_fmri_length + 1; 4207c478bd9Sstevel@tonic-gate buf = safe_malloc(buf_sz); 4217c478bd9Sstevel@tonic-gate if (scf_property_to_fmri(g_prop, buf, buf_sz) == -1) 4227c478bd9Sstevel@tonic-gate scfdie(); 4237c478bd9Sstevel@tonic-gate 4247c478bd9Sstevel@tonic-gate uu_warn(gettext("Property \"%s\" is misconfigured.\n"), buf); 4257c478bd9Sstevel@tonic-gate 4267c478bd9Sstevel@tonic-gate free(buf); 4277c478bd9Sstevel@tonic-gate 4287c478bd9Sstevel@tonic-gate out: 4297c478bd9Sstevel@tonic-gate return (ret); 4307c478bd9Sstevel@tonic-gate } 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate static scf_snapshot_t * 4337c478bd9Sstevel@tonic-gate get_running_snapshot(scf_instance_t *inst) 4347c478bd9Sstevel@tonic-gate { 4357c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 4367c478bd9Sstevel@tonic-gate 4377c478bd9Sstevel@tonic-gate snap = scf_snapshot_create(h); 4387c478bd9Sstevel@tonic-gate if (snap == NULL) 4397c478bd9Sstevel@tonic-gate scfdie(); 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate if (scf_instance_get_snapshot(inst, "running", snap) == 0) 4427c478bd9Sstevel@tonic-gate return (snap); 4437c478bd9Sstevel@tonic-gate 4447c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 4457c478bd9Sstevel@tonic-gate scfdie(); 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 4487c478bd9Sstevel@tonic-gate return (NULL); 4497c478bd9Sstevel@tonic-gate } 4507c478bd9Sstevel@tonic-gate 4517c478bd9Sstevel@tonic-gate /* 4527c478bd9Sstevel@tonic-gate * As pg_get_single_val(), except look the property group up in an 4537c478bd9Sstevel@tonic-gate * instance. If "use_running" is set, and the running snapshot exists, 4547c478bd9Sstevel@tonic-gate * do a composed lookup there. Otherwise, do an (optionally composed) 4557c478bd9Sstevel@tonic-gate * lookup on the current values. Note that lookups using snapshots are 4567c478bd9Sstevel@tonic-gate * always composed. 4577c478bd9Sstevel@tonic-gate */ 4587c478bd9Sstevel@tonic-gate int 4597c478bd9Sstevel@tonic-gate inst_get_single_val(scf_instance_t *inst, const char *pgname, 4607c478bd9Sstevel@tonic-gate const char *propname, scf_type_t ty, void *vp, size_t sz, uint_t flags, 4617c478bd9Sstevel@tonic-gate int use_running, int composed) 4627c478bd9Sstevel@tonic-gate { 4637c478bd9Sstevel@tonic-gate scf_snapshot_t *snap = NULL; 4647c478bd9Sstevel@tonic-gate int r; 4657c478bd9Sstevel@tonic-gate 4667c478bd9Sstevel@tonic-gate if (use_running) 4677c478bd9Sstevel@tonic-gate snap = get_running_snapshot(inst); 4687c478bd9Sstevel@tonic-gate if (composed || use_running) 4697c478bd9Sstevel@tonic-gate r = scf_instance_get_pg_composed(inst, snap, pgname, g_pg); 4707c478bd9Sstevel@tonic-gate else 4717c478bd9Sstevel@tonic-gate r = scf_instance_get_pg(inst, pgname, g_pg); 4727c478bd9Sstevel@tonic-gate if (snap) 4737c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 4747c478bd9Sstevel@tonic-gate if (r == -1) 4757c478bd9Sstevel@tonic-gate return (-1); 4767c478bd9Sstevel@tonic-gate 4777c478bd9Sstevel@tonic-gate r = pg_get_single_val(g_pg, propname, ty, vp, sz, flags); 4787c478bd9Sstevel@tonic-gate 4797c478bd9Sstevel@tonic-gate return (r); 4807c478bd9Sstevel@tonic-gate } 4817c478bd9Sstevel@tonic-gate 4827c478bd9Sstevel@tonic-gate static int 4837c478bd9Sstevel@tonic-gate instance_enabled(scf_instance_t *inst, boolean_t temp) 4847c478bd9Sstevel@tonic-gate { 4857c478bd9Sstevel@tonic-gate uint8_t b; 4867c478bd9Sstevel@tonic-gate 4877c478bd9Sstevel@tonic-gate if (inst_get_single_val(inst, 4887c478bd9Sstevel@tonic-gate temp ? SCF_PG_GENERAL_OVR : SCF_PG_GENERAL, SCF_PROPERTY_ENABLED, 4897c478bd9Sstevel@tonic-gate SCF_TYPE_BOOLEAN, &b, 0, 0, 0, 0) != 0) 4907c478bd9Sstevel@tonic-gate return (-1); 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate return (b ? 1 : 0); 4937c478bd9Sstevel@tonic-gate } 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate /* 4967c478bd9Sstevel@tonic-gate * Get a string property from the restarter property group of the given 4977c478bd9Sstevel@tonic-gate * instance. Return an empty string on normal problems. 4987c478bd9Sstevel@tonic-gate */ 4997c478bd9Sstevel@tonic-gate static void 5007c478bd9Sstevel@tonic-gate get_restarter_string_prop(scf_instance_t *inst, const char *pname, 5017c478bd9Sstevel@tonic-gate char *buf, size_t buf_sz) 5027c478bd9Sstevel@tonic-gate { 5037c478bd9Sstevel@tonic-gate if (inst_get_single_val(inst, SCF_PG_RESTARTER, pname, 5047c478bd9Sstevel@tonic-gate SCF_TYPE_ASTRING, buf, buf_sz, 0, 0, 1) != 0) 5057c478bd9Sstevel@tonic-gate *buf = '\0'; 5067c478bd9Sstevel@tonic-gate } 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate static int 5097c478bd9Sstevel@tonic-gate get_restarter_time_prop(scf_instance_t *inst, const char *pname, 5107c478bd9Sstevel@tonic-gate struct timeval *tvp, int ok_if_empty) 5117c478bd9Sstevel@tonic-gate { 5127c478bd9Sstevel@tonic-gate int r; 5137c478bd9Sstevel@tonic-gate 5147c478bd9Sstevel@tonic-gate r = inst_get_single_val(inst, SCF_PG_RESTARTER, pname, SCF_TYPE_TIME, 5157c478bd9Sstevel@tonic-gate tvp, NULL, ok_if_empty ? EMPTY_OK : 0, 0, 1); 5167c478bd9Sstevel@tonic-gate 5177c478bd9Sstevel@tonic-gate return (r == 0 ? 0 : -1); 5187c478bd9Sstevel@tonic-gate } 5197c478bd9Sstevel@tonic-gate 5207c478bd9Sstevel@tonic-gate static int 5217c478bd9Sstevel@tonic-gate get_restarter_count_prop(scf_instance_t *inst, const char *pname, uint64_t *cp, 5227c478bd9Sstevel@tonic-gate uint_t flags) 5237c478bd9Sstevel@tonic-gate { 5247c478bd9Sstevel@tonic-gate return (inst_get_single_val(inst, SCF_PG_RESTARTER, pname, 5257c478bd9Sstevel@tonic-gate SCF_TYPE_COUNT, cp, 0, flags, 0, 1)); 5267c478bd9Sstevel@tonic-gate } 5277c478bd9Sstevel@tonic-gate 5287c478bd9Sstevel@tonic-gate 5297c478bd9Sstevel@tonic-gate /* 5307c478bd9Sstevel@tonic-gate * Generic functions 5317c478bd9Sstevel@tonic-gate */ 5327c478bd9Sstevel@tonic-gate 53394501b61Sskamm /* 53494501b61Sskamm * Return an array of pids associated with the given contract id. 53594501b61Sskamm * Returned pids are added to the end of the pidsp array. 53694501b61Sskamm */ 53794501b61Sskamm static void 53894501b61Sskamm ctid_to_pids(uint64_t c, pid_t **pidsp, uint_t *np) 53994501b61Sskamm { 54094501b61Sskamm ct_stathdl_t ctst; 54194501b61Sskamm uint_t m; 54294501b61Sskamm int fd; 54394501b61Sskamm int r, err; 54494501b61Sskamm pid_t *pids; 54594501b61Sskamm 54694501b61Sskamm fd = contract_open(c, NULL, "status", O_RDONLY); 54794501b61Sskamm if (fd < 0) 54894501b61Sskamm return; 54994501b61Sskamm 55094501b61Sskamm err = ct_status_read(fd, CTD_ALL, &ctst); 55194501b61Sskamm if (err != 0) { 55294501b61Sskamm uu_warn(gettext("Could not read status of contract " 55394501b61Sskamm "%ld: %s.\n"), c, strerror(err)); 55494501b61Sskamm (void) close(fd); 55594501b61Sskamm return; 55694501b61Sskamm } 55794501b61Sskamm 55894501b61Sskamm (void) close(fd); 55994501b61Sskamm 56094501b61Sskamm r = ct_pr_status_get_members(ctst, &pids, &m); 56194501b61Sskamm assert(r == 0); 56294501b61Sskamm 56394501b61Sskamm if (m == 0) { 56494501b61Sskamm ct_status_free(ctst); 56594501b61Sskamm return; 56694501b61Sskamm } 56794501b61Sskamm 56894501b61Sskamm *pidsp = realloc(*pidsp, (*np + m) * sizeof (*pidsp)); 56994501b61Sskamm if (*pidsp == NULL) 57094501b61Sskamm uu_die(gettext("Out of memory")); 57194501b61Sskamm 57294501b61Sskamm bcopy(pids, *pidsp + *np, m * sizeof (*pids)); 57394501b61Sskamm *np += m; 57494501b61Sskamm 57594501b61Sskamm ct_status_free(ctst); 57694501b61Sskamm } 57794501b61Sskamm 5787c478bd9Sstevel@tonic-gate static int 5797c478bd9Sstevel@tonic-gate propvals_to_pids(scf_propertygroup_t *pg, const char *pname, pid_t **pidsp, 5807c478bd9Sstevel@tonic-gate uint_t *np, scf_property_t *prop, scf_value_t *val, scf_iter_t *iter) 5817c478bd9Sstevel@tonic-gate { 5827c478bd9Sstevel@tonic-gate scf_type_t ty; 5837c478bd9Sstevel@tonic-gate uint64_t c; 58494501b61Sskamm int r; 5857c478bd9Sstevel@tonic-gate 5867c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, pname, prop) != 0) { 5877c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 5887c478bd9Sstevel@tonic-gate scfdie(); 5897c478bd9Sstevel@tonic-gate 5907c478bd9Sstevel@tonic-gate return (ENOENT); 5917c478bd9Sstevel@tonic-gate } 5927c478bd9Sstevel@tonic-gate 5937c478bd9Sstevel@tonic-gate if (scf_property_type(prop, &ty) != 0) 5947c478bd9Sstevel@tonic-gate scfdie(); 5957c478bd9Sstevel@tonic-gate 5967c478bd9Sstevel@tonic-gate if (ty != SCF_TYPE_COUNT) 5977c478bd9Sstevel@tonic-gate return (EINVAL); 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, prop) != 0) 6007c478bd9Sstevel@tonic-gate scfdie(); 6017c478bd9Sstevel@tonic-gate 6027c478bd9Sstevel@tonic-gate for (;;) { 6037c478bd9Sstevel@tonic-gate r = scf_iter_next_value(iter, val); 6047c478bd9Sstevel@tonic-gate if (r == -1) 6057c478bd9Sstevel@tonic-gate scfdie(); 6067c478bd9Sstevel@tonic-gate if (r == 0) 6077c478bd9Sstevel@tonic-gate break; 6087c478bd9Sstevel@tonic-gate 6097c478bd9Sstevel@tonic-gate if (scf_value_get_count(val, &c) != 0) 6107c478bd9Sstevel@tonic-gate scfdie(); 6117c478bd9Sstevel@tonic-gate 61294501b61Sskamm ctid_to_pids(c, pidsp, np); 61394501b61Sskamm } 6147c478bd9Sstevel@tonic-gate 61594501b61Sskamm return (0); 61694501b61Sskamm } 6177c478bd9Sstevel@tonic-gate 61894501b61Sskamm /* 61994501b61Sskamm * Check if instance has general/restarter property that matches 62094501b61Sskamm * given string. Restarter string must be in canonified form. 62194501b61Sskamm * Returns 0 for success; -1 otherwise. 62294501b61Sskamm */ 62394501b61Sskamm static int 62494501b61Sskamm check_for_restarter(scf_instance_t *inst, const char *restarter) 62594501b61Sskamm { 62694501b61Sskamm char *fmri_buf; 62794501b61Sskamm char *fmri_buf_canonified = NULL; 62894501b61Sskamm int ret = -1; 6297c478bd9Sstevel@tonic-gate 63094501b61Sskamm if (inst == NULL) 63194501b61Sskamm return (-1); 6327c478bd9Sstevel@tonic-gate 63394501b61Sskamm /* Get restarter */ 63494501b61Sskamm fmri_buf = safe_malloc(max_scf_fmri_length + 1); 63594501b61Sskamm if (inst_get_single_val(inst, SCF_PG_GENERAL, 63694501b61Sskamm SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, fmri_buf, 63794501b61Sskamm max_scf_fmri_length + 1, 0, 0, 1) != 0) 63894501b61Sskamm goto out; 63994501b61Sskamm 64094501b61Sskamm fmri_buf_canonified = safe_malloc(max_scf_fmri_length + 1); 64194501b61Sskamm if (scf_canonify_fmri(fmri_buf, fmri_buf_canonified, 64294501b61Sskamm (max_scf_fmri_length + 1)) < 0) 64394501b61Sskamm goto out; 64494501b61Sskamm 64594501b61Sskamm if (strcmp(fmri_buf, restarter) == 0) 64694501b61Sskamm ret = 0; 64794501b61Sskamm 64894501b61Sskamm out: 64994501b61Sskamm free(fmri_buf); 65094501b61Sskamm if (fmri_buf_canonified) 65194501b61Sskamm free(fmri_buf_canonified); 65294501b61Sskamm return (ret); 65394501b61Sskamm } 65494501b61Sskamm 65594501b61Sskamm /* 65694501b61Sskamm * Common code that is used by ctids_by_restarter and pids_by_restarter. 65794501b61Sskamm * Checks for a common restarter and if one is available, it generates 65894501b61Sskamm * the appropriate filename using wip->fmri and stores that in the 65994501b61Sskamm * global genfmri_filename. 66094501b61Sskamm * 66194501b61Sskamm * Restarters currently supported are: svc:/network/inetd:default 66294501b61Sskamm * If a restarter specific action is available, then restarter_spec 66394501b61Sskamm * is set to 1. If a restarter specific action is not available, then 66494501b61Sskamm * restarter_spec is set to 0 and a -1 is returned. 66594501b61Sskamm * 66694501b61Sskamm * Returns: 66794501b61Sskamm * 0 if success: restarter specific action found and filename generated 66894501b61Sskamm * -1 if restarter specific action not found, 66994501b61Sskamm * if restarter specific action found but an error was encountered 67094501b61Sskamm * during the generation of the wip->fmri based filename 67194501b61Sskamm */ 67294501b61Sskamm static int 67394501b61Sskamm common_by_restarter(scf_instance_t *inst, const char *fmri, 67494501b61Sskamm int *restarter_specp) 67594501b61Sskamm { 67694501b61Sskamm int ret = -1; 67794501b61Sskamm int r; 67894501b61Sskamm 67994501b61Sskamm /* Check for inetd specific restarter */ 68094501b61Sskamm if (check_for_restarter(inst, "svc:/network/inetd:default") != 0) { 68194501b61Sskamm *restarter_specp = 0; 68294501b61Sskamm return (ret); 68394501b61Sskamm } 68494501b61Sskamm 68594501b61Sskamm *restarter_specp = 1; 68694501b61Sskamm 68794501b61Sskamm /* Get the ctid filename associated with this instance */ 68894501b61Sskamm r = gen_filenms_from_fmri(fmri, "ctid", genfmri_filename, NULL); 68994501b61Sskamm 69094501b61Sskamm switch (r) { 69194501b61Sskamm case 0: 69294501b61Sskamm break; 69394501b61Sskamm 69494501b61Sskamm case -1: 69594501b61Sskamm /* 69694501b61Sskamm * Unable to get filename from fmri. Print warning 69794501b61Sskamm * and return failure with no ctids. 69894501b61Sskamm */ 69994501b61Sskamm uu_warn(gettext("Unable to read contract ids for %s -- " 70094501b61Sskamm "FMRI is too long\n"), fmri); 70194501b61Sskamm return (ret); 70294501b61Sskamm 70394501b61Sskamm case -2: 70494501b61Sskamm /* 70594501b61Sskamm * The directory didn't exist, so no contracts. 70694501b61Sskamm * Return failure with no ctids. 70794501b61Sskamm */ 70894501b61Sskamm return (ret); 70994501b61Sskamm 71094501b61Sskamm default: 71194501b61Sskamm uu_warn(gettext("%s:%d: gen_filenms_from_fmri() failed with " 71294501b61Sskamm "unknown error %d\n"), __FILE__, __LINE__, r); 71394501b61Sskamm abort(); 71494501b61Sskamm } 71594501b61Sskamm 71694501b61Sskamm return (0); 71794501b61Sskamm 71894501b61Sskamm } 71994501b61Sskamm 72094501b61Sskamm /* 72194501b61Sskamm * Get or print a contract id using a restarter specific action. 72294501b61Sskamm * 72394501b61Sskamm * If the print_flag is not set, this routine gets the single contract 72494501b61Sskamm * id associated with this instance. 72594501b61Sskamm * If the print flag is set, then print each contract id found. 72694501b61Sskamm * 72794501b61Sskamm * Returns: 72894501b61Sskamm * 0 if success: restarter specific action found and used with no error 72994501b61Sskamm * -1 if restarter specific action not found 73094501b61Sskamm * -1 if restarter specific action found, but there was a failure 73194501b61Sskamm * -1 if print flag is not set and no contract id is found or multiple 73294501b61Sskamm * contract ids were found 73394501b61Sskamm * E2BIG if print flag is not set, MULTI_OK bit in flag is set and multiple 73494501b61Sskamm * contract ids were found 73594501b61Sskamm */ 73694501b61Sskamm static int 73794501b61Sskamm ctids_by_restarter(scf_walkinfo_t *wip, uint64_t *cp, int print_flag, 73894501b61Sskamm uint_t flags, int *restarter_specp, void (*callback_header)(), 73994501b61Sskamm void (*callback_ctid)(uint64_t)) 74094501b61Sskamm { 74194501b61Sskamm FILE *fp; 74294501b61Sskamm int ret = -1; 74394501b61Sskamm int fscanf_ret; 74494501b61Sskamm uint64_t cp2; 74594501b61Sskamm int rest_ret; 74694501b61Sskamm 74794501b61Sskamm /* Check if callbacks are needed and were passed in */ 74894501b61Sskamm if (print_flag) { 74994501b61Sskamm if ((callback_header == NULL) || (callback_ctid == NULL)) 75094501b61Sskamm return (ret); 75194501b61Sskamm } 75294501b61Sskamm 75394501b61Sskamm /* Check for restarter specific action and generation of filename */ 75494501b61Sskamm rest_ret = common_by_restarter(wip->inst, wip->fmri, restarter_specp); 75594501b61Sskamm if (rest_ret != 0) 75694501b61Sskamm return (rest_ret); 75794501b61Sskamm 75894501b61Sskamm /* 75994501b61Sskamm * If fopen fails, then ctid file hasn't been created yet. 76094501b61Sskamm * If print_flag is set, this is ok; otherwise fail. 76194501b61Sskamm */ 76294501b61Sskamm if ((fp = fopen(genfmri_filename, "r")) == NULL) { 76394501b61Sskamm if (print_flag) 76494501b61Sskamm return (0); 76594501b61Sskamm goto out; 76694501b61Sskamm } 76794501b61Sskamm 76894501b61Sskamm if (print_flag) { 76994501b61Sskamm /* 77094501b61Sskamm * Print all contract ids that are found. 77194501b61Sskamm * First callback to print ctid header. 77294501b61Sskamm */ 77394501b61Sskamm callback_header(); 77494501b61Sskamm 77594501b61Sskamm /* fscanf may not set errno, so be sure to clear it first */ 77694501b61Sskamm errno = 0; 77794501b61Sskamm while ((fscanf_ret = fscanf(fp, "%llu", cp)) == 1) { 77894501b61Sskamm /* Callback to print contract id */ 77994501b61Sskamm callback_ctid(*cp); 78094501b61Sskamm errno = 0; 78194501b61Sskamm } 78294501b61Sskamm /* EOF is not a failure when no errno. */ 78394501b61Sskamm if ((fscanf_ret != EOF) || (errno != 0)) { 78494501b61Sskamm uu_die(gettext("Unable to read ctid file for %s"), 78594501b61Sskamm wip->fmri); 78694501b61Sskamm } 78794501b61Sskamm (void) putchar('\n'); 78894501b61Sskamm ret = 0; 78994501b61Sskamm } else { 79094501b61Sskamm /* Must find 1 ctid or fail */ 79194501b61Sskamm if (fscanf(fp, "%llu", cp) == 1) { 79294501b61Sskamm /* If 2nd ctid found - fail */ 79394501b61Sskamm if (fscanf(fp, "%llu", &cp2) == 1) { 79494501b61Sskamm if (flags & MULTI_OK) 79594501b61Sskamm ret = E2BIG; 79694501b61Sskamm } else { 79794501b61Sskamm /* Success - found only 1 ctid */ 79894501b61Sskamm ret = 0; 79994501b61Sskamm } 8007c478bd9Sstevel@tonic-gate } 80194501b61Sskamm } 80294501b61Sskamm (void) fclose(fp); 8037c478bd9Sstevel@tonic-gate 80494501b61Sskamm out: 80594501b61Sskamm return (ret); 80694501b61Sskamm } 80794501b61Sskamm 80894501b61Sskamm /* 80994501b61Sskamm * Get the process ids associated with an instance using a restarter 81094501b61Sskamm * specific action. 81194501b61Sskamm * 81294501b61Sskamm * Returns: 81394501b61Sskamm * 0 if success: restarter specific action found and used with no error 81494501b61Sskamm * -1 restarter specific action not found or if failure 81594501b61Sskamm */ 81694501b61Sskamm static int 81794501b61Sskamm pids_by_restarter(scf_instance_t *inst, const char *fmri, 81894501b61Sskamm pid_t **pids, uint_t *np, int *restarter_specp) 81994501b61Sskamm { 82094501b61Sskamm uint64_t c; 82194501b61Sskamm FILE *fp; 82294501b61Sskamm int fscanf_ret; 82394501b61Sskamm int rest_ret; 8247c478bd9Sstevel@tonic-gate 82594501b61Sskamm /* Check for restarter specific action and generation of filename */ 82694501b61Sskamm rest_ret = common_by_restarter(inst, fmri, restarter_specp); 82794501b61Sskamm if (rest_ret != 0) 82894501b61Sskamm return (rest_ret); 8297c478bd9Sstevel@tonic-gate 83094501b61Sskamm /* 83194501b61Sskamm * If fopen fails with ENOENT then the ctid file hasn't been 83294501b61Sskamm * created yet so return success. 83394501b61Sskamm * For all other errors - fail with uu_die. 83494501b61Sskamm */ 83594501b61Sskamm if ((fp = fopen(genfmri_filename, "r")) == NULL) { 83694501b61Sskamm if (errno == ENOENT) 83794501b61Sskamm return (0); 83894501b61Sskamm uu_die(gettext("Unable to open ctid file for %s"), fmri); 83994501b61Sskamm } 84094501b61Sskamm 84194501b61Sskamm /* fscanf may not set errno, so be sure to clear it first */ 84294501b61Sskamm errno = 0; 84394501b61Sskamm while ((fscanf_ret = fscanf(fp, "%llu", &c)) == 1) { 84494501b61Sskamm if (c == 0) { 84594501b61Sskamm (void) fclose(fp); 84694501b61Sskamm uu_die(gettext("ctid file for %s has corrupt data"), 84794501b61Sskamm fmri); 84894501b61Sskamm } 84994501b61Sskamm ctid_to_pids(c, pids, np); 85094501b61Sskamm errno = 0; 85194501b61Sskamm } 85294501b61Sskamm /* EOF is not a failure when no errno. */ 85394501b61Sskamm if ((fscanf_ret != EOF) || (errno != 0)) { 85494501b61Sskamm uu_die(gettext("Unable to read ctid file for %s"), fmri); 8557c478bd9Sstevel@tonic-gate } 8567c478bd9Sstevel@tonic-gate 85794501b61Sskamm (void) fclose(fp); 8587c478bd9Sstevel@tonic-gate return (0); 8597c478bd9Sstevel@tonic-gate } 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate static int 86294501b61Sskamm instance_processes(scf_instance_t *inst, const char *fmri, 86394501b61Sskamm pid_t **pids, uint_t *np) 8647c478bd9Sstevel@tonic-gate { 8657c478bd9Sstevel@tonic-gate scf_iter_t *iter; 8667c478bd9Sstevel@tonic-gate int ret; 86794501b61Sskamm int restarter_spec; 86894501b61Sskamm 86994501b61Sskamm /* Use the restarter specific get pids routine, if available. */ 87094501b61Sskamm ret = pids_by_restarter(inst, fmri, pids, np, &restarter_spec); 87194501b61Sskamm if (restarter_spec == 1) 87294501b61Sskamm return (ret); 8737c478bd9Sstevel@tonic-gate 8747c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL) 8757c478bd9Sstevel@tonic-gate scfdie(); 8767c478bd9Sstevel@tonic-gate 8777c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(inst, SCF_PG_RESTARTER, g_pg) == 0) { 8787c478bd9Sstevel@tonic-gate *pids = NULL; 8797c478bd9Sstevel@tonic-gate *np = 0; 8807c478bd9Sstevel@tonic-gate 8817c478bd9Sstevel@tonic-gate (void) propvals_to_pids(g_pg, scf_property_contract, pids, np, 8827c478bd9Sstevel@tonic-gate g_prop, g_val, iter); 8837c478bd9Sstevel@tonic-gate 8847c478bd9Sstevel@tonic-gate (void) propvals_to_pids(g_pg, SCF_PROPERTY_TRANSIENT_CONTRACT, 8857c478bd9Sstevel@tonic-gate pids, np, g_prop, g_val, iter); 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate ret = 0; 8887c478bd9Sstevel@tonic-gate } else { 8897c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 8907c478bd9Sstevel@tonic-gate scfdie(); 8917c478bd9Sstevel@tonic-gate 8927c478bd9Sstevel@tonic-gate ret = -1; 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate 8957c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate return (ret); 8987c478bd9Sstevel@tonic-gate } 8997c478bd9Sstevel@tonic-gate 9007c478bd9Sstevel@tonic-gate static int 9017c478bd9Sstevel@tonic-gate get_psinfo(pid_t pid, psinfo_t *psip) 9027c478bd9Sstevel@tonic-gate { 9037c478bd9Sstevel@tonic-gate char path[100]; 9047c478bd9Sstevel@tonic-gate int fd; 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate (void) snprintf(path, sizeof (path), "/proc/%lu/psinfo", pid); 9077c478bd9Sstevel@tonic-gate 9087c478bd9Sstevel@tonic-gate fd = open64(path, O_RDONLY); 9097c478bd9Sstevel@tonic-gate if (fd < 0) 9107c478bd9Sstevel@tonic-gate return (-1); 9117c478bd9Sstevel@tonic-gate 9127c478bd9Sstevel@tonic-gate if (read(fd, psip, sizeof (*psip)) < 0) 9137c478bd9Sstevel@tonic-gate uu_die(gettext("Could not read info for process %lu"), pid); 9147c478bd9Sstevel@tonic-gate 9157c478bd9Sstevel@tonic-gate (void) close(fd); 9167c478bd9Sstevel@tonic-gate 9177c478bd9Sstevel@tonic-gate return (0); 9187c478bd9Sstevel@tonic-gate } 9197c478bd9Sstevel@tonic-gate 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate 9227c478bd9Sstevel@tonic-gate /* 9237c478bd9Sstevel@tonic-gate * Column sprint and sortkey functions 9247c478bd9Sstevel@tonic-gate */ 9257c478bd9Sstevel@tonic-gate 9267c478bd9Sstevel@tonic-gate struct column { 9277c478bd9Sstevel@tonic-gate const char *name; 9287c478bd9Sstevel@tonic-gate int width; 9297c478bd9Sstevel@tonic-gate 9307c478bd9Sstevel@tonic-gate /* 9317c478bd9Sstevel@tonic-gate * This function should write the value for the column into buf, and 9327c478bd9Sstevel@tonic-gate * grow or allocate buf accordingly. It should always write at least 9337c478bd9Sstevel@tonic-gate * width bytes, blanking unused bytes with spaces. If the field is 9347c478bd9Sstevel@tonic-gate * greater than the column width we allow it to overlap other columns. 9357c478bd9Sstevel@tonic-gate * In particular, it shouldn't write any null bytes. (Though an extra 9367c478bd9Sstevel@tonic-gate * null byte past the end is currently tolerated.) If the property 9377c478bd9Sstevel@tonic-gate * group is non-NULL, then we are dealing with a legacy service. 9387c478bd9Sstevel@tonic-gate */ 9397c478bd9Sstevel@tonic-gate void (*sprint)(char **, scf_walkinfo_t *); 9407c478bd9Sstevel@tonic-gate 9417c478bd9Sstevel@tonic-gate int sortkey_width; 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate /* 9447c478bd9Sstevel@tonic-gate * This function should write sortkey_width bytes into buf which will 9457c478bd9Sstevel@tonic-gate * cause memcmp() to sort it properly. (Unlike sprint() above, 9467c478bd9Sstevel@tonic-gate * however, an extra null byte may overrun the buffer.) The second 9477c478bd9Sstevel@tonic-gate * argument controls whether the results are sorted in forward or 9487c478bd9Sstevel@tonic-gate * reverse order. 9497c478bd9Sstevel@tonic-gate */ 9507c478bd9Sstevel@tonic-gate void (*get_sortkey)(char *, int, scf_walkinfo_t *); 9517c478bd9Sstevel@tonic-gate }; 9527c478bd9Sstevel@tonic-gate 9537c478bd9Sstevel@tonic-gate static void 9547c478bd9Sstevel@tonic-gate reverse_bytes(char *buf, size_t len) 9557c478bd9Sstevel@tonic-gate { 9567c478bd9Sstevel@tonic-gate int i; 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate for (i = 0; i < len; ++i) 9597c478bd9Sstevel@tonic-gate buf[i] = ~buf[i]; 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate 9627c478bd9Sstevel@tonic-gate /* CTID */ 9637c478bd9Sstevel@tonic-gate #define CTID_COLUMN_WIDTH 6 9647c478bd9Sstevel@tonic-gate 9657c478bd9Sstevel@tonic-gate static void 9667c478bd9Sstevel@tonic-gate sprint_ctid(char **buf, scf_walkinfo_t *wip) 9677c478bd9Sstevel@tonic-gate { 9687c478bd9Sstevel@tonic-gate int r; 9697c478bd9Sstevel@tonic-gate uint64_t c; 9707c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + CTID_COLUMN_WIDTH + 2; 9717c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 97294501b61Sskamm int restarter_spec; 9737c478bd9Sstevel@tonic-gate 97494501b61Sskamm /* 97594501b61Sskamm * Use the restarter specific get pids routine, if available. 97694501b61Sskamm * Only check for non-legacy services (wip->pg == 0). 97794501b61Sskamm */ 97894501b61Sskamm if (wip->pg != NULL) { 9797c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, scf_property_contract, 9807c478bd9Sstevel@tonic-gate SCF_TYPE_COUNT, &c, 0, EMPTY_OK | MULTI_OK); 98194501b61Sskamm } else { 98294501b61Sskamm r = ctids_by_restarter(wip, &c, 0, MULTI_OK, &restarter_spec, 98394501b61Sskamm NULL, NULL); 98494501b61Sskamm if (restarter_spec == 0) { 98594501b61Sskamm /* No restarter specific routine */ 98694501b61Sskamm r = get_restarter_count_prop(wip->inst, 98794501b61Sskamm scf_property_contract, &c, EMPTY_OK | MULTI_OK); 98894501b61Sskamm } 98994501b61Sskamm } 9907c478bd9Sstevel@tonic-gate 9917c478bd9Sstevel@tonic-gate if (r == 0) 9927c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%*lu ", 9937c478bd9Sstevel@tonic-gate *buf ? *buf : "", CTID_COLUMN_WIDTH, (ctid_t)c); 9947c478bd9Sstevel@tonic-gate else if (r == E2BIG) 9957c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%*lu* ", 9967c478bd9Sstevel@tonic-gate *buf ? *buf : "", CTID_COLUMN_WIDTH - 1, (ctid_t)c); 9977c478bd9Sstevel@tonic-gate else 9987c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%*s ", 9997c478bd9Sstevel@tonic-gate *buf ? *buf : "", CTID_COLUMN_WIDTH, "-"); 10007c478bd9Sstevel@tonic-gate if (*buf) 10017c478bd9Sstevel@tonic-gate free(*buf); 10027c478bd9Sstevel@tonic-gate *buf = newbuf; 10037c478bd9Sstevel@tonic-gate } 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate #define CTID_SORTKEY_WIDTH (sizeof (uint64_t)) 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate static void 10087c478bd9Sstevel@tonic-gate sortkey_ctid(char *buf, int reverse, scf_walkinfo_t *wip) 10097c478bd9Sstevel@tonic-gate { 10107c478bd9Sstevel@tonic-gate int r; 10117c478bd9Sstevel@tonic-gate uint64_t c; 101294501b61Sskamm int restarter_spec; 10137c478bd9Sstevel@tonic-gate 101494501b61Sskamm /* 101594501b61Sskamm * Use the restarter specific get pids routine, if available. 101694501b61Sskamm * Only check for non-legacy services (wip->pg == 0). 101794501b61Sskamm */ 101894501b61Sskamm if (wip->pg != NULL) { 10197c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, scf_property_contract, 10207c478bd9Sstevel@tonic-gate SCF_TYPE_COUNT, &c, 0, EMPTY_OK); 102194501b61Sskamm } else { 102294501b61Sskamm r = ctids_by_restarter(wip, &c, 0, MULTI_OK, &restarter_spec, 102394501b61Sskamm NULL, NULL); 102494501b61Sskamm if (restarter_spec == 0) { 102594501b61Sskamm /* No restarter specific routine */ 102694501b61Sskamm r = get_restarter_count_prop(wip->inst, 102794501b61Sskamm scf_property_contract, &c, EMPTY_OK); 102894501b61Sskamm } 102994501b61Sskamm } 10307c478bd9Sstevel@tonic-gate 10317c478bd9Sstevel@tonic-gate if (r == 0) { 10327c478bd9Sstevel@tonic-gate /* 10337c478bd9Sstevel@tonic-gate * Use the id itself, but it must be big-endian for this to 10347c478bd9Sstevel@tonic-gate * work. 10357c478bd9Sstevel@tonic-gate */ 10367c478bd9Sstevel@tonic-gate c = BE_64(c); 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate bcopy(&c, buf, CTID_SORTKEY_WIDTH); 10397c478bd9Sstevel@tonic-gate } else { 10407c478bd9Sstevel@tonic-gate bzero(buf, CTID_SORTKEY_WIDTH); 10417c478bd9Sstevel@tonic-gate } 10427c478bd9Sstevel@tonic-gate 10437c478bd9Sstevel@tonic-gate if (reverse) 10447c478bd9Sstevel@tonic-gate reverse_bytes(buf, CTID_SORTKEY_WIDTH); 10457c478bd9Sstevel@tonic-gate } 10467c478bd9Sstevel@tonic-gate 10477c478bd9Sstevel@tonic-gate /* DESC */ 10487c478bd9Sstevel@tonic-gate #define DESC_COLUMN_WIDTH 100 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate static void 10517c478bd9Sstevel@tonic-gate sprint_desc(char **buf, scf_walkinfo_t *wip) 10527c478bd9Sstevel@tonic-gate { 10537c478bd9Sstevel@tonic-gate char *x; 10547c478bd9Sstevel@tonic-gate size_t newsize; 10557c478bd9Sstevel@tonic-gate char *newbuf; 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate if (common_name_buf == NULL) 10587c478bd9Sstevel@tonic-gate common_name_buf = safe_malloc(max_scf_value_length + 1); 10597c478bd9Sstevel@tonic-gate 10607c478bd9Sstevel@tonic-gate bzero(common_name_buf, max_scf_value_length + 1); 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate if (wip->pg != NULL) { 10637c478bd9Sstevel@tonic-gate common_name_buf[0] = '-'; 10647c478bd9Sstevel@tonic-gate } else if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, locale, 10657c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 10667c478bd9Sstevel@tonic-gate 1, 1) == -1 && 10677c478bd9Sstevel@tonic-gate inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, "C", 10687c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 10697c478bd9Sstevel@tonic-gate 1, 1) == -1) { 10707c478bd9Sstevel@tonic-gate common_name_buf[0] = '-'; 10717c478bd9Sstevel@tonic-gate } 10727c478bd9Sstevel@tonic-gate 10737c478bd9Sstevel@tonic-gate /* 10747c478bd9Sstevel@tonic-gate * Collapse multi-line tm_common_name values into a single line. 10757c478bd9Sstevel@tonic-gate */ 10767c478bd9Sstevel@tonic-gate for (x = common_name_buf; *x != '\0'; x++) 10777c478bd9Sstevel@tonic-gate if (*x == '\n') 10787c478bd9Sstevel@tonic-gate *x = ' '; 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate if (strlen(common_name_buf) > DESC_COLUMN_WIDTH) 10817c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + 10827c478bd9Sstevel@tonic-gate strlen(common_name_buf) + 1; 10837c478bd9Sstevel@tonic-gate else 10847c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + DESC_COLUMN_WIDTH + 1; 10857c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 10867c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 10873eae19d9Swesolows DESC_COLUMN_WIDTH, common_name_buf); 10887c478bd9Sstevel@tonic-gate if (*buf) 10897c478bd9Sstevel@tonic-gate free(*buf); 10907c478bd9Sstevel@tonic-gate *buf = newbuf; 10917c478bd9Sstevel@tonic-gate } 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate /* ARGSUSED */ 10947c478bd9Sstevel@tonic-gate static void 10957c478bd9Sstevel@tonic-gate sortkey_desc(char *buf, int reverse, scf_walkinfo_t *wip) 10967c478bd9Sstevel@tonic-gate { 10977c478bd9Sstevel@tonic-gate bzero(buf, DESC_COLUMN_WIDTH); 10987c478bd9Sstevel@tonic-gate } 10997c478bd9Sstevel@tonic-gate 11007c478bd9Sstevel@tonic-gate /* State columns (STATE, NSTATE, S, N, SN, STA, NSTA) */ 11017c478bd9Sstevel@tonic-gate 11027c478bd9Sstevel@tonic-gate static char 11037c478bd9Sstevel@tonic-gate state_to_char(const char *state) 11047c478bd9Sstevel@tonic-gate { 11057c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) 11067c478bd9Sstevel@tonic-gate return ('u'); 11077c478bd9Sstevel@tonic-gate 11087c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0) 11097c478bd9Sstevel@tonic-gate return ('0'); 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) 11127c478bd9Sstevel@tonic-gate return ('1'); 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) 11157c478bd9Sstevel@tonic-gate return ('m'); 11167c478bd9Sstevel@tonic-gate 11177c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) 11187c478bd9Sstevel@tonic-gate return ('d'); 11197c478bd9Sstevel@tonic-gate 11207c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) 11217c478bd9Sstevel@tonic-gate return ('D'); 11227c478bd9Sstevel@tonic-gate 11237c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0) 11247c478bd9Sstevel@tonic-gate return ('L'); 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate return ('?'); 11277c478bd9Sstevel@tonic-gate } 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate /* Return true if inst is transitioning. */ 11307c478bd9Sstevel@tonic-gate static int 11317c478bd9Sstevel@tonic-gate transitioning(scf_instance_t *inst) 11327c478bd9Sstevel@tonic-gate { 11337c478bd9Sstevel@tonic-gate char nstate_name[MAX_SCF_STATE_STRING_SZ]; 11347c478bd9Sstevel@tonic-gate 11357c478bd9Sstevel@tonic-gate get_restarter_string_prop(inst, scf_property_next_state, nstate_name, 11367c478bd9Sstevel@tonic-gate sizeof (nstate_name)); 11377c478bd9Sstevel@tonic-gate 11387c478bd9Sstevel@tonic-gate return (state_to_char(nstate_name) != '?'); 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate /* ARGSUSED */ 11427c478bd9Sstevel@tonic-gate static void 11437c478bd9Sstevel@tonic-gate sortkey_states(const char *pname, char *buf, int reverse, scf_walkinfo_t *wip) 11447c478bd9Sstevel@tonic-gate { 11457c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate /* 11487c478bd9Sstevel@tonic-gate * Lower numbers are printed first, so these are arranged from least 11497c478bd9Sstevel@tonic-gate * interesting ("legacy run") to most interesting (unknown). 11507c478bd9Sstevel@tonic-gate */ 11517c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 11527c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, pname, state_name, 11537c478bd9Sstevel@tonic-gate sizeof (state_name)); 11547c478bd9Sstevel@tonic-gate 11557c478bd9Sstevel@tonic-gate if (strcmp(state_name, SCF_STATE_STRING_ONLINE) == 0) 11567c478bd9Sstevel@tonic-gate *buf = 2; 11577c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_DEGRADED) == 0) 11587c478bd9Sstevel@tonic-gate *buf = 3; 11597c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_OFFLINE) == 0) 11607c478bd9Sstevel@tonic-gate *buf = 4; 11617c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_MAINT) == 0) 11627c478bd9Sstevel@tonic-gate *buf = 5; 11637c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_DISABLED) == 0) 11647c478bd9Sstevel@tonic-gate *buf = 1; 11657c478bd9Sstevel@tonic-gate else if (strcmp(state_name, SCF_STATE_STRING_UNINIT) == 0) 11667c478bd9Sstevel@tonic-gate *buf = 6; 11677c478bd9Sstevel@tonic-gate else 11687c478bd9Sstevel@tonic-gate *buf = 7; 11697c478bd9Sstevel@tonic-gate } else 11707c478bd9Sstevel@tonic-gate *buf = 0; 11717c478bd9Sstevel@tonic-gate 11727c478bd9Sstevel@tonic-gate if (reverse) 11737c478bd9Sstevel@tonic-gate *buf = 255 - *buf; 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate static void 11777c478bd9Sstevel@tonic-gate sprint_state(char **buf, scf_walkinfo_t *wip) 11787c478bd9Sstevel@tonic-gate { 11797c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ + 1]; 11807c478bd9Sstevel@tonic-gate size_t newsize; 11817c478bd9Sstevel@tonic-gate char *newbuf; 11827c478bd9Sstevel@tonic-gate 11837c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 11847c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 11857c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate /* Don't print blank fields, to ease parsing. */ 11887c478bd9Sstevel@tonic-gate if (state_name[0] == '\0') { 11897c478bd9Sstevel@tonic-gate state_name[0] = '-'; 11907c478bd9Sstevel@tonic-gate state_name[1] = '\0'; 11917c478bd9Sstevel@tonic-gate } 11927c478bd9Sstevel@tonic-gate 11937c478bd9Sstevel@tonic-gate if (!opt_nstate_shown && transitioning(wip->inst)) { 11947c478bd9Sstevel@tonic-gate /* Append an asterisk if nstate is valid. */ 11957c478bd9Sstevel@tonic-gate (void) strcat(state_name, "*"); 11967c478bd9Sstevel@tonic-gate } 11977c478bd9Sstevel@tonic-gate } else 11987c478bd9Sstevel@tonic-gate (void) strcpy(state_name, SCF_STATE_STRING_LEGACY); 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + MAX_SCF_STATE_STRING_SZ + 2; 12017c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 12027c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 12037c478bd9Sstevel@tonic-gate MAX_SCF_STATE_STRING_SZ + 1, state_name); 12047c478bd9Sstevel@tonic-gate 12057c478bd9Sstevel@tonic-gate if (*buf) 12067c478bd9Sstevel@tonic-gate free(*buf); 12077c478bd9Sstevel@tonic-gate *buf = newbuf; 12087c478bd9Sstevel@tonic-gate } 12097c478bd9Sstevel@tonic-gate 12107c478bd9Sstevel@tonic-gate static void 12117c478bd9Sstevel@tonic-gate sortkey_state(char *buf, int reverse, scf_walkinfo_t *wip) 12127c478bd9Sstevel@tonic-gate { 12137c478bd9Sstevel@tonic-gate sortkey_states(scf_property_state, buf, reverse, wip); 12147c478bd9Sstevel@tonic-gate } 12157c478bd9Sstevel@tonic-gate 12167c478bd9Sstevel@tonic-gate static void 12177c478bd9Sstevel@tonic-gate sprint_nstate(char **buf, scf_walkinfo_t *wip) 12187c478bd9Sstevel@tonic-gate { 12197c478bd9Sstevel@tonic-gate char next_state_name[MAX_SCF_STATE_STRING_SZ]; 12207c478bd9Sstevel@tonic-gate boolean_t blank = 0; 12217c478bd9Sstevel@tonic-gate size_t newsize; 12227c478bd9Sstevel@tonic-gate char *newbuf; 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 12257c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 12267c478bd9Sstevel@tonic-gate next_state_name, sizeof (next_state_name)); 12277c478bd9Sstevel@tonic-gate 12287c478bd9Sstevel@tonic-gate /* Don't print blank fields, to ease parsing. */ 12297c478bd9Sstevel@tonic-gate if (next_state_name[0] == '\0' || 12307c478bd9Sstevel@tonic-gate strcmp(next_state_name, SCF_STATE_STRING_NONE) == 0) 12317c478bd9Sstevel@tonic-gate blank = 1; 12327c478bd9Sstevel@tonic-gate } else 12337c478bd9Sstevel@tonic-gate blank = 1; 12347c478bd9Sstevel@tonic-gate 12357c478bd9Sstevel@tonic-gate if (blank) { 12367c478bd9Sstevel@tonic-gate next_state_name[0] = '-'; 12377c478bd9Sstevel@tonic-gate next_state_name[1] = '\0'; 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate 12407c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + MAX_SCF_STATE_STRING_SZ + 1; 12417c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 12427c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 12437c478bd9Sstevel@tonic-gate MAX_SCF_STATE_STRING_SZ - 1, next_state_name); 12447c478bd9Sstevel@tonic-gate if (*buf) 12457c478bd9Sstevel@tonic-gate free(*buf); 12467c478bd9Sstevel@tonic-gate *buf = newbuf; 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate static void 12507c478bd9Sstevel@tonic-gate sortkey_nstate(char *buf, int reverse, scf_walkinfo_t *wip) 12517c478bd9Sstevel@tonic-gate { 12527c478bd9Sstevel@tonic-gate sortkey_states(scf_property_next_state, buf, reverse, wip); 12537c478bd9Sstevel@tonic-gate } 12547c478bd9Sstevel@tonic-gate 12557c478bd9Sstevel@tonic-gate static void 12567c478bd9Sstevel@tonic-gate sprint_s(char **buf, scf_walkinfo_t *wip) 12577c478bd9Sstevel@tonic-gate { 12587c478bd9Sstevel@tonic-gate char tmp[3]; 12597c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 12607c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 4; 12617c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 12627c478bd9Sstevel@tonic-gate 12637c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 12647c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 12657c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 12667c478bd9Sstevel@tonic-gate tmp[0] = state_to_char(state_name); 12677c478bd9Sstevel@tonic-gate 12687c478bd9Sstevel@tonic-gate if (!opt_nstate_shown && transitioning(wip->inst)) 12697c478bd9Sstevel@tonic-gate tmp[1] = '*'; 12707c478bd9Sstevel@tonic-gate else 12717c478bd9Sstevel@tonic-gate tmp[1] = ' '; 12727c478bd9Sstevel@tonic-gate } else { 12737c478bd9Sstevel@tonic-gate tmp[0] = 'L'; 12747c478bd9Sstevel@tonic-gate tmp[1] = ' '; 12757c478bd9Sstevel@tonic-gate } 12767c478bd9Sstevel@tonic-gate tmp[2] = ' '; 12777c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s", *buf ? *buf : "", 12787c478bd9Sstevel@tonic-gate 3, tmp); 12797c478bd9Sstevel@tonic-gate if (*buf) 12807c478bd9Sstevel@tonic-gate free(*buf); 12817c478bd9Sstevel@tonic-gate *buf = newbuf; 12827c478bd9Sstevel@tonic-gate } 12837c478bd9Sstevel@tonic-gate 12847c478bd9Sstevel@tonic-gate static void 12857c478bd9Sstevel@tonic-gate sprint_n(char **buf, scf_walkinfo_t *wip) 12867c478bd9Sstevel@tonic-gate { 12877c478bd9Sstevel@tonic-gate char tmp[2]; 12887c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 3; 12897c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 12907c478bd9Sstevel@tonic-gate char nstate_name[MAX_SCF_STATE_STRING_SZ]; 12917c478bd9Sstevel@tonic-gate 12927c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 12937c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 12947c478bd9Sstevel@tonic-gate nstate_name, sizeof (nstate_name)); 12957c478bd9Sstevel@tonic-gate 12967c478bd9Sstevel@tonic-gate if (strcmp(nstate_name, SCF_STATE_STRING_NONE) == 0) 12977c478bd9Sstevel@tonic-gate tmp[0] = '-'; 12987c478bd9Sstevel@tonic-gate else 12997c478bd9Sstevel@tonic-gate tmp[0] = state_to_char(nstate_name); 13007c478bd9Sstevel@tonic-gate } else 13017c478bd9Sstevel@tonic-gate tmp[0] = '-'; 13027c478bd9Sstevel@tonic-gate 13037c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 13047c478bd9Sstevel@tonic-gate 2, tmp); 13057c478bd9Sstevel@tonic-gate if (*buf) 13067c478bd9Sstevel@tonic-gate free(*buf); 13077c478bd9Sstevel@tonic-gate *buf = newbuf; 13087c478bd9Sstevel@tonic-gate } 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate static void 13117c478bd9Sstevel@tonic-gate sprint_sn(char **buf, scf_walkinfo_t *wip) 13127c478bd9Sstevel@tonic-gate { 13137c478bd9Sstevel@tonic-gate char tmp[3]; 13147c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 4; 13157c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 13167c478bd9Sstevel@tonic-gate char nstate_name[MAX_SCF_STATE_STRING_SZ]; 13177c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 13187c478bd9Sstevel@tonic-gate 13197c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 13207c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 13217c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 13227c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 13237c478bd9Sstevel@tonic-gate nstate_name, sizeof (nstate_name)); 13247c478bd9Sstevel@tonic-gate tmp[0] = state_to_char(state_name); 13257c478bd9Sstevel@tonic-gate 13267c478bd9Sstevel@tonic-gate if (strcmp(nstate_name, SCF_STATE_STRING_NONE) == 0) 13277c478bd9Sstevel@tonic-gate tmp[1] = '-'; 13287c478bd9Sstevel@tonic-gate else 13297c478bd9Sstevel@tonic-gate tmp[1] = state_to_char(nstate_name); 13307c478bd9Sstevel@tonic-gate } else { 13317c478bd9Sstevel@tonic-gate tmp[0] = 'L'; 13327c478bd9Sstevel@tonic-gate tmp[1] = '-'; 13337c478bd9Sstevel@tonic-gate } 13347c478bd9Sstevel@tonic-gate 13357c478bd9Sstevel@tonic-gate tmp[2] = ' '; 13367c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 13377c478bd9Sstevel@tonic-gate 3, tmp); 13387c478bd9Sstevel@tonic-gate if (*buf) 13397c478bd9Sstevel@tonic-gate free(*buf); 13407c478bd9Sstevel@tonic-gate *buf = newbuf; 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate /* ARGSUSED */ 13447c478bd9Sstevel@tonic-gate static void 13457c478bd9Sstevel@tonic-gate sortkey_sn(char *buf, int reverse, scf_walkinfo_t *wip) 13467c478bd9Sstevel@tonic-gate { 13477c478bd9Sstevel@tonic-gate sortkey_state(buf, reverse, wip); 13487c478bd9Sstevel@tonic-gate sortkey_nstate(buf + 1, reverse, wip); 13497c478bd9Sstevel@tonic-gate } 13507c478bd9Sstevel@tonic-gate 13517c478bd9Sstevel@tonic-gate static const char * 13527c478bd9Sstevel@tonic-gate state_abbrev(const char *state) 13537c478bd9Sstevel@tonic-gate { 13547c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) 13557c478bd9Sstevel@tonic-gate return ("UN"); 13567c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_OFFLINE) == 0) 13577c478bd9Sstevel@tonic-gate return ("OFF"); 13587c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_ONLINE) == 0) 13597c478bd9Sstevel@tonic-gate return ("ON"); 13607c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) 13617c478bd9Sstevel@tonic-gate return ("MNT"); 13627c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DISABLED) == 0) 13637c478bd9Sstevel@tonic-gate return ("DIS"); 13647c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_DEGRADED) == 0) 13657c478bd9Sstevel@tonic-gate return ("DGD"); 13667c478bd9Sstevel@tonic-gate if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0) 13677c478bd9Sstevel@tonic-gate return ("LRC"); 13687c478bd9Sstevel@tonic-gate 13697c478bd9Sstevel@tonic-gate return ("?"); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate static void 13737c478bd9Sstevel@tonic-gate sprint_sta(char **buf, scf_walkinfo_t *wip) 13747c478bd9Sstevel@tonic-gate { 13757c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 13767c478bd9Sstevel@tonic-gate char sta[5]; 13777c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 6; 13787c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 13797c478bd9Sstevel@tonic-gate 13807c478bd9Sstevel@tonic-gate if (wip->pg == NULL) 13817c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_state, 13827c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 13837c478bd9Sstevel@tonic-gate else 13847c478bd9Sstevel@tonic-gate (void) strcpy(state_name, SCF_STATE_STRING_LEGACY); 13857c478bd9Sstevel@tonic-gate 13867c478bd9Sstevel@tonic-gate (void) strcpy(sta, state_abbrev(state_name)); 13877c478bd9Sstevel@tonic-gate 13887c478bd9Sstevel@tonic-gate if (wip->pg == NULL && !opt_nstate_shown && transitioning(wip->inst)) 13897c478bd9Sstevel@tonic-gate (void) strcat(sta, "*"); 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", sta); 13927c478bd9Sstevel@tonic-gate if (*buf) 13937c478bd9Sstevel@tonic-gate free(*buf); 13947c478bd9Sstevel@tonic-gate *buf = newbuf; 13957c478bd9Sstevel@tonic-gate } 13967c478bd9Sstevel@tonic-gate 13977c478bd9Sstevel@tonic-gate static void 13987c478bd9Sstevel@tonic-gate sprint_nsta(char **buf, scf_walkinfo_t *wip) 13997c478bd9Sstevel@tonic-gate { 14007c478bd9Sstevel@tonic-gate char state_name[MAX_SCF_STATE_STRING_SZ]; 14017c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + 6; 14027c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate if (wip->pg == NULL) 14057c478bd9Sstevel@tonic-gate get_restarter_string_prop(wip->inst, scf_property_next_state, 14067c478bd9Sstevel@tonic-gate state_name, sizeof (state_name)); 14077c478bd9Sstevel@tonic-gate else 14087c478bd9Sstevel@tonic-gate (void) strcpy(state_name, SCF_STATE_STRING_NONE); 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate if (strcmp(state_name, SCF_STATE_STRING_NONE) == 0) 14117c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", 14127c478bd9Sstevel@tonic-gate "-"); 14137c478bd9Sstevel@tonic-gate else 14147c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-4s ", *buf ? *buf : "", 14157c478bd9Sstevel@tonic-gate state_abbrev(state_name)); 14167c478bd9Sstevel@tonic-gate if (*buf) 14177c478bd9Sstevel@tonic-gate free(*buf); 14187c478bd9Sstevel@tonic-gate *buf = newbuf; 14197c478bd9Sstevel@tonic-gate } 14207c478bd9Sstevel@tonic-gate 14217c478bd9Sstevel@tonic-gate /* FMRI */ 14227c478bd9Sstevel@tonic-gate #define FMRI_COLUMN_WIDTH 50 14237c478bd9Sstevel@tonic-gate static void 14247c478bd9Sstevel@tonic-gate sprint_fmri(char **buf, scf_walkinfo_t *wip) 14257c478bd9Sstevel@tonic-gate { 14267c478bd9Sstevel@tonic-gate char *fmri_buf = safe_malloc(max_scf_fmri_length + 1); 14277c478bd9Sstevel@tonic-gate size_t newsize; 14287c478bd9Sstevel@tonic-gate char *newbuf; 14297c478bd9Sstevel@tonic-gate 14307c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 14317c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(wip->inst, fmri_buf, 14327c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1) == -1) 14337c478bd9Sstevel@tonic-gate scfdie(); 14347c478bd9Sstevel@tonic-gate } else { 14357b209c2cSacruz (void) strcpy(fmri_buf, SCF_FMRI_LEGACY_PREFIX); 14367c478bd9Sstevel@tonic-gate if (pg_get_single_val(wip->pg, SCF_LEGACY_PROPERTY_NAME, 14377b209c2cSacruz SCF_TYPE_ASTRING, fmri_buf + 14387b209c2cSacruz sizeof (SCF_FMRI_LEGACY_PREFIX) - 1, 14397b209c2cSacruz max_scf_fmri_length + 1 - 14407b209c2cSacruz (sizeof (SCF_FMRI_LEGACY_PREFIX) - 1), 0) != 0) 14417c478bd9Sstevel@tonic-gate (void) strcat(fmri_buf, LEGACY_UNKNOWN); 14427c478bd9Sstevel@tonic-gate } 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate if (strlen(fmri_buf) > FMRI_COLUMN_WIDTH) 14457c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + strlen(fmri_buf) + 2; 14467c478bd9Sstevel@tonic-gate else 14477c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + FMRI_COLUMN_WIDTH + 2; 14487c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 14497c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 14507c478bd9Sstevel@tonic-gate FMRI_COLUMN_WIDTH, fmri_buf); 14517c478bd9Sstevel@tonic-gate free(fmri_buf); 14527c478bd9Sstevel@tonic-gate if (*buf) 14537c478bd9Sstevel@tonic-gate free(*buf); 14547c478bd9Sstevel@tonic-gate *buf = newbuf; 14557c478bd9Sstevel@tonic-gate } 14567c478bd9Sstevel@tonic-gate 14577c478bd9Sstevel@tonic-gate static void 14587c478bd9Sstevel@tonic-gate sortkey_fmri(char *buf, int reverse, scf_walkinfo_t *wip) 14597c478bd9Sstevel@tonic-gate { 14607c478bd9Sstevel@tonic-gate char *tmp = NULL; 14617c478bd9Sstevel@tonic-gate 14627c478bd9Sstevel@tonic-gate sprint_fmri(&tmp, wip); 14637c478bd9Sstevel@tonic-gate bcopy(tmp, buf, FMRI_COLUMN_WIDTH); 14647c478bd9Sstevel@tonic-gate free(tmp); 14657c478bd9Sstevel@tonic-gate if (reverse) 14667c478bd9Sstevel@tonic-gate reverse_bytes(buf, FMRI_COLUMN_WIDTH); 14677c478bd9Sstevel@tonic-gate } 14687c478bd9Sstevel@tonic-gate 14697c478bd9Sstevel@tonic-gate /* Component columns */ 14707c478bd9Sstevel@tonic-gate #define COMPONENT_COLUMN_WIDTH 20 14717c478bd9Sstevel@tonic-gate static void 14727c478bd9Sstevel@tonic-gate sprint_scope(char **buf, scf_walkinfo_t *wip) 14737c478bd9Sstevel@tonic-gate { 14747c478bd9Sstevel@tonic-gate char *scope_buf = safe_malloc(max_scf_name_length + 1); 14757c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + COMPONENT_COLUMN_WIDTH + 2; 14767c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 14777c478bd9Sstevel@tonic-gate 14787c478bd9Sstevel@tonic-gate assert(wip->scope != NULL); 14797c478bd9Sstevel@tonic-gate 14807c478bd9Sstevel@tonic-gate if (scf_scope_get_name(wip->scope, scope_buf, max_scf_name_length) < 0) 14817c478bd9Sstevel@tonic-gate scfdie(); 14827c478bd9Sstevel@tonic-gate 14837c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 14847c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, scope_buf); 14857c478bd9Sstevel@tonic-gate if (*buf) 14867c478bd9Sstevel@tonic-gate free(*buf); 14877c478bd9Sstevel@tonic-gate *buf = newbuf; 14887c478bd9Sstevel@tonic-gate free(scope_buf); 14897c478bd9Sstevel@tonic-gate } 14907c478bd9Sstevel@tonic-gate 14917c478bd9Sstevel@tonic-gate static void 14927c478bd9Sstevel@tonic-gate sortkey_scope(char *buf, int reverse, scf_walkinfo_t *wip) 14937c478bd9Sstevel@tonic-gate { 14947c478bd9Sstevel@tonic-gate char *tmp = NULL; 14957c478bd9Sstevel@tonic-gate 14967c478bd9Sstevel@tonic-gate sprint_scope(&tmp, wip); 14977c478bd9Sstevel@tonic-gate bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH); 14987c478bd9Sstevel@tonic-gate free(tmp); 14997c478bd9Sstevel@tonic-gate if (reverse) 15007c478bd9Sstevel@tonic-gate reverse_bytes(buf, COMPONENT_COLUMN_WIDTH); 15017c478bd9Sstevel@tonic-gate } 15027c478bd9Sstevel@tonic-gate 15037c478bd9Sstevel@tonic-gate static void 15047c478bd9Sstevel@tonic-gate sprint_service(char **buf, scf_walkinfo_t *wip) 15057c478bd9Sstevel@tonic-gate { 15067c478bd9Sstevel@tonic-gate char *svc_buf = safe_malloc(max_scf_name_length + 1); 15077c478bd9Sstevel@tonic-gate char *newbuf; 15087c478bd9Sstevel@tonic-gate size_t newsize; 15097c478bd9Sstevel@tonic-gate 15107c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 15117c478bd9Sstevel@tonic-gate if (scf_service_get_name(wip->svc, svc_buf, 15127c478bd9Sstevel@tonic-gate max_scf_name_length + 1) < 0) 15137c478bd9Sstevel@tonic-gate scfdie(); 15147c478bd9Sstevel@tonic-gate } else { 15157c478bd9Sstevel@tonic-gate if (pg_get_single_val(wip->pg, "name", SCF_TYPE_ASTRING, 15167c478bd9Sstevel@tonic-gate svc_buf, max_scf_name_length + 1, EMPTY_OK) != 0) 15177c478bd9Sstevel@tonic-gate (void) strcpy(svc_buf, LEGACY_UNKNOWN); 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate 15207c478bd9Sstevel@tonic-gate 15217c478bd9Sstevel@tonic-gate if (strlen(svc_buf) > COMPONENT_COLUMN_WIDTH) 15227c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + strlen(svc_buf) + 2; 15237c478bd9Sstevel@tonic-gate else 15247c478bd9Sstevel@tonic-gate newsize = (*buf ? strlen(*buf) : 0) + 15257c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH + 2; 15267c478bd9Sstevel@tonic-gate newbuf = safe_malloc(newsize); 15277c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 15287c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, svc_buf); 15297c478bd9Sstevel@tonic-gate free(svc_buf); 15307c478bd9Sstevel@tonic-gate if (*buf) 15317c478bd9Sstevel@tonic-gate free(*buf); 15327c478bd9Sstevel@tonic-gate *buf = newbuf; 15337c478bd9Sstevel@tonic-gate } 15347c478bd9Sstevel@tonic-gate 15357c478bd9Sstevel@tonic-gate static void 15367c478bd9Sstevel@tonic-gate sortkey_service(char *buf, int reverse, scf_walkinfo_t *wip) 15377c478bd9Sstevel@tonic-gate { 15387c478bd9Sstevel@tonic-gate char *tmp = NULL; 15397c478bd9Sstevel@tonic-gate 15407c478bd9Sstevel@tonic-gate sprint_service(&tmp, wip); 15417c478bd9Sstevel@tonic-gate bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH); 15427c478bd9Sstevel@tonic-gate free(tmp); 15437c478bd9Sstevel@tonic-gate if (reverse) 15447c478bd9Sstevel@tonic-gate reverse_bytes(buf, COMPONENT_COLUMN_WIDTH); 15457c478bd9Sstevel@tonic-gate } 15467c478bd9Sstevel@tonic-gate 15477c478bd9Sstevel@tonic-gate /* INST */ 15487c478bd9Sstevel@tonic-gate static void 15497c478bd9Sstevel@tonic-gate sprint_instance(char **buf, scf_walkinfo_t *wip) 15507c478bd9Sstevel@tonic-gate { 15517c478bd9Sstevel@tonic-gate char *tmp = safe_malloc(max_scf_name_length + 1); 15527c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + COMPONENT_COLUMN_WIDTH + 2; 15537c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 15547c478bd9Sstevel@tonic-gate 15557c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 15567c478bd9Sstevel@tonic-gate if (scf_instance_get_name(wip->inst, tmp, 15577c478bd9Sstevel@tonic-gate max_scf_name_length + 1) < 0) 15587c478bd9Sstevel@tonic-gate scfdie(); 15597c478bd9Sstevel@tonic-gate } else { 15607c478bd9Sstevel@tonic-gate tmp[0] = '-'; 15617c478bd9Sstevel@tonic-gate tmp[1] = '\0'; 15627c478bd9Sstevel@tonic-gate } 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 15657c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, tmp); 15667c478bd9Sstevel@tonic-gate if (*buf) 15677c478bd9Sstevel@tonic-gate free(*buf); 15687c478bd9Sstevel@tonic-gate *buf = newbuf; 15697c478bd9Sstevel@tonic-gate free(tmp); 15707c478bd9Sstevel@tonic-gate } 15717c478bd9Sstevel@tonic-gate 15727c478bd9Sstevel@tonic-gate static void 15737c478bd9Sstevel@tonic-gate sortkey_instance(char *buf, int reverse, scf_walkinfo_t *wip) 15747c478bd9Sstevel@tonic-gate { 15757c478bd9Sstevel@tonic-gate char *tmp = NULL; 15767c478bd9Sstevel@tonic-gate 15777c478bd9Sstevel@tonic-gate sprint_instance(&tmp, wip); 15787c478bd9Sstevel@tonic-gate bcopy(tmp, buf, COMPONENT_COLUMN_WIDTH); 15797c478bd9Sstevel@tonic-gate free(tmp); 15807c478bd9Sstevel@tonic-gate if (reverse) 15817c478bd9Sstevel@tonic-gate reverse_bytes(buf, COMPONENT_COLUMN_WIDTH); 15827c478bd9Sstevel@tonic-gate } 15837c478bd9Sstevel@tonic-gate 15847c478bd9Sstevel@tonic-gate /* STIME */ 15857c478bd9Sstevel@tonic-gate #define STIME_COLUMN_WIDTH 8 15867c478bd9Sstevel@tonic-gate #define FORMAT_TIME "%k:%M:%S" 15877c478bd9Sstevel@tonic-gate #define FORMAT_DATE "%b_%d " 15887c478bd9Sstevel@tonic-gate #define FORMAT_YEAR "%Y " 15897c478bd9Sstevel@tonic-gate 159061402014Slianep /* 159161402014Slianep * sprint_stime() will allocate a new buffer and snprintf the services's 159261402014Slianep * state timestamp. If the timestamp is unavailable for some reason 159361402014Slianep * a '-' is given instead. 159461402014Slianep */ 15957c478bd9Sstevel@tonic-gate static void 15967c478bd9Sstevel@tonic-gate sprint_stime(char **buf, scf_walkinfo_t *wip) 15977c478bd9Sstevel@tonic-gate { 15987c478bd9Sstevel@tonic-gate int r; 15997c478bd9Sstevel@tonic-gate struct timeval tv; 16007c478bd9Sstevel@tonic-gate time_t then; 16017c478bd9Sstevel@tonic-gate struct tm *tm; 16027c478bd9Sstevel@tonic-gate char st_buf[STIME_COLUMN_WIDTH + 1]; 16037c478bd9Sstevel@tonic-gate size_t newsize = (*buf ? strlen(*buf) : 0) + STIME_COLUMN_WIDTH + 2; 16047c478bd9Sstevel@tonic-gate char *newbuf = safe_malloc(newsize); 16057c478bd9Sstevel@tonic-gate 16067c478bd9Sstevel@tonic-gate if (wip->pg == NULL) { 16077c478bd9Sstevel@tonic-gate r = get_restarter_time_prop(wip->inst, 16087c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE_TIMESTAMP, &tv, 0); 16097c478bd9Sstevel@tonic-gate } else { 16107c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, SCF_PROPERTY_STATE_TIMESTAMP, 16117c478bd9Sstevel@tonic-gate SCF_TYPE_TIME, &tv, NULL, 0); 16127c478bd9Sstevel@tonic-gate } 16137c478bd9Sstevel@tonic-gate 16147c478bd9Sstevel@tonic-gate if (r != 0) { 161561402014Slianep /* 161661402014Slianep * There's something amiss with our service 161761402014Slianep * so we'll print a '-' for STIME. 161861402014Slianep */ 16197c478bd9Sstevel@tonic-gate (void) snprintf(newbuf, newsize, "%s%-*s", *buf ? *buf : "", 162061402014Slianep STIME_COLUMN_WIDTH + 1, "-"); 162161402014Slianep } else { 162261402014Slianep /* tv should be valid so we'll format it */ 162361402014Slianep then = (time_t)tv.tv_sec; 16247c478bd9Sstevel@tonic-gate 162561402014Slianep tm = localtime(&then); 162661402014Slianep /* 162761402014Slianep * Print time if started within the past 24 hours, print date 162861402014Slianep * if within the past 12 months or, finally, print year if 162961402014Slianep * started greater than 12 months ago. 163061402014Slianep */ 163161402014Slianep if (now - then < 24 * 60 * 60) { 163261402014Slianep (void) strftime(st_buf, sizeof (st_buf), 163361402014Slianep gettext(FORMAT_TIME), tm); 163461402014Slianep } else if (now - then < 12 * 30 * 24 * 60 * 60) { 163561402014Slianep (void) strftime(st_buf, sizeof (st_buf), 163661402014Slianep gettext(FORMAT_DATE), tm); 163761402014Slianep } else { 163861402014Slianep (void) strftime(st_buf, sizeof (st_buf), 163961402014Slianep gettext(FORMAT_YEAR), tm); 164061402014Slianep } 164161402014Slianep (void) snprintf(newbuf, newsize, "%s%-*s ", *buf ? *buf : "", 164261402014Slianep STIME_COLUMN_WIDTH + 1, st_buf); 164361402014Slianep } 16447c478bd9Sstevel@tonic-gate if (*buf) 16457c478bd9Sstevel@tonic-gate free(*buf); 16467c478bd9Sstevel@tonic-gate *buf = newbuf; 16477c478bd9Sstevel@tonic-gate } 16487c478bd9Sstevel@tonic-gate 16497c478bd9Sstevel@tonic-gate #define STIME_SORTKEY_WIDTH (sizeof (uint64_t) + sizeof (uint32_t)) 16507c478bd9Sstevel@tonic-gate 16517c478bd9Sstevel@tonic-gate /* ARGSUSED */ 16527c478bd9Sstevel@tonic-gate static void 16537c478bd9Sstevel@tonic-gate sortkey_stime(char *buf, int reverse, scf_walkinfo_t *wip) 16547c478bd9Sstevel@tonic-gate { 16557c478bd9Sstevel@tonic-gate struct timeval tv; 16567c478bd9Sstevel@tonic-gate int r; 16577c478bd9Sstevel@tonic-gate 16587c478bd9Sstevel@tonic-gate if (wip->pg == NULL) 16597c478bd9Sstevel@tonic-gate r = get_restarter_time_prop(wip->inst, 16607c478bd9Sstevel@tonic-gate SCF_PROPERTY_STATE_TIMESTAMP, &tv, 0); 16617c478bd9Sstevel@tonic-gate else 16627c478bd9Sstevel@tonic-gate r = pg_get_single_val(wip->pg, SCF_PROPERTY_STATE_TIMESTAMP, 16637c478bd9Sstevel@tonic-gate SCF_TYPE_TIME, &tv, NULL, 0); 16647c478bd9Sstevel@tonic-gate 16657c478bd9Sstevel@tonic-gate if (r == 0) { 16667c478bd9Sstevel@tonic-gate int64_t sec; 16677c478bd9Sstevel@tonic-gate int32_t us; 16687c478bd9Sstevel@tonic-gate 16697c478bd9Sstevel@tonic-gate /* Stick it straight into the buffer. */ 16707c478bd9Sstevel@tonic-gate sec = tv.tv_sec; 16717c478bd9Sstevel@tonic-gate us = tv.tv_usec; 16727c478bd9Sstevel@tonic-gate 16737c478bd9Sstevel@tonic-gate sec = BE_64(sec); 16747c478bd9Sstevel@tonic-gate us = BE_32(us); 16757c478bd9Sstevel@tonic-gate bcopy(&sec, buf, sizeof (sec)); 16767c478bd9Sstevel@tonic-gate bcopy(&us, buf + sizeof (sec), sizeof (us)); 16777c478bd9Sstevel@tonic-gate } else { 16787c478bd9Sstevel@tonic-gate bzero(buf, STIME_SORTKEY_WIDTH); 16797c478bd9Sstevel@tonic-gate } 16807c478bd9Sstevel@tonic-gate 16817c478bd9Sstevel@tonic-gate if (reverse) 16827c478bd9Sstevel@tonic-gate reverse_bytes(buf, STIME_SORTKEY_WIDTH); 16837c478bd9Sstevel@tonic-gate } 16847c478bd9Sstevel@tonic-gate 16857c478bd9Sstevel@tonic-gate 16867c478bd9Sstevel@tonic-gate /* 16877c478bd9Sstevel@tonic-gate * Information about columns which can be displayed. If you add something, 16887c478bd9Sstevel@tonic-gate * check MAX_COLUMN_NAME_LENGTH_STR & update description_of_column() below. 16897c478bd9Sstevel@tonic-gate */ 16907c478bd9Sstevel@tonic-gate static const struct column columns[] = { 16917c478bd9Sstevel@tonic-gate { "CTID", CTID_COLUMN_WIDTH, sprint_ctid, 16927c478bd9Sstevel@tonic-gate CTID_SORTKEY_WIDTH, sortkey_ctid }, 16937c478bd9Sstevel@tonic-gate { "DESC", DESC_COLUMN_WIDTH, sprint_desc, 16947c478bd9Sstevel@tonic-gate DESC_COLUMN_WIDTH, sortkey_desc }, 16957c478bd9Sstevel@tonic-gate { "FMRI", FMRI_COLUMN_WIDTH, sprint_fmri, 16967c478bd9Sstevel@tonic-gate FMRI_COLUMN_WIDTH, sortkey_fmri }, 16977c478bd9Sstevel@tonic-gate { "INST", COMPONENT_COLUMN_WIDTH, sprint_instance, 16987c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, sortkey_instance }, 16997c478bd9Sstevel@tonic-gate { "N", 1, sprint_n, 1, sortkey_nstate }, 17007c478bd9Sstevel@tonic-gate { "NSTA", 4, sprint_nsta, 1, sortkey_nstate }, 17017c478bd9Sstevel@tonic-gate { "NSTATE", MAX_SCF_STATE_STRING_SZ - 1, sprint_nstate, 17027c478bd9Sstevel@tonic-gate 1, sortkey_nstate }, 17037c478bd9Sstevel@tonic-gate { "S", 2, sprint_s, 1, sortkey_state }, 17047c478bd9Sstevel@tonic-gate { "SCOPE", COMPONENT_COLUMN_WIDTH, sprint_scope, 17057c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, sortkey_scope }, 17067c478bd9Sstevel@tonic-gate { "SN", 2, sprint_sn, 2, sortkey_sn }, 17077c478bd9Sstevel@tonic-gate { "SVC", COMPONENT_COLUMN_WIDTH, sprint_service, 17087c478bd9Sstevel@tonic-gate COMPONENT_COLUMN_WIDTH, sortkey_service }, 17097c478bd9Sstevel@tonic-gate { "STA", 4, sprint_sta, 1, sortkey_state }, 17107c478bd9Sstevel@tonic-gate { "STATE", MAX_SCF_STATE_STRING_SZ - 1 + 1, sprint_state, 17117c478bd9Sstevel@tonic-gate 1, sortkey_state }, 17127c478bd9Sstevel@tonic-gate { "STIME", STIME_COLUMN_WIDTH, sprint_stime, 17137c478bd9Sstevel@tonic-gate STIME_SORTKEY_WIDTH, sortkey_stime }, 17147c478bd9Sstevel@tonic-gate }; 17157c478bd9Sstevel@tonic-gate 17167c478bd9Sstevel@tonic-gate #define MAX_COLUMN_NAME_LENGTH_STR "6" 17177c478bd9Sstevel@tonic-gate 17187c478bd9Sstevel@tonic-gate static const int ncolumns = sizeof (columns) / sizeof (columns[0]); 17197c478bd9Sstevel@tonic-gate 17207c478bd9Sstevel@tonic-gate /* 17217c478bd9Sstevel@tonic-gate * Necessary thanks to gettext() & xgettext. 17227c478bd9Sstevel@tonic-gate */ 17237c478bd9Sstevel@tonic-gate static const char * 17247c478bd9Sstevel@tonic-gate description_of_column(int c) 17257c478bd9Sstevel@tonic-gate { 17267c478bd9Sstevel@tonic-gate const char *s = NULL; 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate switch (c) { 17297c478bd9Sstevel@tonic-gate case 0: 17307c478bd9Sstevel@tonic-gate s = gettext("contract ID for service (see contract(4))"); 17317c478bd9Sstevel@tonic-gate break; 17327c478bd9Sstevel@tonic-gate case 1: 17337c478bd9Sstevel@tonic-gate s = gettext("human-readable description of the service"); 17347c478bd9Sstevel@tonic-gate break; 17357c478bd9Sstevel@tonic-gate case 2: 17367c478bd9Sstevel@tonic-gate s = gettext("Fault Managed Resource Identifier for service"); 17377c478bd9Sstevel@tonic-gate break; 17387c478bd9Sstevel@tonic-gate case 3: 17397c478bd9Sstevel@tonic-gate s = gettext("portion of the FMRI indicating service instance"); 17407c478bd9Sstevel@tonic-gate break; 17417c478bd9Sstevel@tonic-gate case 4: 17427c478bd9Sstevel@tonic-gate s = gettext("abbreviation for next state (if in transition)"); 17437c478bd9Sstevel@tonic-gate break; 17447c478bd9Sstevel@tonic-gate case 5: 17457c478bd9Sstevel@tonic-gate s = gettext("abbreviation for next state (if in transition)"); 17467c478bd9Sstevel@tonic-gate break; 17477c478bd9Sstevel@tonic-gate case 6: 17487c478bd9Sstevel@tonic-gate s = gettext("name for next state (if in transition)"); 17497c478bd9Sstevel@tonic-gate break; 17507c478bd9Sstevel@tonic-gate case 7: 17517c478bd9Sstevel@tonic-gate s = gettext("abbreviation for current state"); 17527c478bd9Sstevel@tonic-gate break; 17537c478bd9Sstevel@tonic-gate case 8: 17547c478bd9Sstevel@tonic-gate s = gettext("name for scope associated with service"); 17557c478bd9Sstevel@tonic-gate break; 17567c478bd9Sstevel@tonic-gate case 9: 17577c478bd9Sstevel@tonic-gate s = gettext("abbreviation for current state and next state"); 17587c478bd9Sstevel@tonic-gate break; 17597c478bd9Sstevel@tonic-gate case 10: 17607c478bd9Sstevel@tonic-gate s = gettext("portion of the FMRI representing service name"); 17617c478bd9Sstevel@tonic-gate break; 17627c478bd9Sstevel@tonic-gate case 11: 17637c478bd9Sstevel@tonic-gate s = gettext("abbreviation for current state"); 17647c478bd9Sstevel@tonic-gate break; 17657c478bd9Sstevel@tonic-gate case 12: 17667c478bd9Sstevel@tonic-gate s = gettext("name for current state"); 17677c478bd9Sstevel@tonic-gate break; 17687c478bd9Sstevel@tonic-gate case 13: 17697c478bd9Sstevel@tonic-gate s = gettext("time of last state change"); 17707c478bd9Sstevel@tonic-gate break; 17717c478bd9Sstevel@tonic-gate } 17727c478bd9Sstevel@tonic-gate 17737c478bd9Sstevel@tonic-gate assert(s != NULL); 17747c478bd9Sstevel@tonic-gate return (s); 17757c478bd9Sstevel@tonic-gate } 17767c478bd9Sstevel@tonic-gate 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate static void 17797c478bd9Sstevel@tonic-gate print_usage(const char *progname, FILE *f, boolean_t do_exit) 17807c478bd9Sstevel@tonic-gate { 17817c478bd9Sstevel@tonic-gate (void) fprintf(f, gettext( 17827c478bd9Sstevel@tonic-gate "Usage: %1$s [-aHpv] [-o col[,col ... ]] [-R restarter] " 17837c478bd9Sstevel@tonic-gate "[-sS col] [<service> ...]\n" 17847c478bd9Sstevel@tonic-gate " %1$s -d | -D [-Hpv] [-o col[,col ... ]] [-sS col] " 17857c478bd9Sstevel@tonic-gate "[<service> ...]\n" 17867c478bd9Sstevel@tonic-gate " %1$s -l <service> ...\n" 17877c478bd9Sstevel@tonic-gate " %1$s -x [-v] [<service> ...]\n" 17887c478bd9Sstevel@tonic-gate " %1$s -?\n"), progname); 17897c478bd9Sstevel@tonic-gate 17907c478bd9Sstevel@tonic-gate if (do_exit) 17917c478bd9Sstevel@tonic-gate exit(UU_EXIT_USAGE); 17927c478bd9Sstevel@tonic-gate } 17937c478bd9Sstevel@tonic-gate 17947c478bd9Sstevel@tonic-gate #define argserr(progname) print_usage(progname, stderr, B_TRUE) 17957c478bd9Sstevel@tonic-gate 17967c478bd9Sstevel@tonic-gate static void 17977c478bd9Sstevel@tonic-gate print_help(const char *progname) 17987c478bd9Sstevel@tonic-gate { 17997c478bd9Sstevel@tonic-gate int i; 18007c478bd9Sstevel@tonic-gate 18017c478bd9Sstevel@tonic-gate print_usage(progname, stdout, B_FALSE); 18027c478bd9Sstevel@tonic-gate 18037c478bd9Sstevel@tonic-gate (void) printf(gettext("\n" 18047c478bd9Sstevel@tonic-gate "\t-a list all service instances rather than " 18057c478bd9Sstevel@tonic-gate "only those that are enabled\n" 18067c478bd9Sstevel@tonic-gate "\t-d list dependencies of the specified service(s)\n" 18077c478bd9Sstevel@tonic-gate "\t-D list dependents of the specified service(s)\n" 18087c478bd9Sstevel@tonic-gate "\t-H omit header line from output\n" 18097c478bd9Sstevel@tonic-gate "\t-l list detailed information about the specified service(s)\n" 18107c478bd9Sstevel@tonic-gate "\t-o list only the specified columns in the output\n" 18117c478bd9Sstevel@tonic-gate "\t-p list process IDs and names associated with each service\n" 18127c478bd9Sstevel@tonic-gate "\t-R list only those services with the specified restarter\n" 18137c478bd9Sstevel@tonic-gate "\t-s sort output in ascending order by the specified column(s)\n" 18147c478bd9Sstevel@tonic-gate "\t-S sort output in descending order by the specified column(s)\n" 18157c478bd9Sstevel@tonic-gate "\t-v list verbose information appropriate to the type of output\n" 18167c478bd9Sstevel@tonic-gate "\t-x explain the status of services that might require maintenance,\n" 18177c478bd9Sstevel@tonic-gate "\t or explain the status of the specified service(s)\n" 18187c478bd9Sstevel@tonic-gate "\n\t" 18197c478bd9Sstevel@tonic-gate "Services can be specified using an FMRI, abbreviation, or fnmatch(5)\n" 18207c478bd9Sstevel@tonic-gate "\tpattern, as shown in these examples for svc:/network/smtp:sendmail\n" 18217c478bd9Sstevel@tonic-gate "\n" 18227c478bd9Sstevel@tonic-gate "\t%1$s [opts] svc:/network/smtp:sendmail\n" 18237c478bd9Sstevel@tonic-gate "\t%1$s [opts] network/smtp:sendmail\n" 18247c478bd9Sstevel@tonic-gate "\t%1$s [opts] network/*mail\n" 18257c478bd9Sstevel@tonic-gate "\t%1$s [opts] network/smtp\n" 18267c478bd9Sstevel@tonic-gate "\t%1$s [opts] smtp:sendmail\n" 18277c478bd9Sstevel@tonic-gate "\t%1$s [opts] smtp\n" 18287c478bd9Sstevel@tonic-gate "\t%1$s [opts] sendmail\n" 18297c478bd9Sstevel@tonic-gate "\n\t" 18307c478bd9Sstevel@tonic-gate "Columns for output or sorting can be specified using these names:\n" 18317c478bd9Sstevel@tonic-gate "\n"), progname); 18327c478bd9Sstevel@tonic-gate 18337c478bd9Sstevel@tonic-gate for (i = 0; i < ncolumns; i++) { 18347c478bd9Sstevel@tonic-gate (void) printf("\t%-" MAX_COLUMN_NAME_LENGTH_STR "s %s\n", 18357c478bd9Sstevel@tonic-gate columns[i].name, description_of_column(i)); 18367c478bd9Sstevel@tonic-gate } 18377c478bd9Sstevel@tonic-gate } 18387c478bd9Sstevel@tonic-gate 18397c478bd9Sstevel@tonic-gate 18407c478bd9Sstevel@tonic-gate /* 18417c478bd9Sstevel@tonic-gate * A getsubopt()-like function which returns an index into the columns table. 18427c478bd9Sstevel@tonic-gate * On success, *optionp is set to point to the next sub-option, or the 18437c478bd9Sstevel@tonic-gate * terminating null if there are none. 18447c478bd9Sstevel@tonic-gate */ 18457c478bd9Sstevel@tonic-gate static int 18467c478bd9Sstevel@tonic-gate getcolumnopt(char **optionp) 18477c478bd9Sstevel@tonic-gate { 18487c478bd9Sstevel@tonic-gate char *str = *optionp, *cp; 18497c478bd9Sstevel@tonic-gate int i; 18507c478bd9Sstevel@tonic-gate 18517c478bd9Sstevel@tonic-gate assert(optionp != NULL); 18527c478bd9Sstevel@tonic-gate assert(*optionp != NULL); 18537c478bd9Sstevel@tonic-gate 18547c478bd9Sstevel@tonic-gate cp = strchr(*optionp, ','); 18557c478bd9Sstevel@tonic-gate if (cp != NULL) 18567c478bd9Sstevel@tonic-gate *cp = '\0'; 18577c478bd9Sstevel@tonic-gate 18587c478bd9Sstevel@tonic-gate for (i = 0; i < ncolumns; ++i) { 18597c478bd9Sstevel@tonic-gate if (strcasecmp(str, columns[i].name) == 0) { 18607c478bd9Sstevel@tonic-gate if (cp != NULL) 18617c478bd9Sstevel@tonic-gate *optionp = cp + 1; 18627c478bd9Sstevel@tonic-gate else 18637c478bd9Sstevel@tonic-gate *optionp = strchr(*optionp, '\0'); 18647c478bd9Sstevel@tonic-gate 18657c478bd9Sstevel@tonic-gate return (i); 18667c478bd9Sstevel@tonic-gate } 18677c478bd9Sstevel@tonic-gate } 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate return (-1); 18707c478bd9Sstevel@tonic-gate } 18717c478bd9Sstevel@tonic-gate 18727c478bd9Sstevel@tonic-gate static void 18737c478bd9Sstevel@tonic-gate print_header() 18747c478bd9Sstevel@tonic-gate { 18757c478bd9Sstevel@tonic-gate int i; 18767c478bd9Sstevel@tonic-gate char *line_buf, *cp; 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate line_buf = safe_malloc(line_sz); 18797c478bd9Sstevel@tonic-gate cp = line_buf; 18807c478bd9Sstevel@tonic-gate for (i = 0; i < opt_cnum; ++i) { 18817c478bd9Sstevel@tonic-gate const struct column * const colp = &columns[opt_columns[i]]; 18827c478bd9Sstevel@tonic-gate 18837c478bd9Sstevel@tonic-gate (void) snprintf(cp, colp->width + 1, "%-*s", colp->width, 18847c478bd9Sstevel@tonic-gate colp->name); 18857c478bd9Sstevel@tonic-gate cp += colp->width; 18867c478bd9Sstevel@tonic-gate *cp++ = ' '; 18877c478bd9Sstevel@tonic-gate } 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate /* Trim the trailing whitespace */ 18907c478bd9Sstevel@tonic-gate --cp; 18917c478bd9Sstevel@tonic-gate while (*cp == ' ') 18927c478bd9Sstevel@tonic-gate --cp; 18937c478bd9Sstevel@tonic-gate *(cp+1) = '\0'; 18947c478bd9Sstevel@tonic-gate (void) puts(line_buf); 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate free(line_buf); 18977c478bd9Sstevel@tonic-gate } 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate 19007c478bd9Sstevel@tonic-gate 19017c478bd9Sstevel@tonic-gate /* 19027c478bd9Sstevel@tonic-gate * Long listing (-l) functions. 19037c478bd9Sstevel@tonic-gate */ 19047c478bd9Sstevel@tonic-gate 19057c478bd9Sstevel@tonic-gate static int 19067c478bd9Sstevel@tonic-gate pidcmp(const void *l, const void *r) 19077c478bd9Sstevel@tonic-gate { 19087c478bd9Sstevel@tonic-gate pid_t lp = *(pid_t *)l, rp = *(pid_t *)r; 19097c478bd9Sstevel@tonic-gate 19107c478bd9Sstevel@tonic-gate if (lp < rp) 19117c478bd9Sstevel@tonic-gate return (-1); 19127c478bd9Sstevel@tonic-gate if (lp > rp) 19137c478bd9Sstevel@tonic-gate return (1); 19147c478bd9Sstevel@tonic-gate return (0); 19157c478bd9Sstevel@tonic-gate } 19167c478bd9Sstevel@tonic-gate 19177c478bd9Sstevel@tonic-gate /* 19187c478bd9Sstevel@tonic-gate * This is the strlen() of the longest label ("description"), plus intercolumn 19197c478bd9Sstevel@tonic-gate * space. 19207c478bd9Sstevel@tonic-gate */ 19217c478bd9Sstevel@tonic-gate #define DETAILED_WIDTH (11 + 2) 19227c478bd9Sstevel@tonic-gate 192394501b61Sskamm /* 192494501b61Sskamm * Callback routine to print header for contract id. 192594501b61Sskamm * Called by ctids_by_restarter and print_detailed. 192694501b61Sskamm */ 192794501b61Sskamm static void 192894501b61Sskamm print_ctid_header() 192994501b61Sskamm { 193094501b61Sskamm (void) printf("%-*s", DETAILED_WIDTH, "contract_id"); 193194501b61Sskamm } 193294501b61Sskamm 193394501b61Sskamm /* 193494501b61Sskamm * Callback routine to print a contract id. 193594501b61Sskamm * Called by ctids_by_restarter and print_detailed. 193694501b61Sskamm */ 193794501b61Sskamm static void 193894501b61Sskamm print_ctid_detailed(uint64_t c) 193994501b61Sskamm { 194094501b61Sskamm (void) printf("%lu ", (ctid_t)c); 194194501b61Sskamm } 194294501b61Sskamm 19437c478bd9Sstevel@tonic-gate static void 194494501b61Sskamm detailed_list_processes(scf_walkinfo_t *wip) 19457c478bd9Sstevel@tonic-gate { 19467c478bd9Sstevel@tonic-gate uint64_t c; 19477c478bd9Sstevel@tonic-gate pid_t *pids; 19487c478bd9Sstevel@tonic-gate uint_t i, n; 19497c478bd9Sstevel@tonic-gate psinfo_t psi; 19507c478bd9Sstevel@tonic-gate 195194501b61Sskamm if (get_restarter_count_prop(wip->inst, scf_property_contract, &c, 19527c478bd9Sstevel@tonic-gate EMPTY_OK) != 0) 19537c478bd9Sstevel@tonic-gate return; 19547c478bd9Sstevel@tonic-gate 195594501b61Sskamm if (instance_processes(wip->inst, wip->fmri, &pids, &n) != 0) 19567c478bd9Sstevel@tonic-gate return; 19577c478bd9Sstevel@tonic-gate 19587c478bd9Sstevel@tonic-gate qsort(pids, n, sizeof (*pids), pidcmp); 19597c478bd9Sstevel@tonic-gate 19607c478bd9Sstevel@tonic-gate for (i = 0; i < n; ++i) { 19617c478bd9Sstevel@tonic-gate (void) printf("%-*s%lu", DETAILED_WIDTH, gettext("process"), 19627c478bd9Sstevel@tonic-gate pids[i]); 19637c478bd9Sstevel@tonic-gate 19647c478bd9Sstevel@tonic-gate if (get_psinfo(pids[i], &psi) == 0) 19657c478bd9Sstevel@tonic-gate (void) printf(" %.*s", PRARGSZ, psi.pr_psargs); 19667c478bd9Sstevel@tonic-gate 19677c478bd9Sstevel@tonic-gate (void) putchar('\n'); 19687c478bd9Sstevel@tonic-gate } 19697c478bd9Sstevel@tonic-gate 19707c478bd9Sstevel@tonic-gate free(pids); 19717c478bd9Sstevel@tonic-gate } 19727c478bd9Sstevel@tonic-gate 19737c478bd9Sstevel@tonic-gate /* 19747c478bd9Sstevel@tonic-gate * Determines the state of a dependency. If the FMRI specifies a file, then we 19757c478bd9Sstevel@tonic-gate * fake up a state based on whether we can access the file. 19767c478bd9Sstevel@tonic-gate */ 19777c478bd9Sstevel@tonic-gate static void 19787c478bd9Sstevel@tonic-gate get_fmri_state(char *fmri, char *state, size_t state_sz) 19797c478bd9Sstevel@tonic-gate { 19807c478bd9Sstevel@tonic-gate char *lfmri; 19817c478bd9Sstevel@tonic-gate const char *svc_name, *inst_name, *pg_name, *path; 19827c478bd9Sstevel@tonic-gate scf_service_t *svc; 19837c478bd9Sstevel@tonic-gate scf_instance_t *inst; 19847c478bd9Sstevel@tonic-gate scf_iter_t *iter; 19857c478bd9Sstevel@tonic-gate 19867c478bd9Sstevel@tonic-gate lfmri = safe_strdup(fmri); 19877c478bd9Sstevel@tonic-gate 19887c478bd9Sstevel@tonic-gate /* 19897c478bd9Sstevel@tonic-gate * Check for file:// dependencies 19907c478bd9Sstevel@tonic-gate */ 19917c478bd9Sstevel@tonic-gate if (scf_parse_file_fmri(lfmri, NULL, &path) == SCF_SUCCESS) { 19927c478bd9Sstevel@tonic-gate struct stat64 statbuf; 19937c478bd9Sstevel@tonic-gate const char *msg; 19947c478bd9Sstevel@tonic-gate 19957c478bd9Sstevel@tonic-gate if (stat64(path, &statbuf) == 0) 19967c478bd9Sstevel@tonic-gate msg = "online"; 19977c478bd9Sstevel@tonic-gate else if (errno == ENOENT) 19987c478bd9Sstevel@tonic-gate msg = "absent"; 19997c478bd9Sstevel@tonic-gate else 20007c478bd9Sstevel@tonic-gate msg = "unknown"; 20017c478bd9Sstevel@tonic-gate 20027c478bd9Sstevel@tonic-gate (void) strlcpy(state, msg, state_sz); 20037c478bd9Sstevel@tonic-gate return; 20047c478bd9Sstevel@tonic-gate } 20057c478bd9Sstevel@tonic-gate 20067c478bd9Sstevel@tonic-gate /* 20077c478bd9Sstevel@tonic-gate * scf_parse_file_fmri() may have overwritten part of the string, so 20087c478bd9Sstevel@tonic-gate * copy it back. 20097c478bd9Sstevel@tonic-gate */ 20107c478bd9Sstevel@tonic-gate (void) strcpy(lfmri, fmri); 20117c478bd9Sstevel@tonic-gate 20127c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(lfmri, NULL, &svc_name, &inst_name, 20137c478bd9Sstevel@tonic-gate &pg_name, NULL) != SCF_SUCCESS) { 20147c478bd9Sstevel@tonic-gate free(lfmri); 20157c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20167c478bd9Sstevel@tonic-gate return; 20177c478bd9Sstevel@tonic-gate } 20187c478bd9Sstevel@tonic-gate 20197c478bd9Sstevel@tonic-gate free(lfmri); 20207c478bd9Sstevel@tonic-gate 20217c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 20227c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20237c478bd9Sstevel@tonic-gate return; 20247c478bd9Sstevel@tonic-gate } 20257c478bd9Sstevel@tonic-gate 20267c478bd9Sstevel@tonic-gate if (inst_name != NULL) { 20277c478bd9Sstevel@tonic-gate /* instance: get state */ 20287c478bd9Sstevel@tonic-gate inst = scf_instance_create(h); 20297c478bd9Sstevel@tonic-gate if (inst == NULL) 20307c478bd9Sstevel@tonic-gate scfdie(); 20317c478bd9Sstevel@tonic-gate 20327c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst, NULL, 20337c478bd9Sstevel@tonic-gate NULL, SCF_DECODE_FMRI_EXACT) == SCF_SUCCESS) 20347c478bd9Sstevel@tonic-gate get_restarter_string_prop(inst, scf_property_state, 20357c478bd9Sstevel@tonic-gate state, state_sz); 20367c478bd9Sstevel@tonic-gate else { 20377c478bd9Sstevel@tonic-gate switch (scf_error()) { 20387c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT: 20397c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20407c478bd9Sstevel@tonic-gate break; 20417c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 20427c478bd9Sstevel@tonic-gate (void) strlcpy(state, "absent", state_sz); 20437c478bd9Sstevel@tonic-gate break; 20447c478bd9Sstevel@tonic-gate 20457c478bd9Sstevel@tonic-gate default: 20467c478bd9Sstevel@tonic-gate scfdie(); 20477c478bd9Sstevel@tonic-gate } 20487c478bd9Sstevel@tonic-gate } 20497c478bd9Sstevel@tonic-gate 20507c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 20517c478bd9Sstevel@tonic-gate return; 20527c478bd9Sstevel@tonic-gate } 20537c478bd9Sstevel@tonic-gate 20547c478bd9Sstevel@tonic-gate /* 20557c478bd9Sstevel@tonic-gate * service: If only one instance, use that state. Otherwise, say 20567c478bd9Sstevel@tonic-gate * "multiple". 20577c478bd9Sstevel@tonic-gate */ 20587c478bd9Sstevel@tonic-gate if ((svc = scf_service_create(h)) == NULL || 20597c478bd9Sstevel@tonic-gate (inst = scf_instance_create(h)) == NULL || 20607c478bd9Sstevel@tonic-gate (iter = scf_iter_create(h)) == NULL) 20617c478bd9Sstevel@tonic-gate scfdie(); 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, fmri, NULL, svc, NULL, NULL, NULL, 20647c478bd9Sstevel@tonic-gate SCF_DECODE_FMRI_EXACT) != SCF_SUCCESS) { 20657c478bd9Sstevel@tonic-gate switch (scf_error()) { 20667c478bd9Sstevel@tonic-gate case SCF_ERROR_INVALID_ARGUMENT: 20677c478bd9Sstevel@tonic-gate (void) strlcpy(state, "invalid", state_sz); 20687c478bd9Sstevel@tonic-gate goto out; 20697c478bd9Sstevel@tonic-gate case SCF_ERROR_NOT_FOUND: 20707c478bd9Sstevel@tonic-gate (void) strlcpy(state, "absent", state_sz); 20717c478bd9Sstevel@tonic-gate goto out; 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate default: 20747c478bd9Sstevel@tonic-gate scfdie(); 20757c478bd9Sstevel@tonic-gate } 20767c478bd9Sstevel@tonic-gate } 20777c478bd9Sstevel@tonic-gate 20787c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(iter, svc) != SCF_SUCCESS) 20797c478bd9Sstevel@tonic-gate scfdie(); 20807c478bd9Sstevel@tonic-gate 20817c478bd9Sstevel@tonic-gate switch (scf_iter_next_instance(iter, inst)) { 20827c478bd9Sstevel@tonic-gate case 0: 20837c478bd9Sstevel@tonic-gate (void) strlcpy(state, "absent", state_sz); 20847c478bd9Sstevel@tonic-gate goto out; 20857c478bd9Sstevel@tonic-gate 20867c478bd9Sstevel@tonic-gate case 1: 20877c478bd9Sstevel@tonic-gate break; 20887c478bd9Sstevel@tonic-gate 20897c478bd9Sstevel@tonic-gate default: 20907c478bd9Sstevel@tonic-gate scfdie(); 20917c478bd9Sstevel@tonic-gate } 20927c478bd9Sstevel@tonic-gate 20937c478bd9Sstevel@tonic-gate /* Get the state in case this is the only instance. */ 20947c478bd9Sstevel@tonic-gate get_restarter_string_prop(inst, scf_property_state, state, state_sz); 20957c478bd9Sstevel@tonic-gate 20967c478bd9Sstevel@tonic-gate switch (scf_iter_next_instance(iter, inst)) { 20977c478bd9Sstevel@tonic-gate case 0: 20987c478bd9Sstevel@tonic-gate break; 20997c478bd9Sstevel@tonic-gate 21007c478bd9Sstevel@tonic-gate case 1: 21017c478bd9Sstevel@tonic-gate /* Nope, multiple instances. */ 21027c478bd9Sstevel@tonic-gate (void) strlcpy(state, "multiple", state_sz); 21037c478bd9Sstevel@tonic-gate goto out; 21047c478bd9Sstevel@tonic-gate 21057c478bd9Sstevel@tonic-gate default: 21067c478bd9Sstevel@tonic-gate scfdie(); 21077c478bd9Sstevel@tonic-gate } 21087c478bd9Sstevel@tonic-gate 21097c478bd9Sstevel@tonic-gate out: 21107c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 21117c478bd9Sstevel@tonic-gate scf_instance_destroy(inst); 21127c478bd9Sstevel@tonic-gate scf_service_destroy(svc); 21137c478bd9Sstevel@tonic-gate } 21147c478bd9Sstevel@tonic-gate 2115*1f6eb021SLiane Praza static void 2116*1f6eb021SLiane Praza print_application_properties(scf_walkinfo_t *wip, scf_snapshot_t *snap) 2117*1f6eb021SLiane Praza { 2118*1f6eb021SLiane Praza scf_iter_t *pg_iter, *prop_iter, *val_iter; 2119*1f6eb021SLiane Praza scf_propertygroup_t *pg; 2120*1f6eb021SLiane Praza scf_property_t *prop; 2121*1f6eb021SLiane Praza scf_value_t *val; 2122*1f6eb021SLiane Praza scf_pg_tmpl_t *pt; 2123*1f6eb021SLiane Praza scf_prop_tmpl_t *prt; 2124*1f6eb021SLiane Praza char *pg_name_buf = safe_malloc(max_scf_name_length + 1); 2125*1f6eb021SLiane Praza char *prop_name_buf = safe_malloc(max_scf_name_length + 1); 2126*1f6eb021SLiane Praza char *snap_name = safe_malloc(max_scf_name_length + 1); 2127*1f6eb021SLiane Praza char *val_buf = safe_malloc(max_scf_value_length + 1); 2128*1f6eb021SLiane Praza char *desc, *cp; 2129*1f6eb021SLiane Praza scf_type_t type; 2130*1f6eb021SLiane Praza int i, j, k; 2131*1f6eb021SLiane Praza uint8_t vis; 2132*1f6eb021SLiane Praza 2133*1f6eb021SLiane Praza if ((pg_iter = scf_iter_create(h)) == NULL || 2134*1f6eb021SLiane Praza (prop_iter = scf_iter_create(h)) == NULL || 2135*1f6eb021SLiane Praza (val_iter = scf_iter_create(h)) == NULL || 2136*1f6eb021SLiane Praza (val = scf_value_create(h)) == NULL || 2137*1f6eb021SLiane Praza (prop = scf_property_create(h)) == NULL || 2138*1f6eb021SLiane Praza (pt = scf_tmpl_pg_create(h)) == NULL || 2139*1f6eb021SLiane Praza (prt = scf_tmpl_prop_create(h)) == NULL || 2140*1f6eb021SLiane Praza (pg = scf_pg_create(h)) == NULL) 2141*1f6eb021SLiane Praza scfdie(); 2142*1f6eb021SLiane Praza 2143*1f6eb021SLiane Praza if (scf_iter_instance_pgs_typed_composed(pg_iter, wip->inst, snap, 2144*1f6eb021SLiane Praza SCF_PG_APP_DEFAULT) == -1) 2145*1f6eb021SLiane Praza scfdie(); 2146*1f6eb021SLiane Praza 2147*1f6eb021SLiane Praza /* 2148*1f6eb021SLiane Praza * Format for output: 2149*1f6eb021SLiane Praza * pg (pgtype) 2150*1f6eb021SLiane Praza * description 2151*1f6eb021SLiane Praza * pg/prop (proptype) = <value> <value> 2152*1f6eb021SLiane Praza * description 2153*1f6eb021SLiane Praza */ 2154*1f6eb021SLiane Praza while ((i = scf_iter_next_pg(pg_iter, pg)) == 1) { 2155*1f6eb021SLiane Praza int tmpl = 0; 2156*1f6eb021SLiane Praza 2157*1f6eb021SLiane Praza if (scf_pg_get_name(pg, pg_name_buf, max_scf_name_length) < 0) 2158*1f6eb021SLiane Praza scfdie(); 2159*1f6eb021SLiane Praza if (scf_snapshot_get_name(snap, snap_name, 2160*1f6eb021SLiane Praza max_scf_name_length) < 0) 2161*1f6eb021SLiane Praza scfdie(); 2162*1f6eb021SLiane Praza 2163*1f6eb021SLiane Praza if (scf_tmpl_get_by_pg_name(wip->fmri, snap_name, pg_name_buf, 2164*1f6eb021SLiane Praza SCF_PG_APP_DEFAULT, pt, 0) == 0) 2165*1f6eb021SLiane Praza tmpl = 1; 2166*1f6eb021SLiane Praza else 2167*1f6eb021SLiane Praza tmpl = 0; 2168*1f6eb021SLiane Praza 2169*1f6eb021SLiane Praza (void) printf("%s (%s)\n", pg_name_buf, SCF_PG_APP_DEFAULT); 2170*1f6eb021SLiane Praza 2171*1f6eb021SLiane Praza if (tmpl == 1 && scf_tmpl_pg_description(pt, NULL, &desc) > 0) { 2172*1f6eb021SLiane Praza (void) printf(" %s\n", desc); 2173*1f6eb021SLiane Praza free(desc); 2174*1f6eb021SLiane Praza } 2175*1f6eb021SLiane Praza 2176*1f6eb021SLiane Praza if (scf_iter_pg_properties(prop_iter, pg) == -1) 2177*1f6eb021SLiane Praza scfdie(); 2178*1f6eb021SLiane Praza while ((j = scf_iter_next_property(prop_iter, prop)) == 1) { 2179*1f6eb021SLiane Praza if (scf_property_get_name(prop, prop_name_buf, 2180*1f6eb021SLiane Praza max_scf_name_length) < 0) 2181*1f6eb021SLiane Praza scfdie(); 2182*1f6eb021SLiane Praza if (scf_property_type(prop, &type) == -1) 2183*1f6eb021SLiane Praza scfdie(); 2184*1f6eb021SLiane Praza 2185*1f6eb021SLiane Praza if ((tmpl == 1) && 2186*1f6eb021SLiane Praza (scf_tmpl_get_by_prop(pt, prop_name_buf, prt, 2187*1f6eb021SLiane Praza 0) != 0)) 2188*1f6eb021SLiane Praza tmpl = 0; 2189*1f6eb021SLiane Praza 2190*1f6eb021SLiane Praza if (tmpl == 1 && 2191*1f6eb021SLiane Praza scf_tmpl_prop_visibility(prt, &vis) != -1 && 2192*1f6eb021SLiane Praza vis == SCF_TMPL_VISIBILITY_HIDDEN) 2193*1f6eb021SLiane Praza continue; 2194*1f6eb021SLiane Praza 2195*1f6eb021SLiane Praza (void) printf("%s/%s (%s) = ", pg_name_buf, 2196*1f6eb021SLiane Praza prop_name_buf, scf_type_to_string(type)); 2197*1f6eb021SLiane Praza 2198*1f6eb021SLiane Praza if (scf_iter_property_values(val_iter, prop) == -1) 2199*1f6eb021SLiane Praza scfdie(); 2200*1f6eb021SLiane Praza 2201*1f6eb021SLiane Praza while ((k = scf_iter_next_value(val_iter, val)) == 1) { 2202*1f6eb021SLiane Praza if (scf_value_get_as_string(val, val_buf, 2203*1f6eb021SLiane Praza max_scf_value_length + 1) < 0) 2204*1f6eb021SLiane Praza scfdie(); 2205*1f6eb021SLiane Praza if (strpbrk(val_buf, " \t\n\"()") != NULL) { 2206*1f6eb021SLiane Praza (void) printf("\""); 2207*1f6eb021SLiane Praza for (cp = val_buf; *cp != '\0'; ++cp) { 2208*1f6eb021SLiane Praza if (*cp == '"' || *cp == '\\') 2209*1f6eb021SLiane Praza (void) putc('\\', 2210*1f6eb021SLiane Praza stdout); 2211*1f6eb021SLiane Praza 2212*1f6eb021SLiane Praza (void) putc(*cp, stdout); 2213*1f6eb021SLiane Praza } 2214*1f6eb021SLiane Praza (void) printf("\""); 2215*1f6eb021SLiane Praza } else { 2216*1f6eb021SLiane Praza (void) printf("%s ", val_buf); 2217*1f6eb021SLiane Praza } 2218*1f6eb021SLiane Praza } 2219*1f6eb021SLiane Praza 2220*1f6eb021SLiane Praza (void) printf("\n"); 2221*1f6eb021SLiane Praza 2222*1f6eb021SLiane Praza if (k == -1) 2223*1f6eb021SLiane Praza scfdie(); 2224*1f6eb021SLiane Praza 2225*1f6eb021SLiane Praza if (tmpl == 1 && scf_tmpl_prop_description(prt, NULL, 2226*1f6eb021SLiane Praza &desc) > 0) { 2227*1f6eb021SLiane Praza (void) printf(" %s\n", desc); 2228*1f6eb021SLiane Praza free(desc); 2229*1f6eb021SLiane Praza } 2230*1f6eb021SLiane Praza } 2231*1f6eb021SLiane Praza if (j == -1) 2232*1f6eb021SLiane Praza scfdie(); 2233*1f6eb021SLiane Praza } 2234*1f6eb021SLiane Praza if (i == -1) 2235*1f6eb021SLiane Praza scfdie(); 2236*1f6eb021SLiane Praza 2237*1f6eb021SLiane Praza 2238*1f6eb021SLiane Praza scf_iter_destroy(pg_iter); 2239*1f6eb021SLiane Praza scf_iter_destroy(prop_iter); 2240*1f6eb021SLiane Praza scf_iter_destroy(val_iter); 2241*1f6eb021SLiane Praza scf_value_destroy(val); 2242*1f6eb021SLiane Praza scf_property_destroy(prop); 2243*1f6eb021SLiane Praza scf_tmpl_pg_destroy(pt); 2244*1f6eb021SLiane Praza scf_tmpl_prop_destroy(prt); 2245*1f6eb021SLiane Praza scf_pg_destroy(pg); 2246*1f6eb021SLiane Praza free(pg_name_buf); 2247*1f6eb021SLiane Praza free(prop_name_buf); 2248*1f6eb021SLiane Praza free(snap_name); 2249*1f6eb021SLiane Praza free(val_buf); 2250*1f6eb021SLiane Praza } 2251*1f6eb021SLiane Praza 22527c478bd9Sstevel@tonic-gate static void 22537c478bd9Sstevel@tonic-gate print_detailed_dependency(scf_propertygroup_t *pg) 22547c478bd9Sstevel@tonic-gate { 22557c478bd9Sstevel@tonic-gate scf_property_t *eprop; 22567c478bd9Sstevel@tonic-gate scf_iter_t *iter; 22577c478bd9Sstevel@tonic-gate scf_type_t ty; 22587c478bd9Sstevel@tonic-gate char *val_buf; 22597c478bd9Sstevel@tonic-gate int i; 22607c478bd9Sstevel@tonic-gate 22617c478bd9Sstevel@tonic-gate if ((eprop = scf_property_create(h)) == NULL || 22627c478bd9Sstevel@tonic-gate (iter = scf_iter_create(h)) == NULL) 22637c478bd9Sstevel@tonic-gate scfdie(); 22647c478bd9Sstevel@tonic-gate 22657c478bd9Sstevel@tonic-gate val_buf = safe_malloc(max_scf_value_length + 1); 22667c478bd9Sstevel@tonic-gate 22677c478bd9Sstevel@tonic-gate if (scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, eprop) != 22687c478bd9Sstevel@tonic-gate SCF_SUCCESS || 22697c478bd9Sstevel@tonic-gate scf_property_type(eprop, &ty) != SCF_SUCCESS || 22707c478bd9Sstevel@tonic-gate ty != SCF_TYPE_FMRI) 22717c478bd9Sstevel@tonic-gate return; 22727c478bd9Sstevel@tonic-gate 22737c478bd9Sstevel@tonic-gate (void) printf("%-*s", DETAILED_WIDTH, gettext("dependency")); 22747c478bd9Sstevel@tonic-gate 22757c478bd9Sstevel@tonic-gate /* Print the grouping */ 22767c478bd9Sstevel@tonic-gate if (pg_get_single_val(pg, SCF_PROPERTY_GROUPING, SCF_TYPE_ASTRING, 22777c478bd9Sstevel@tonic-gate val_buf, max_scf_value_length + 1, 0) == 0) 22787c478bd9Sstevel@tonic-gate (void) fputs(val_buf, stdout); 22797c478bd9Sstevel@tonic-gate else 22807c478bd9Sstevel@tonic-gate (void) putchar('?'); 22817c478bd9Sstevel@tonic-gate 22827c478bd9Sstevel@tonic-gate (void) putchar('/'); 22837c478bd9Sstevel@tonic-gate 22847c478bd9Sstevel@tonic-gate if (pg_get_single_val(pg, SCF_PROPERTY_RESTART_ON, SCF_TYPE_ASTRING, 22857c478bd9Sstevel@tonic-gate val_buf, max_scf_value_length + 1, 0) == 0) 22867c478bd9Sstevel@tonic-gate (void) fputs(val_buf, stdout); 22877c478bd9Sstevel@tonic-gate else 22887c478bd9Sstevel@tonic-gate (void) putchar('?'); 22897c478bd9Sstevel@tonic-gate 22907c478bd9Sstevel@tonic-gate /* Print the dependency entities. */ 22917c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, eprop) == -1) 22927c478bd9Sstevel@tonic-gate scfdie(); 22937c478bd9Sstevel@tonic-gate 22947c478bd9Sstevel@tonic-gate while ((i = scf_iter_next_value(iter, g_val)) == 1) { 22957c478bd9Sstevel@tonic-gate char state[MAX_SCF_STATE_STRING_SZ]; 22967c478bd9Sstevel@tonic-gate 22977c478bd9Sstevel@tonic-gate if (scf_value_get_astring(g_val, val_buf, 22987c478bd9Sstevel@tonic-gate max_scf_value_length + 1) < 0) 22997c478bd9Sstevel@tonic-gate scfdie(); 23007c478bd9Sstevel@tonic-gate 23017c478bd9Sstevel@tonic-gate (void) putchar(' '); 23027c478bd9Sstevel@tonic-gate (void) fputs(val_buf, stdout); 23037c478bd9Sstevel@tonic-gate 23047c478bd9Sstevel@tonic-gate /* Print the state. */ 23057c478bd9Sstevel@tonic-gate state[0] = '-'; 23067c478bd9Sstevel@tonic-gate state[1] = '\0'; 23077c478bd9Sstevel@tonic-gate 23087c478bd9Sstevel@tonic-gate get_fmri_state(val_buf, state, sizeof (state)); 23097c478bd9Sstevel@tonic-gate 23107c478bd9Sstevel@tonic-gate (void) printf(" (%s)", state); 23117c478bd9Sstevel@tonic-gate } 23127c478bd9Sstevel@tonic-gate if (i == -1) 23137c478bd9Sstevel@tonic-gate scfdie(); 23147c478bd9Sstevel@tonic-gate 23157c478bd9Sstevel@tonic-gate (void) putchar('\n'); 23167c478bd9Sstevel@tonic-gate 23177c478bd9Sstevel@tonic-gate free(val_buf); 23187c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 23197c478bd9Sstevel@tonic-gate scf_property_destroy(eprop); 23207c478bd9Sstevel@tonic-gate } 23217c478bd9Sstevel@tonic-gate 23227c478bd9Sstevel@tonic-gate /* ARGSUSED */ 23237c478bd9Sstevel@tonic-gate static int 23247c478bd9Sstevel@tonic-gate print_detailed(void *unused, scf_walkinfo_t *wip) 23257c478bd9Sstevel@tonic-gate { 23267c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 23277c478bd9Sstevel@tonic-gate scf_propertygroup_t *rpg; 23287c478bd9Sstevel@tonic-gate scf_iter_t *pg_iter; 23297c478bd9Sstevel@tonic-gate 23307c478bd9Sstevel@tonic-gate char *buf; 23317c478bd9Sstevel@tonic-gate char *timebuf; 23327c478bd9Sstevel@tonic-gate size_t tbsz; 23337c478bd9Sstevel@tonic-gate int ret; 23347c478bd9Sstevel@tonic-gate uint64_t c; 23357c478bd9Sstevel@tonic-gate int temp, perm; 23367c478bd9Sstevel@tonic-gate struct timeval tv; 23377c478bd9Sstevel@tonic-gate time_t stime; 23387c478bd9Sstevel@tonic-gate struct tm *tmp; 233994501b61Sskamm int restarter_spec; 234094501b61Sskamm int restarter_ret; 23417c478bd9Sstevel@tonic-gate 23427c478bd9Sstevel@tonic-gate const char * const fmt = "%-*s%s\n"; 23437c478bd9Sstevel@tonic-gate 23447c478bd9Sstevel@tonic-gate assert(wip->pg == NULL); 23457c478bd9Sstevel@tonic-gate 23467c478bd9Sstevel@tonic-gate rpg = scf_pg_create(h); 23477c478bd9Sstevel@tonic-gate if (rpg == NULL) 23487c478bd9Sstevel@tonic-gate scfdie(); 23497c478bd9Sstevel@tonic-gate 23507c478bd9Sstevel@tonic-gate if (first_paragraph) 23517c478bd9Sstevel@tonic-gate first_paragraph = 0; 23527c478bd9Sstevel@tonic-gate else 23537c478bd9Sstevel@tonic-gate (void) putchar('\n'); 23547c478bd9Sstevel@tonic-gate 23557c478bd9Sstevel@tonic-gate buf = safe_malloc(max_scf_fmri_length + 1); 23567c478bd9Sstevel@tonic-gate 23577c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(wip->inst, buf, max_scf_fmri_length + 1) != -1) 23587c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, "fmri", buf); 23597c478bd9Sstevel@tonic-gate 23607c478bd9Sstevel@tonic-gate if (common_name_buf == NULL) 23617c478bd9Sstevel@tonic-gate common_name_buf = safe_malloc(max_scf_value_length + 1); 23627c478bd9Sstevel@tonic-gate 23637c478bd9Sstevel@tonic-gate if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, locale, 23647c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 1, 1) 23657c478bd9Sstevel@tonic-gate == 0) 23667c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("name"), 23677c478bd9Sstevel@tonic-gate common_name_buf); 23687c478bd9Sstevel@tonic-gate else if (inst_get_single_val(wip->inst, SCF_PG_TM_COMMON_NAME, "C", 23697c478bd9Sstevel@tonic-gate SCF_TYPE_USTRING, common_name_buf, max_scf_value_length, 0, 1, 1) 23707c478bd9Sstevel@tonic-gate == 0) 23717c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("name"), 23727c478bd9Sstevel@tonic-gate common_name_buf); 23737c478bd9Sstevel@tonic-gate 23747c478bd9Sstevel@tonic-gate /* 23757c478bd9Sstevel@tonic-gate * Synthesize an 'enabled' property that hides the enabled_ovr 23767c478bd9Sstevel@tonic-gate * implementation from the user. If the service has been temporarily 23777c478bd9Sstevel@tonic-gate * set to a state other than its permanent value, alert the user with 23787c478bd9Sstevel@tonic-gate * a '(temporary)' message. 23797c478bd9Sstevel@tonic-gate */ 23807c478bd9Sstevel@tonic-gate perm = instance_enabled(wip->inst, B_FALSE); 23817c478bd9Sstevel@tonic-gate temp = instance_enabled(wip->inst, B_TRUE); 23827c478bd9Sstevel@tonic-gate if (temp != -1) { 23837c478bd9Sstevel@tonic-gate if (temp != perm) 23847c478bd9Sstevel@tonic-gate (void) printf(gettext("%-*s%s (temporary)\n"), 23857c478bd9Sstevel@tonic-gate DETAILED_WIDTH, gettext("enabled"), 23867c478bd9Sstevel@tonic-gate temp ? gettext("true") : gettext("false")); 23877c478bd9Sstevel@tonic-gate else 23887c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, 23897c478bd9Sstevel@tonic-gate gettext("enabled"), temp ? gettext("true") : 23907c478bd9Sstevel@tonic-gate gettext("false")); 23917c478bd9Sstevel@tonic-gate } else if (perm != -1) { 23927c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("enabled"), 23937c478bd9Sstevel@tonic-gate perm ? gettext("true") : gettext("false")); 23947c478bd9Sstevel@tonic-gate } 23957c478bd9Sstevel@tonic-gate 23967c478bd9Sstevel@tonic-gate /* 23977c478bd9Sstevel@tonic-gate * Property values may be longer than max_scf_fmri_length, but these 23987c478bd9Sstevel@tonic-gate * shouldn't be, so we'll just reuse buf. The user can use svcprop if 23997c478bd9Sstevel@tonic-gate * he suspects something fishy. 24007c478bd9Sstevel@tonic-gate */ 24017c478bd9Sstevel@tonic-gate if (scf_instance_get_pg(wip->inst, SCF_PG_RESTARTER, rpg) != 0) { 24027c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 24037c478bd9Sstevel@tonic-gate scfdie(); 24047c478bd9Sstevel@tonic-gate 24057c478bd9Sstevel@tonic-gate scf_pg_destroy(rpg); 24067c478bd9Sstevel@tonic-gate rpg = NULL; 24077c478bd9Sstevel@tonic-gate } 24087c478bd9Sstevel@tonic-gate 24097c478bd9Sstevel@tonic-gate if (rpg) { 24107c478bd9Sstevel@tonic-gate if (pg_get_single_val(rpg, scf_property_state, SCF_TYPE_ASTRING, 24117c478bd9Sstevel@tonic-gate buf, max_scf_fmri_length + 1, 0) == 0) 24127c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("state"), 24137c478bd9Sstevel@tonic-gate buf); 24147c478bd9Sstevel@tonic-gate 24157c478bd9Sstevel@tonic-gate if (pg_get_single_val(rpg, scf_property_next_state, 24167c478bd9Sstevel@tonic-gate SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0) 24177c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, 24187c478bd9Sstevel@tonic-gate gettext("next_state"), buf); 24197c478bd9Sstevel@tonic-gate 24207c478bd9Sstevel@tonic-gate if (pg_get_single_val(rpg, SCF_PROPERTY_STATE_TIMESTAMP, 24217c478bd9Sstevel@tonic-gate SCF_TYPE_TIME, &tv, NULL, 0) == 0) { 24227c478bd9Sstevel@tonic-gate stime = tv.tv_sec; 24237c478bd9Sstevel@tonic-gate tmp = localtime(&stime); 24247c478bd9Sstevel@tonic-gate for (tbsz = 50; ; tbsz *= 2) { 24257c478bd9Sstevel@tonic-gate timebuf = safe_malloc(tbsz); 24267c478bd9Sstevel@tonic-gate if (strftime(timebuf, tbsz, NULL, tmp) != 0) 24277c478bd9Sstevel@tonic-gate break; 24287c478bd9Sstevel@tonic-gate free(timebuf); 24297c478bd9Sstevel@tonic-gate } 24307c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, 24317c478bd9Sstevel@tonic-gate gettext("state_time"), 24327c478bd9Sstevel@tonic-gate timebuf); 24337c478bd9Sstevel@tonic-gate free(timebuf); 24347c478bd9Sstevel@tonic-gate } 24357c478bd9Sstevel@tonic-gate 2436b7185059Srm if (pg_get_single_val(rpg, SCF_PROPERTY_ALT_LOGFILE, 2437b7185059Srm SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0) 2438b7185059Srm (void) printf(fmt, DETAILED_WIDTH, 2439b7185059Srm gettext("alt_logfile"), buf); 24407c478bd9Sstevel@tonic-gate 2441b7185059Srm if (pg_get_single_val(rpg, SCF_PROPERTY_LOGFILE, 2442b7185059Srm SCF_TYPE_ASTRING, buf, max_scf_fmri_length + 1, 0) == 0) 2443b7185059Srm (void) printf(fmt, DETAILED_WIDTH, gettext("logfile"), 2444b7185059Srm buf); 2445b7185059Srm } 24467c478bd9Sstevel@tonic-gate 24477c478bd9Sstevel@tonic-gate if (inst_get_single_val(wip->inst, SCF_PG_GENERAL, 24487c478bd9Sstevel@tonic-gate SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, buf, 24497c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1, 0, 0, 1) == 0) 24507c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("restarter"), buf); 24517c478bd9Sstevel@tonic-gate else 24527c478bd9Sstevel@tonic-gate (void) printf(fmt, DETAILED_WIDTH, gettext("restarter"), 24537c478bd9Sstevel@tonic-gate SCF_SERVICE_STARTD); 24547c478bd9Sstevel@tonic-gate 24557c478bd9Sstevel@tonic-gate free(buf); 24567c478bd9Sstevel@tonic-gate 245794501b61Sskamm /* 245894501b61Sskamm * Use the restarter specific routine to print the ctids, if available. 245994501b61Sskamm * If restarter specific action is available and it fails, then die. 246094501b61Sskamm */ 246194501b61Sskamm restarter_ret = ctids_by_restarter(wip, &c, 1, 0, 246294501b61Sskamm &restarter_spec, print_ctid_header, print_ctid_detailed); 246394501b61Sskamm if (restarter_spec == 1) { 246494501b61Sskamm if (restarter_ret != 0) 246594501b61Sskamm uu_die(gettext("Unable to get restarter for %s"), 246694501b61Sskamm wip->fmri); 246794501b61Sskamm goto restarter_common; 246894501b61Sskamm } 246994501b61Sskamm 24707c478bd9Sstevel@tonic-gate if (rpg) { 24717c478bd9Sstevel@tonic-gate scf_iter_t *iter; 24727c478bd9Sstevel@tonic-gate 24737c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL) 24747c478bd9Sstevel@tonic-gate scfdie(); 24757c478bd9Sstevel@tonic-gate 24767c478bd9Sstevel@tonic-gate if (scf_pg_get_property(rpg, scf_property_contract, g_prop) == 24777c478bd9Sstevel@tonic-gate 0) { 24787c478bd9Sstevel@tonic-gate if (scf_property_is_type(g_prop, SCF_TYPE_COUNT) == 0) { 247994501b61Sskamm 248094501b61Sskamm /* Callback to print ctid header */ 248194501b61Sskamm print_ctid_header(); 24827c478bd9Sstevel@tonic-gate 24837c478bd9Sstevel@tonic-gate if (scf_iter_property_values(iter, g_prop) != 0) 24847c478bd9Sstevel@tonic-gate scfdie(); 24857c478bd9Sstevel@tonic-gate 24867c478bd9Sstevel@tonic-gate for (;;) { 24877c478bd9Sstevel@tonic-gate ret = scf_iter_next_value(iter, g_val); 24887c478bd9Sstevel@tonic-gate if (ret == -1) 24897c478bd9Sstevel@tonic-gate scfdie(); 24907c478bd9Sstevel@tonic-gate if (ret == 0) 24917c478bd9Sstevel@tonic-gate break; 24927c478bd9Sstevel@tonic-gate 24937c478bd9Sstevel@tonic-gate if (scf_value_get_count(g_val, &c) != 0) 24947c478bd9Sstevel@tonic-gate scfdie(); 249594501b61Sskamm 249694501b61Sskamm /* Callback to print contract id. */ 249794501b61Sskamm print_ctid_detailed(c); 24987c478bd9Sstevel@tonic-gate } 24997c478bd9Sstevel@tonic-gate 25007c478bd9Sstevel@tonic-gate (void) putchar('\n'); 25017c478bd9Sstevel@tonic-gate } else { 25027c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_TYPE_MISMATCH) 25037c478bd9Sstevel@tonic-gate scfdie(); 25047c478bd9Sstevel@tonic-gate } 25057c478bd9Sstevel@tonic-gate } else { 25067c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 25077c478bd9Sstevel@tonic-gate scfdie(); 25087c478bd9Sstevel@tonic-gate } 25097c478bd9Sstevel@tonic-gate 25107c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 25117c478bd9Sstevel@tonic-gate } else { 25127c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 25137c478bd9Sstevel@tonic-gate scfdie(); 25147c478bd9Sstevel@tonic-gate } 25157c478bd9Sstevel@tonic-gate 251694501b61Sskamm restarter_common: 25177c478bd9Sstevel@tonic-gate scf_pg_destroy(rpg); 25187c478bd9Sstevel@tonic-gate 25197c478bd9Sstevel@tonic-gate /* Dependencies. */ 25207c478bd9Sstevel@tonic-gate if ((pg_iter = scf_iter_create(h)) == NULL) 25217c478bd9Sstevel@tonic-gate scfdie(); 25227c478bd9Sstevel@tonic-gate 25237c478bd9Sstevel@tonic-gate snap = get_running_snapshot(wip->inst); 25247c478bd9Sstevel@tonic-gate 25257c478bd9Sstevel@tonic-gate if (scf_iter_instance_pgs_typed_composed(pg_iter, wip->inst, snap, 25267c478bd9Sstevel@tonic-gate SCF_GROUP_DEPENDENCY) != SCF_SUCCESS) 25277c478bd9Sstevel@tonic-gate scfdie(); 25287c478bd9Sstevel@tonic-gate 25297c478bd9Sstevel@tonic-gate while ((ret = scf_iter_next_pg(pg_iter, g_pg)) == 1) 25307c478bd9Sstevel@tonic-gate print_detailed_dependency(g_pg); 25317c478bd9Sstevel@tonic-gate if (ret == -1) 25327c478bd9Sstevel@tonic-gate scfdie(); 25337c478bd9Sstevel@tonic-gate 25347c478bd9Sstevel@tonic-gate scf_iter_destroy(pg_iter); 25357c478bd9Sstevel@tonic-gate 25367c478bd9Sstevel@tonic-gate if (opt_processes) 253794501b61Sskamm detailed_list_processes(wip); 25387c478bd9Sstevel@tonic-gate 2539*1f6eb021SLiane Praza /* "application" type property groups */ 2540*1f6eb021SLiane Praza if (opt_verbose == 1) 2541*1f6eb021SLiane Praza print_application_properties(wip, snap); 2542*1f6eb021SLiane Praza 2543*1f6eb021SLiane Praza scf_snapshot_destroy(snap); 2544*1f6eb021SLiane Praza 25457c478bd9Sstevel@tonic-gate return (0); 25467c478bd9Sstevel@tonic-gate } 25477c478bd9Sstevel@tonic-gate 25487c478bd9Sstevel@tonic-gate /* 25497c478bd9Sstevel@tonic-gate * Append a one-lined description of each process in inst's contract(s) and 25507c478bd9Sstevel@tonic-gate * return the augmented string. 25517c478bd9Sstevel@tonic-gate */ 25527c478bd9Sstevel@tonic-gate static char * 255394501b61Sskamm add_processes(scf_walkinfo_t *wip, char *line, scf_propertygroup_t *lpg) 25547c478bd9Sstevel@tonic-gate { 25557c478bd9Sstevel@tonic-gate pid_t *pids = NULL; 25567c478bd9Sstevel@tonic-gate uint_t i, n = 0; 25577c478bd9Sstevel@tonic-gate 25587c478bd9Sstevel@tonic-gate if (lpg == NULL) { 255994501b61Sskamm if (instance_processes(wip->inst, wip->fmri, &pids, &n) != 0) 25607c478bd9Sstevel@tonic-gate return (line); 25617c478bd9Sstevel@tonic-gate } else { 256294501b61Sskamm /* Legacy services */ 25637c478bd9Sstevel@tonic-gate scf_iter_t *iter; 25647c478bd9Sstevel@tonic-gate 25657c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL) 25667c478bd9Sstevel@tonic-gate scfdie(); 25677c478bd9Sstevel@tonic-gate 25687c478bd9Sstevel@tonic-gate (void) propvals_to_pids(lpg, scf_property_contract, &pids, &n, 25697c478bd9Sstevel@tonic-gate g_prop, g_val, iter); 25707c478bd9Sstevel@tonic-gate 25717c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 25727c478bd9Sstevel@tonic-gate } 25737c478bd9Sstevel@tonic-gate 25747c478bd9Sstevel@tonic-gate if (n == 0) 25757c478bd9Sstevel@tonic-gate return (line); 25767c478bd9Sstevel@tonic-gate 25777c478bd9Sstevel@tonic-gate qsort(pids, n, sizeof (*pids), pidcmp); 25787c478bd9Sstevel@tonic-gate 25797c478bd9Sstevel@tonic-gate for (i = 0; i < n; ++i) { 25807c478bd9Sstevel@tonic-gate char *cp, stime[9]; 25817c478bd9Sstevel@tonic-gate psinfo_t psi; 25827c478bd9Sstevel@tonic-gate struct tm *tm; 25837c478bd9Sstevel@tonic-gate int len = 1 + 15 + 8 + 3 + 6 + 1 + PRFNSZ; 25847c478bd9Sstevel@tonic-gate 25857c478bd9Sstevel@tonic-gate if (get_psinfo(pids[i], &psi) != 0) 25867c478bd9Sstevel@tonic-gate continue; 25877c478bd9Sstevel@tonic-gate 25887c478bd9Sstevel@tonic-gate line = realloc(line, strlen(line) + len); 25897c478bd9Sstevel@tonic-gate if (line == NULL) 25907c478bd9Sstevel@tonic-gate uu_die(gettext("Out of memory.\n")); 25917c478bd9Sstevel@tonic-gate 25927c478bd9Sstevel@tonic-gate cp = strchr(line, '\0'); 25937c478bd9Sstevel@tonic-gate 25947c478bd9Sstevel@tonic-gate tm = localtime(&psi.pr_start.tv_sec); 25957c478bd9Sstevel@tonic-gate 25967c478bd9Sstevel@tonic-gate /* 25977c478bd9Sstevel@tonic-gate * Print time if started within the past 24 hours, print date 25987c478bd9Sstevel@tonic-gate * if within the past 12 months, print year if started greater 25997c478bd9Sstevel@tonic-gate * than 12 months ago. 26007c478bd9Sstevel@tonic-gate */ 26017c478bd9Sstevel@tonic-gate if (now - psi.pr_start.tv_sec < 24 * 60 * 60) 26023eae19d9Swesolows (void) strftime(stime, sizeof (stime), 26033eae19d9Swesolows gettext(FORMAT_TIME), tm); 26047c478bd9Sstevel@tonic-gate else if (now - psi.pr_start.tv_sec < 12 * 30 * 24 * 60 * 60) 26053eae19d9Swesolows (void) strftime(stime, sizeof (stime), 26063eae19d9Swesolows gettext(FORMAT_DATE), tm); 26077c478bd9Sstevel@tonic-gate else 26083eae19d9Swesolows (void) strftime(stime, sizeof (stime), 26093eae19d9Swesolows gettext(FORMAT_YEAR), tm); 26107c478bd9Sstevel@tonic-gate 26117c478bd9Sstevel@tonic-gate (void) snprintf(cp, len, "\n %-8s %6ld %.*s", 26127c478bd9Sstevel@tonic-gate stime, pids[i], PRFNSZ, psi.pr_fname); 26137c478bd9Sstevel@tonic-gate } 26147c478bd9Sstevel@tonic-gate 26157c478bd9Sstevel@tonic-gate free(pids); 26167c478bd9Sstevel@tonic-gate 26177c478bd9Sstevel@tonic-gate return (line); 26187c478bd9Sstevel@tonic-gate } 26197c478bd9Sstevel@tonic-gate 26207c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 26217c478bd9Sstevel@tonic-gate static int 26227c478bd9Sstevel@tonic-gate list_instance(void *unused, scf_walkinfo_t *wip) 26237c478bd9Sstevel@tonic-gate { 26247c478bd9Sstevel@tonic-gate struct avl_string *lp; 26257c478bd9Sstevel@tonic-gate char *cp; 26267c478bd9Sstevel@tonic-gate int i; 26277c478bd9Sstevel@tonic-gate uu_avl_index_t idx; 26287c478bd9Sstevel@tonic-gate 26297c478bd9Sstevel@tonic-gate /* 26307c478bd9Sstevel@tonic-gate * If the user has specified a restarter, check for a match first 26317c478bd9Sstevel@tonic-gate */ 26327c478bd9Sstevel@tonic-gate if (restarters != NULL) { 26337c478bd9Sstevel@tonic-gate struct pfmri_list *rest; 26347c478bd9Sstevel@tonic-gate int match; 26357c478bd9Sstevel@tonic-gate char *restarter_fmri; 26367c478bd9Sstevel@tonic-gate const char *scope_name, *svc_name, *inst_name, *pg_name; 26377c478bd9Sstevel@tonic-gate 26387c478bd9Sstevel@tonic-gate /* legacy services don't have restarters */ 26397c478bd9Sstevel@tonic-gate if (wip->pg != NULL) 26407c478bd9Sstevel@tonic-gate return (0); 26417c478bd9Sstevel@tonic-gate 26427c478bd9Sstevel@tonic-gate restarter_fmri = safe_malloc(max_scf_fmri_length + 1); 26437c478bd9Sstevel@tonic-gate 26447c478bd9Sstevel@tonic-gate if (inst_get_single_val(wip->inst, SCF_PG_GENERAL, 26457c478bd9Sstevel@tonic-gate SCF_PROPERTY_RESTARTER, SCF_TYPE_ASTRING, restarter_fmri, 26467c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1, 0, 0, 1) != 0) 26477c478bd9Sstevel@tonic-gate (void) strcpy(restarter_fmri, SCF_SERVICE_STARTD); 26487c478bd9Sstevel@tonic-gate 26497c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(restarter_fmri, &scope_name, &svc_name, 26507c478bd9Sstevel@tonic-gate &inst_name, &pg_name, NULL) != SCF_SUCCESS) { 26517c478bd9Sstevel@tonic-gate free(restarter_fmri); 26527c478bd9Sstevel@tonic-gate return (0); 26537c478bd9Sstevel@tonic-gate } 26547c478bd9Sstevel@tonic-gate 26557c478bd9Sstevel@tonic-gate match = 0; 26567c478bd9Sstevel@tonic-gate for (rest = restarters; rest != NULL; rest = rest->next) { 26577c478bd9Sstevel@tonic-gate if (strcmp(rest->scope, scope_name) == 0 && 26587c478bd9Sstevel@tonic-gate strcmp(rest->service, svc_name) == 0 && 26597c478bd9Sstevel@tonic-gate strcmp(rest->instance, inst_name) == 0) 26607c478bd9Sstevel@tonic-gate match = 1; 26617c478bd9Sstevel@tonic-gate } 26627c478bd9Sstevel@tonic-gate 26637c478bd9Sstevel@tonic-gate free(restarter_fmri); 26647c478bd9Sstevel@tonic-gate 26657c478bd9Sstevel@tonic-gate if (!match) 26667c478bd9Sstevel@tonic-gate return (0); 26677c478bd9Sstevel@tonic-gate } 26687c478bd9Sstevel@tonic-gate 26697c478bd9Sstevel@tonic-gate if (wip->pg == NULL && ht_buckets != NULL && ht_add(wip->fmri)) { 26707c478bd9Sstevel@tonic-gate /* It was already there. */ 26717c478bd9Sstevel@tonic-gate return (0); 26727c478bd9Sstevel@tonic-gate } 26737c478bd9Sstevel@tonic-gate 26747c478bd9Sstevel@tonic-gate lp = safe_malloc(sizeof (*lp)); 26757c478bd9Sstevel@tonic-gate 26767c478bd9Sstevel@tonic-gate lp->str = NULL; 26777c478bd9Sstevel@tonic-gate for (i = 0; i < opt_cnum; ++i) { 26787c478bd9Sstevel@tonic-gate columns[opt_columns[i]].sprint(&lp->str, wip); 26797c478bd9Sstevel@tonic-gate } 26807c478bd9Sstevel@tonic-gate cp = lp->str + strlen(lp->str); 26817c478bd9Sstevel@tonic-gate cp--; 26827c478bd9Sstevel@tonic-gate while (*cp == ' ') 26837c478bd9Sstevel@tonic-gate cp--; 26847c478bd9Sstevel@tonic-gate *(cp+1) = '\0'; 26857c478bd9Sstevel@tonic-gate 26867c478bd9Sstevel@tonic-gate /* If we're supposed to list the processes, too, do that now. */ 26877c478bd9Sstevel@tonic-gate if (opt_processes) 268894501b61Sskamm lp->str = add_processes(wip, lp->str, wip->pg); 26897c478bd9Sstevel@tonic-gate 26907c478bd9Sstevel@tonic-gate /* Create the sort key. */ 26917c478bd9Sstevel@tonic-gate cp = lp->key = safe_malloc(sortkey_sz); 26927c478bd9Sstevel@tonic-gate for (i = 0; i < opt_snum; ++i) { 26937c478bd9Sstevel@tonic-gate int j = opt_sort[i] & 0xff; 26947c478bd9Sstevel@tonic-gate 26957c478bd9Sstevel@tonic-gate assert(columns[j].get_sortkey != NULL); 26967c478bd9Sstevel@tonic-gate columns[j].get_sortkey(cp, opt_sort[i] & ~0xff, wip); 26977c478bd9Sstevel@tonic-gate cp += columns[j].sortkey_width; 26987c478bd9Sstevel@tonic-gate } 26997c478bd9Sstevel@tonic-gate 27007c478bd9Sstevel@tonic-gate /* Insert into AVL tree. */ 27017c478bd9Sstevel@tonic-gate uu_avl_node_init(lp, &lp->node, lines_pool); 27027c478bd9Sstevel@tonic-gate (void) uu_avl_find(lines, lp, NULL, &idx); 27037c478bd9Sstevel@tonic-gate uu_avl_insert(lines, lp, idx); 27047c478bd9Sstevel@tonic-gate 27057c478bd9Sstevel@tonic-gate return (0); 27067c478bd9Sstevel@tonic-gate } 27077c478bd9Sstevel@tonic-gate 27087c478bd9Sstevel@tonic-gate static int 27097c478bd9Sstevel@tonic-gate list_if_enabled(void *unused, scf_walkinfo_t *wip) 27107c478bd9Sstevel@tonic-gate { 27117c478bd9Sstevel@tonic-gate if (wip->pg != NULL || 27127c478bd9Sstevel@tonic-gate instance_enabled(wip->inst, B_FALSE) == 1 || 27137c478bd9Sstevel@tonic-gate instance_enabled(wip->inst, B_TRUE) == 1) 27147c478bd9Sstevel@tonic-gate return (list_instance(unused, wip)); 27157c478bd9Sstevel@tonic-gate 27167c478bd9Sstevel@tonic-gate return (0); 27177c478bd9Sstevel@tonic-gate } 27187c478bd9Sstevel@tonic-gate 27197c478bd9Sstevel@tonic-gate /* 27207c478bd9Sstevel@tonic-gate * Service FMRI selection: Lookup and call list_instance() for the instances. 27217c478bd9Sstevel@tonic-gate * Instance FMRI selection: Lookup and call list_instance(). 27227c478bd9Sstevel@tonic-gate * 27237c478bd9Sstevel@tonic-gate * Note: This is shoehorned into a walk_dependencies() callback prototype so 27247c478bd9Sstevel@tonic-gate * it can be used in list_dependencies. 27257c478bd9Sstevel@tonic-gate */ 27267c478bd9Sstevel@tonic-gate static int 27277c478bd9Sstevel@tonic-gate list_svc_or_inst_fmri(void *complain, scf_walkinfo_t *wip) 27287c478bd9Sstevel@tonic-gate { 27297c478bd9Sstevel@tonic-gate char *fmri; 27307c478bd9Sstevel@tonic-gate const char *svc_name, *inst_name, *pg_name, *save; 27317c478bd9Sstevel@tonic-gate scf_iter_t *iter; 27327c478bd9Sstevel@tonic-gate int ret; 27337c478bd9Sstevel@tonic-gate 27347c478bd9Sstevel@tonic-gate fmri = safe_strdup(wip->fmri); 27357c478bd9Sstevel@tonic-gate 27367c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(fmri, NULL, &svc_name, &inst_name, &pg_name, 27377c478bd9Sstevel@tonic-gate NULL) != SCF_SUCCESS) { 27387c478bd9Sstevel@tonic-gate if (complain) 27397c478bd9Sstevel@tonic-gate uu_warn(gettext("FMRI \"%s\" is invalid.\n"), 27407c478bd9Sstevel@tonic-gate wip->fmri); 27417c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 27427c478bd9Sstevel@tonic-gate free(fmri); 27437c478bd9Sstevel@tonic-gate return (0); 27447c478bd9Sstevel@tonic-gate } 27457c478bd9Sstevel@tonic-gate 27467c478bd9Sstevel@tonic-gate /* 27477c478bd9Sstevel@tonic-gate * Yes, this invalidates *_name, but we only care whether they're NULL 27487c478bd9Sstevel@tonic-gate * or not. 27497c478bd9Sstevel@tonic-gate */ 27507c478bd9Sstevel@tonic-gate free(fmri); 27517c478bd9Sstevel@tonic-gate 27527c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 27537c478bd9Sstevel@tonic-gate if (complain) 27547c478bd9Sstevel@tonic-gate uu_warn(gettext("FMRI \"%s\" does not designate a " 27557c478bd9Sstevel@tonic-gate "service or instance.\n"), wip->fmri); 27567c478bd9Sstevel@tonic-gate return (0); 27577c478bd9Sstevel@tonic-gate } 27587c478bd9Sstevel@tonic-gate 27597c478bd9Sstevel@tonic-gate if (inst_name != NULL) { 27607c478bd9Sstevel@tonic-gate /* instance */ 27617c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, wip->fmri, wip->scope, wip->svc, 27627c478bd9Sstevel@tonic-gate wip->inst, NULL, NULL, 0) != SCF_SUCCESS) { 27637c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 27647c478bd9Sstevel@tonic-gate scfdie(); 27657c478bd9Sstevel@tonic-gate 27667c478bd9Sstevel@tonic-gate if (complain) 27677c478bd9Sstevel@tonic-gate uu_warn(gettext( 27687c478bd9Sstevel@tonic-gate "Instance \"%s\" does not exist.\n"), 27697c478bd9Sstevel@tonic-gate wip->fmri); 27707c478bd9Sstevel@tonic-gate return (0); 27717c478bd9Sstevel@tonic-gate } 27727c478bd9Sstevel@tonic-gate 27737c478bd9Sstevel@tonic-gate return (list_instance(NULL, wip)); 27747c478bd9Sstevel@tonic-gate } 27757c478bd9Sstevel@tonic-gate 27767c478bd9Sstevel@tonic-gate /* service: Walk the instances. */ 27777c478bd9Sstevel@tonic-gate if (scf_handle_decode_fmri(h, wip->fmri, wip->scope, wip->svc, NULL, 27787c478bd9Sstevel@tonic-gate NULL, NULL, 0) != SCF_SUCCESS) { 27797c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 27807c478bd9Sstevel@tonic-gate scfdie(); 27817c478bd9Sstevel@tonic-gate 27827c478bd9Sstevel@tonic-gate if (complain) 27837c478bd9Sstevel@tonic-gate uu_warn(gettext("Service \"%s\" does not exist.\n"), 27847c478bd9Sstevel@tonic-gate wip->fmri); 27857c478bd9Sstevel@tonic-gate 27867c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 27877c478bd9Sstevel@tonic-gate 27887c478bd9Sstevel@tonic-gate return (0); 27897c478bd9Sstevel@tonic-gate } 27907c478bd9Sstevel@tonic-gate 27917c478bd9Sstevel@tonic-gate iter = scf_iter_create(h); 27927c478bd9Sstevel@tonic-gate if (iter == NULL) 27937c478bd9Sstevel@tonic-gate scfdie(); 27947c478bd9Sstevel@tonic-gate 27957c478bd9Sstevel@tonic-gate if (scf_iter_service_instances(iter, wip->svc) != SCF_SUCCESS) 27967c478bd9Sstevel@tonic-gate scfdie(); 27977c478bd9Sstevel@tonic-gate 27987c478bd9Sstevel@tonic-gate if ((fmri = malloc(max_scf_fmri_length + 1)) == NULL) { 27997c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 28007c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 28017c478bd9Sstevel@tonic-gate return (0); 28027c478bd9Sstevel@tonic-gate } 28037c478bd9Sstevel@tonic-gate 28047c478bd9Sstevel@tonic-gate save = wip->fmri; 28057c478bd9Sstevel@tonic-gate wip->fmri = fmri; 28067c478bd9Sstevel@tonic-gate while ((ret = scf_iter_next_instance(iter, wip->inst)) == 1) { 28077c478bd9Sstevel@tonic-gate if (scf_instance_to_fmri(wip->inst, fmri, 28087c478bd9Sstevel@tonic-gate max_scf_fmri_length + 1) <= 0) 28097c478bd9Sstevel@tonic-gate scfdie(); 28107c478bd9Sstevel@tonic-gate (void) list_instance(NULL, wip); 28117c478bd9Sstevel@tonic-gate } 28127c478bd9Sstevel@tonic-gate free(fmri); 28137c478bd9Sstevel@tonic-gate wip->fmri = save; 28147c478bd9Sstevel@tonic-gate if (ret == -1) 28157c478bd9Sstevel@tonic-gate scfdie(); 28167c478bd9Sstevel@tonic-gate 28177c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_OK; 28187c478bd9Sstevel@tonic-gate 28197c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 28207c478bd9Sstevel@tonic-gate 28217c478bd9Sstevel@tonic-gate return (0); 28227c478bd9Sstevel@tonic-gate } 28237c478bd9Sstevel@tonic-gate 28247c478bd9Sstevel@tonic-gate /* 28257c478bd9Sstevel@tonic-gate * Dependency selection: Straightforward since each instance lists the 28267c478bd9Sstevel@tonic-gate * services it depends on. 28277c478bd9Sstevel@tonic-gate */ 28287c478bd9Sstevel@tonic-gate 28297c478bd9Sstevel@tonic-gate static void 28307c478bd9Sstevel@tonic-gate walk_dependencies(scf_walkinfo_t *wip, scf_walk_callback callback, void *data) 28317c478bd9Sstevel@tonic-gate { 28327c478bd9Sstevel@tonic-gate scf_snapshot_t *snap; 28337c478bd9Sstevel@tonic-gate scf_iter_t *iter, *viter; 28347c478bd9Sstevel@tonic-gate int ret, vret; 28357c478bd9Sstevel@tonic-gate char *dep; 28367c478bd9Sstevel@tonic-gate 28377c478bd9Sstevel@tonic-gate assert(wip->inst != NULL); 28387c478bd9Sstevel@tonic-gate 28397c478bd9Sstevel@tonic-gate if ((iter = scf_iter_create(h)) == NULL || 28407c478bd9Sstevel@tonic-gate (viter = scf_iter_create(h)) == NULL) 28417c478bd9Sstevel@tonic-gate scfdie(); 28427c478bd9Sstevel@tonic-gate 28437c478bd9Sstevel@tonic-gate snap = get_running_snapshot(wip->inst); 28447c478bd9Sstevel@tonic-gate 28457c478bd9Sstevel@tonic-gate if (scf_iter_instance_pgs_typed_composed(iter, wip->inst, snap, 28467c478bd9Sstevel@tonic-gate SCF_GROUP_DEPENDENCY) != SCF_SUCCESS) 28477c478bd9Sstevel@tonic-gate scfdie(); 28487c478bd9Sstevel@tonic-gate 28497c478bd9Sstevel@tonic-gate dep = safe_malloc(max_scf_value_length + 1); 28507c478bd9Sstevel@tonic-gate 28517c478bd9Sstevel@tonic-gate while ((ret = scf_iter_next_pg(iter, g_pg)) == 1) { 28527c478bd9Sstevel@tonic-gate scf_type_t ty; 28537c478bd9Sstevel@tonic-gate 28547c478bd9Sstevel@tonic-gate /* Ignore exclude_any dependencies. */ 28557c478bd9Sstevel@tonic-gate if (scf_pg_get_property(g_pg, SCF_PROPERTY_GROUPING, g_prop) != 28567c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 28577c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 28587c478bd9Sstevel@tonic-gate scfdie(); 28597c478bd9Sstevel@tonic-gate 28607c478bd9Sstevel@tonic-gate continue; 28617c478bd9Sstevel@tonic-gate } 28627c478bd9Sstevel@tonic-gate 28637c478bd9Sstevel@tonic-gate if (scf_property_type(g_prop, &ty) != SCF_SUCCESS) 28647c478bd9Sstevel@tonic-gate scfdie(); 28657c478bd9Sstevel@tonic-gate 28667c478bd9Sstevel@tonic-gate if (ty != SCF_TYPE_ASTRING) 28677c478bd9Sstevel@tonic-gate continue; 28687c478bd9Sstevel@tonic-gate 28697c478bd9Sstevel@tonic-gate if (scf_property_get_value(g_prop, g_val) != SCF_SUCCESS) { 28707c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_CONSTRAINT_VIOLATED) 28717c478bd9Sstevel@tonic-gate scfdie(); 28727c478bd9Sstevel@tonic-gate 28737c478bd9Sstevel@tonic-gate continue; 28747c478bd9Sstevel@tonic-gate } 28757c478bd9Sstevel@tonic-gate 28767c478bd9Sstevel@tonic-gate if (scf_value_get_astring(g_val, dep, 28777c478bd9Sstevel@tonic-gate max_scf_value_length + 1) < 0) 28787c478bd9Sstevel@tonic-gate scfdie(); 28797c478bd9Sstevel@tonic-gate 28807c478bd9Sstevel@tonic-gate if (strcmp(dep, SCF_DEP_EXCLUDE_ALL) == 0) 28817c478bd9Sstevel@tonic-gate continue; 28827c478bd9Sstevel@tonic-gate 28837c478bd9Sstevel@tonic-gate if (scf_pg_get_property(g_pg, SCF_PROPERTY_ENTITIES, g_prop) != 28847c478bd9Sstevel@tonic-gate SCF_SUCCESS) { 28857c478bd9Sstevel@tonic-gate if (scf_error() != SCF_ERROR_NOT_FOUND) 28867c478bd9Sstevel@tonic-gate scfdie(); 28877c478bd9Sstevel@tonic-gate 28887c478bd9Sstevel@tonic-gate continue; 28897c478bd9Sstevel@tonic-gate } 28907c478bd9Sstevel@tonic-gate 28917c478bd9Sstevel@tonic-gate if (scf_iter_property_values(viter, g_prop) != SCF_SUCCESS) 28927c478bd9Sstevel@tonic-gate scfdie(); 28937c478bd9Sstevel@tonic-gate 28947c478bd9Sstevel@tonic-gate while ((vret = scf_iter_next_value(viter, g_val)) == 1) { 28957c478bd9Sstevel@tonic-gate if (scf_value_get_astring(g_val, dep, 28967c478bd9Sstevel@tonic-gate max_scf_value_length + 1) < 0) 28977c478bd9Sstevel@tonic-gate scfdie(); 28987c478bd9Sstevel@tonic-gate 28997c478bd9Sstevel@tonic-gate wip->fmri = dep; 29007c478bd9Sstevel@tonic-gate if (callback(data, wip) != 0) 29017c478bd9Sstevel@tonic-gate goto out; 29027c478bd9Sstevel@tonic-gate } 29037c478bd9Sstevel@tonic-gate if (vret == -1) 29047c478bd9Sstevel@tonic-gate scfdie(); 29057c478bd9Sstevel@tonic-gate } 29067c478bd9Sstevel@tonic-gate if (ret == -1) 29077c478bd9Sstevel@tonic-gate scfdie(); 29087c478bd9Sstevel@tonic-gate 29097c478bd9Sstevel@tonic-gate out: 29107c478bd9Sstevel@tonic-gate scf_iter_destroy(viter); 29117c478bd9Sstevel@tonic-gate scf_iter_destroy(iter); 29127c478bd9Sstevel@tonic-gate scf_snapshot_destroy(snap); 29137c478bd9Sstevel@tonic-gate } 29147c478bd9Sstevel@tonic-gate 29157c478bd9Sstevel@tonic-gate static int 29167c478bd9Sstevel@tonic-gate list_dependencies(void *data, scf_walkinfo_t *wip) 29177c478bd9Sstevel@tonic-gate { 29187c478bd9Sstevel@tonic-gate walk_dependencies(wip, list_svc_or_inst_fmri, data); 29197c478bd9Sstevel@tonic-gate return (0); 29207c478bd9Sstevel@tonic-gate } 29217c478bd9Sstevel@tonic-gate 29227c478bd9Sstevel@tonic-gate 29237c478bd9Sstevel@tonic-gate /* 29247c478bd9Sstevel@tonic-gate * Dependent selection: The "providing" service's or instance's FMRI is parsed 29257c478bd9Sstevel@tonic-gate * into the provider_* variables, the instances are walked, and any instance 29267c478bd9Sstevel@tonic-gate * which lists an FMRI which parses to these components is selected. This is 29277c478bd9Sstevel@tonic-gate * inefficient in the face of multiple operands, but that should be uncommon. 29287c478bd9Sstevel@tonic-gate */ 29297c478bd9Sstevel@tonic-gate 29307c478bd9Sstevel@tonic-gate static char *provider_scope; 29317c478bd9Sstevel@tonic-gate static char *provider_svc; 29327c478bd9Sstevel@tonic-gate static char *provider_inst; /* NULL for services */ 29337c478bd9Sstevel@tonic-gate 29347c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 29357c478bd9Sstevel@tonic-gate static int 29367c478bd9Sstevel@tonic-gate check_against_provider(void *arg, scf_walkinfo_t *wip) 29377c478bd9Sstevel@tonic-gate { 29387c478bd9Sstevel@tonic-gate char *cfmri; 29397c478bd9Sstevel@tonic-gate const char *scope_name, *svc_name, *inst_name, *pg_name; 29407c478bd9Sstevel@tonic-gate int *matchp = arg; 29417c478bd9Sstevel@tonic-gate 29427c478bd9Sstevel@tonic-gate cfmri = safe_strdup(wip->fmri); 29437c478bd9Sstevel@tonic-gate 29447c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(cfmri, &scope_name, &svc_name, &inst_name, 29457c478bd9Sstevel@tonic-gate &pg_name, NULL) != SCF_SUCCESS) { 29467c478bd9Sstevel@tonic-gate free(cfmri); 29477c478bd9Sstevel@tonic-gate return (0); 29487c478bd9Sstevel@tonic-gate } 29497c478bd9Sstevel@tonic-gate 29507c478bd9Sstevel@tonic-gate if (svc_name == NULL || pg_name != NULL) { 29517c478bd9Sstevel@tonic-gate free(cfmri); 29527c478bd9Sstevel@tonic-gate return (0); 29537c478bd9Sstevel@tonic-gate } 29547c478bd9Sstevel@tonic-gate 29557c478bd9Sstevel@tonic-gate /* 29567c478bd9Sstevel@tonic-gate * If the user has specified an instance, then also match dependencies 29577c478bd9Sstevel@tonic-gate * on the service itself. 29587c478bd9Sstevel@tonic-gate */ 29597c478bd9Sstevel@tonic-gate *matchp = (strcmp(provider_scope, scope_name) == 0 && 29607c478bd9Sstevel@tonic-gate strcmp(provider_svc, svc_name) == 0 && 29617c478bd9Sstevel@tonic-gate (provider_inst == NULL ? (inst_name == NULL) : 29627c478bd9Sstevel@tonic-gate (inst_name == NULL || strcmp(provider_inst, inst_name) == 0))); 29637c478bd9Sstevel@tonic-gate 29647c478bd9Sstevel@tonic-gate free(cfmri); 29657c478bd9Sstevel@tonic-gate 29667c478bd9Sstevel@tonic-gate /* Stop on matches. */ 29677c478bd9Sstevel@tonic-gate return (*matchp); 29687c478bd9Sstevel@tonic-gate } 29697c478bd9Sstevel@tonic-gate 29707c478bd9Sstevel@tonic-gate static int 29717c478bd9Sstevel@tonic-gate list_if_dependent(void *unused, scf_walkinfo_t *wip) 29727c478bd9Sstevel@tonic-gate { 29737c478bd9Sstevel@tonic-gate /* Only proceed if this instance depends on provider_*. */ 29747c478bd9Sstevel@tonic-gate int match = 0; 29757c478bd9Sstevel@tonic-gate 29767c478bd9Sstevel@tonic-gate (void) walk_dependencies(wip, check_against_provider, &match); 29777c478bd9Sstevel@tonic-gate 29787c478bd9Sstevel@tonic-gate if (match) 29797c478bd9Sstevel@tonic-gate return (list_instance(unused, wip)); 29807c478bd9Sstevel@tonic-gate 29817c478bd9Sstevel@tonic-gate return (0); 29827c478bd9Sstevel@tonic-gate } 29837c478bd9Sstevel@tonic-gate 29847c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 29857c478bd9Sstevel@tonic-gate static int 29867c478bd9Sstevel@tonic-gate list_dependents(void *unused, scf_walkinfo_t *wip) 29877c478bd9Sstevel@tonic-gate { 29887c478bd9Sstevel@tonic-gate char *save; 29897c478bd9Sstevel@tonic-gate int ret; 29907c478bd9Sstevel@tonic-gate 29917c478bd9Sstevel@tonic-gate if (scf_scope_get_name(wip->scope, provider_scope, 29927c478bd9Sstevel@tonic-gate max_scf_fmri_length) <= 0 || 29937c478bd9Sstevel@tonic-gate scf_service_get_name(wip->svc, provider_svc, 29947c478bd9Sstevel@tonic-gate max_scf_fmri_length) <= 0) 29957c478bd9Sstevel@tonic-gate scfdie(); 29967c478bd9Sstevel@tonic-gate 29977c478bd9Sstevel@tonic-gate save = provider_inst; 29987c478bd9Sstevel@tonic-gate if (wip->inst == NULL) 29997c478bd9Sstevel@tonic-gate provider_inst = NULL; 30007c478bd9Sstevel@tonic-gate else if (scf_instance_get_name(wip->inst, provider_inst, 30017c478bd9Sstevel@tonic-gate max_scf_fmri_length) <= 0) 30027c478bd9Sstevel@tonic-gate scfdie(); 30037c478bd9Sstevel@tonic-gate 30047c478bd9Sstevel@tonic-gate ret = scf_walk_fmri(h, 0, NULL, 0, list_if_dependent, NULL, NULL, 30057c478bd9Sstevel@tonic-gate uu_warn); 30067c478bd9Sstevel@tonic-gate 30077c478bd9Sstevel@tonic-gate provider_inst = save; 30087c478bd9Sstevel@tonic-gate 30097c478bd9Sstevel@tonic-gate return (ret); 30107c478bd9Sstevel@tonic-gate } 30117c478bd9Sstevel@tonic-gate 30127c478bd9Sstevel@tonic-gate /* 30137c478bd9Sstevel@tonic-gate * main() & helpers 30147c478bd9Sstevel@tonic-gate */ 30157c478bd9Sstevel@tonic-gate 30167c478bd9Sstevel@tonic-gate static void 30177c478bd9Sstevel@tonic-gate add_sort_column(const char *col, int reverse) 30187c478bd9Sstevel@tonic-gate { 30197c478bd9Sstevel@tonic-gate int i; 30207c478bd9Sstevel@tonic-gate 30217c478bd9Sstevel@tonic-gate ++opt_snum; 30227c478bd9Sstevel@tonic-gate 30237c478bd9Sstevel@tonic-gate opt_sort = realloc(opt_sort, opt_snum * sizeof (*opt_sort)); 30247c478bd9Sstevel@tonic-gate if (opt_sort == NULL) 30257c478bd9Sstevel@tonic-gate uu_die(gettext("Too many sort criteria: out of memory.\n")); 30267c478bd9Sstevel@tonic-gate 30277c478bd9Sstevel@tonic-gate for (i = 0; i < ncolumns; ++i) { 30287c478bd9Sstevel@tonic-gate if (strcasecmp(col, columns[i].name) == 0) 30297c478bd9Sstevel@tonic-gate break; 30307c478bd9Sstevel@tonic-gate } 30317c478bd9Sstevel@tonic-gate 30327c478bd9Sstevel@tonic-gate if (i < ncolumns) 30337c478bd9Sstevel@tonic-gate opt_sort[opt_snum - 1] = (reverse ? i | 0x100 : i); 30347c478bd9Sstevel@tonic-gate else 30357c478bd9Sstevel@tonic-gate uu_die(gettext("Unrecognized sort column \"%s\".\n"), col); 30367c478bd9Sstevel@tonic-gate 30377c478bd9Sstevel@tonic-gate sortkey_sz += columns[i].sortkey_width; 30387c478bd9Sstevel@tonic-gate } 30397c478bd9Sstevel@tonic-gate 30407c478bd9Sstevel@tonic-gate static void 30417c478bd9Sstevel@tonic-gate add_restarter(const char *fmri) 30427c478bd9Sstevel@tonic-gate { 30437c478bd9Sstevel@tonic-gate char *cfmri; 30447c478bd9Sstevel@tonic-gate const char *pg_name; 30457c478bd9Sstevel@tonic-gate struct pfmri_list *rest; 30467c478bd9Sstevel@tonic-gate 30477c478bd9Sstevel@tonic-gate cfmri = safe_strdup(fmri); 30487c478bd9Sstevel@tonic-gate rest = safe_malloc(sizeof (*rest)); 30497c478bd9Sstevel@tonic-gate 30507c478bd9Sstevel@tonic-gate if (scf_parse_svc_fmri(cfmri, &rest->scope, &rest->service, 30517c478bd9Sstevel@tonic-gate &rest->instance, &pg_name, NULL) != SCF_SUCCESS) 30527c478bd9Sstevel@tonic-gate uu_die(gettext("Restarter FMRI \"%s\" is invalid.\n"), fmri); 30537c478bd9Sstevel@tonic-gate 30547c478bd9Sstevel@tonic-gate if (rest->instance == NULL || pg_name != NULL) 30557c478bd9Sstevel@tonic-gate uu_die(gettext("Restarter FMRI \"%s\" does not designate an " 30567c478bd9Sstevel@tonic-gate "instance.\n"), fmri); 30577c478bd9Sstevel@tonic-gate 30587c478bd9Sstevel@tonic-gate rest->next = restarters; 30597c478bd9Sstevel@tonic-gate restarters = rest; 30607c478bd9Sstevel@tonic-gate return; 30617c478bd9Sstevel@tonic-gate 30627c478bd9Sstevel@tonic-gate err: 30637c478bd9Sstevel@tonic-gate free(cfmri); 30647c478bd9Sstevel@tonic-gate free(rest); 30657c478bd9Sstevel@tonic-gate } 30667c478bd9Sstevel@tonic-gate 30677c478bd9Sstevel@tonic-gate /* ARGSUSED */ 30687c478bd9Sstevel@tonic-gate static int 30697c478bd9Sstevel@tonic-gate line_cmp(const void *l_arg, const void *r_arg, void *private) 30707c478bd9Sstevel@tonic-gate { 30717c478bd9Sstevel@tonic-gate const struct avl_string *l = l_arg; 30727c478bd9Sstevel@tonic-gate const struct avl_string *r = r_arg; 30737c478bd9Sstevel@tonic-gate 30747c478bd9Sstevel@tonic-gate return (memcmp(l->key, r->key, sortkey_sz)); 30757c478bd9Sstevel@tonic-gate } 30767c478bd9Sstevel@tonic-gate 30777c478bd9Sstevel@tonic-gate /* ARGSUSED */ 30787c478bd9Sstevel@tonic-gate static int 30797c478bd9Sstevel@tonic-gate print_line(void *e, void *private) 30807c478bd9Sstevel@tonic-gate { 30817c478bd9Sstevel@tonic-gate struct avl_string *lp = e; 30827c478bd9Sstevel@tonic-gate 30837c478bd9Sstevel@tonic-gate (void) puts(lp->str); 30847c478bd9Sstevel@tonic-gate 30857c478bd9Sstevel@tonic-gate return (UU_WALK_NEXT); 30867c478bd9Sstevel@tonic-gate } 30877c478bd9Sstevel@tonic-gate 30887c478bd9Sstevel@tonic-gate int 30897c478bd9Sstevel@tonic-gate main(int argc, char **argv) 30907c478bd9Sstevel@tonic-gate { 30917c478bd9Sstevel@tonic-gate char opt, opt_mode; 30927c478bd9Sstevel@tonic-gate int i, n; 30937c478bd9Sstevel@tonic-gate char *columns_str = NULL; 30947c478bd9Sstevel@tonic-gate char *cp; 30957c478bd9Sstevel@tonic-gate const char *progname; 30967c478bd9Sstevel@tonic-gate int err; 30977c478bd9Sstevel@tonic-gate 30987c478bd9Sstevel@tonic-gate int show_all = 0; 30997c478bd9Sstevel@tonic-gate int show_header = 1; 31007c478bd9Sstevel@tonic-gate 31017c478bd9Sstevel@tonic-gate const char * const options = "aHpvo:R:s:S:dDl?x"; 31027c478bd9Sstevel@tonic-gate 31037c478bd9Sstevel@tonic-gate (void) setlocale(LC_ALL, ""); 31047c478bd9Sstevel@tonic-gate 31057c478bd9Sstevel@tonic-gate locale = setlocale(LC_MESSAGES, ""); 31067c478bd9Sstevel@tonic-gate if (locale) { 31077c478bd9Sstevel@tonic-gate locale = safe_strdup(locale); 3108*1f6eb021SLiane Praza _scf_sanitize_locale(locale); 31097c478bd9Sstevel@tonic-gate } 31107c478bd9Sstevel@tonic-gate 31117c478bd9Sstevel@tonic-gate (void) textdomain(TEXT_DOMAIN); 31127c478bd9Sstevel@tonic-gate progname = uu_setpname(argv[0]); 31137c478bd9Sstevel@tonic-gate 31147c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_OK; 31157c478bd9Sstevel@tonic-gate 31167c478bd9Sstevel@tonic-gate max_scf_name_length = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH); 31177c478bd9Sstevel@tonic-gate max_scf_value_length = scf_limit(SCF_LIMIT_MAX_VALUE_LENGTH); 31187c478bd9Sstevel@tonic-gate max_scf_fmri_length = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH); 3119*1f6eb021SLiane Praza max_scf_type_length = scf_limit(SCF_LIMIT_MAX_PG_TYPE_LENGTH); 31207c478bd9Sstevel@tonic-gate 31217c478bd9Sstevel@tonic-gate if (max_scf_name_length == -1 || max_scf_value_length == -1 || 3122*1f6eb021SLiane Praza max_scf_fmri_length == -1 || max_scf_type_length == -1) 31237c478bd9Sstevel@tonic-gate scfdie(); 31247c478bd9Sstevel@tonic-gate 31257c478bd9Sstevel@tonic-gate now = time(NULL); 31267c478bd9Sstevel@tonic-gate assert(now != -1); 31277c478bd9Sstevel@tonic-gate 31287c478bd9Sstevel@tonic-gate /* 31297c478bd9Sstevel@tonic-gate * opt_mode is the mode of operation. 0 for plain, 'd' for 31307c478bd9Sstevel@tonic-gate * dependencies, 'D' for dependents, and 'l' for detailed (long). We 31317c478bd9Sstevel@tonic-gate * need to know now so we know which options are valid. 31327c478bd9Sstevel@tonic-gate */ 31337c478bd9Sstevel@tonic-gate opt_mode = 0; 31347c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, options)) != -1) { 31357c478bd9Sstevel@tonic-gate switch (opt) { 31367c478bd9Sstevel@tonic-gate case '?': 31377c478bd9Sstevel@tonic-gate if (optopt == '?') { 31387c478bd9Sstevel@tonic-gate print_help(progname); 31397c478bd9Sstevel@tonic-gate return (UU_EXIT_OK); 31407c478bd9Sstevel@tonic-gate } else { 31417c478bd9Sstevel@tonic-gate argserr(progname); 31427c478bd9Sstevel@tonic-gate /* NOTREACHED */ 31437c478bd9Sstevel@tonic-gate } 31447c478bd9Sstevel@tonic-gate 31457c478bd9Sstevel@tonic-gate case 'd': 31467c478bd9Sstevel@tonic-gate case 'D': 31477c478bd9Sstevel@tonic-gate case 'l': 31487c478bd9Sstevel@tonic-gate if (opt_mode != 0) 31497c478bd9Sstevel@tonic-gate argserr(progname); 31507c478bd9Sstevel@tonic-gate 31517c478bd9Sstevel@tonic-gate opt_mode = opt; 31527c478bd9Sstevel@tonic-gate break; 31537c478bd9Sstevel@tonic-gate 31547c478bd9Sstevel@tonic-gate case 'x': 31557c478bd9Sstevel@tonic-gate if (opt_mode != 0) 31567c478bd9Sstevel@tonic-gate argserr(progname); 31577c478bd9Sstevel@tonic-gate 31587c478bd9Sstevel@tonic-gate opt_mode = opt; 31597c478bd9Sstevel@tonic-gate break; 31607c478bd9Sstevel@tonic-gate 31617c478bd9Sstevel@tonic-gate default: 31627c478bd9Sstevel@tonic-gate break; 31637c478bd9Sstevel@tonic-gate } 31647c478bd9Sstevel@tonic-gate } 31657c478bd9Sstevel@tonic-gate 31667c478bd9Sstevel@tonic-gate sortkey_sz = 0; 31677c478bd9Sstevel@tonic-gate 31687c478bd9Sstevel@tonic-gate optind = 1; /* Reset getopt() */ 31697c478bd9Sstevel@tonic-gate while ((opt = getopt(argc, argv, options)) != -1) { 31707c478bd9Sstevel@tonic-gate switch (opt) { 31717c478bd9Sstevel@tonic-gate case 'a': 31727c478bd9Sstevel@tonic-gate if (opt_mode != 0) 31737c478bd9Sstevel@tonic-gate argserr(progname); 31747c478bd9Sstevel@tonic-gate show_all = 1; 31757c478bd9Sstevel@tonic-gate break; 31767c478bd9Sstevel@tonic-gate 31777c478bd9Sstevel@tonic-gate case 'H': 31787c478bd9Sstevel@tonic-gate if (opt_mode == 'l' || opt_mode == 'x') 31797c478bd9Sstevel@tonic-gate argserr(progname); 31807c478bd9Sstevel@tonic-gate show_header = 0; 31817c478bd9Sstevel@tonic-gate break; 31827c478bd9Sstevel@tonic-gate 31837c478bd9Sstevel@tonic-gate case 'p': 31847c478bd9Sstevel@tonic-gate if (opt_mode == 'x') 31857c478bd9Sstevel@tonic-gate argserr(progname); 31867c478bd9Sstevel@tonic-gate opt_processes = 1; 31877c478bd9Sstevel@tonic-gate break; 31887c478bd9Sstevel@tonic-gate 31897c478bd9Sstevel@tonic-gate case 'v': 31907c478bd9Sstevel@tonic-gate opt_verbose = 1; 31917c478bd9Sstevel@tonic-gate break; 31927c478bd9Sstevel@tonic-gate 31937c478bd9Sstevel@tonic-gate case 'o': 31947c478bd9Sstevel@tonic-gate if (opt_mode == 'l' || opt_mode == 'x') 31957c478bd9Sstevel@tonic-gate argserr(progname); 31967c478bd9Sstevel@tonic-gate columns_str = optarg; 31977c478bd9Sstevel@tonic-gate break; 31987c478bd9Sstevel@tonic-gate 31997c478bd9Sstevel@tonic-gate case 'R': 32007c478bd9Sstevel@tonic-gate if (opt_mode != 0 || opt_mode == 'x') 32017c478bd9Sstevel@tonic-gate argserr(progname); 32027c478bd9Sstevel@tonic-gate 32037c478bd9Sstevel@tonic-gate add_restarter(optarg); 32047c478bd9Sstevel@tonic-gate break; 32057c478bd9Sstevel@tonic-gate 32067c478bd9Sstevel@tonic-gate case 's': 32077c478bd9Sstevel@tonic-gate case 'S': 32087c478bd9Sstevel@tonic-gate if (opt_mode != 0) 32097c478bd9Sstevel@tonic-gate argserr(progname); 32107c478bd9Sstevel@tonic-gate 32117c478bd9Sstevel@tonic-gate add_sort_column(optarg, optopt == 'S'); 32127c478bd9Sstevel@tonic-gate break; 32137c478bd9Sstevel@tonic-gate 32147c478bd9Sstevel@tonic-gate case 'd': 32157c478bd9Sstevel@tonic-gate case 'D': 32167c478bd9Sstevel@tonic-gate case 'l': 32177c478bd9Sstevel@tonic-gate case 'x': 32187c478bd9Sstevel@tonic-gate assert(opt_mode == optopt); 32197c478bd9Sstevel@tonic-gate break; 32207c478bd9Sstevel@tonic-gate 32217c478bd9Sstevel@tonic-gate case '?': 32227c478bd9Sstevel@tonic-gate argserr(progname); 32237c478bd9Sstevel@tonic-gate /* NOTREACHED */ 32247c478bd9Sstevel@tonic-gate 32257c478bd9Sstevel@tonic-gate default: 32267c478bd9Sstevel@tonic-gate assert(0); 32277c478bd9Sstevel@tonic-gate abort(); 32287c478bd9Sstevel@tonic-gate } 32297c478bd9Sstevel@tonic-gate } 32307c478bd9Sstevel@tonic-gate 32317c478bd9Sstevel@tonic-gate /* 32327c478bd9Sstevel@tonic-gate * -a is only meaningful when given no arguments 32337c478bd9Sstevel@tonic-gate */ 32347c478bd9Sstevel@tonic-gate if (show_all && optind != argc) 32357c478bd9Sstevel@tonic-gate uu_warn(gettext("-a ignored when used with arguments.\n")); 32367c478bd9Sstevel@tonic-gate 32377c478bd9Sstevel@tonic-gate h = scf_handle_create(SCF_VERSION); 32387c478bd9Sstevel@tonic-gate if (h == NULL) 32397c478bd9Sstevel@tonic-gate scfdie(); 32407c478bd9Sstevel@tonic-gate 32417c478bd9Sstevel@tonic-gate if (scf_handle_bind(h) == -1) 32427c478bd9Sstevel@tonic-gate uu_die(gettext("Could not bind to repository server: %s. " 32437c478bd9Sstevel@tonic-gate "Exiting.\n"), scf_strerror(scf_error())); 32447c478bd9Sstevel@tonic-gate 32457c478bd9Sstevel@tonic-gate if ((g_pg = scf_pg_create(h)) == NULL || 32467c478bd9Sstevel@tonic-gate (g_prop = scf_property_create(h)) == NULL || 32477c478bd9Sstevel@tonic-gate (g_val = scf_value_create(h)) == NULL) 32487c478bd9Sstevel@tonic-gate scfdie(); 32497c478bd9Sstevel@tonic-gate 32507c478bd9Sstevel@tonic-gate argc -= optind; 32517c478bd9Sstevel@tonic-gate argv += optind; 32527c478bd9Sstevel@tonic-gate 32537c478bd9Sstevel@tonic-gate /* 32547c478bd9Sstevel@tonic-gate * If we're in long mode, take care of it now before we deal with the 32557c478bd9Sstevel@tonic-gate * sorting and the columns, since we won't use them anyway. 32567c478bd9Sstevel@tonic-gate */ 32577c478bd9Sstevel@tonic-gate if (opt_mode == 'l') { 32587c478bd9Sstevel@tonic-gate if (argc == 0) 32597c478bd9Sstevel@tonic-gate argserr(progname); 32607c478bd9Sstevel@tonic-gate 32617c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, SCF_WALK_MULTIPLE, 32627c478bd9Sstevel@tonic-gate print_detailed, NULL, &exit_status, uu_warn)) != 0) { 32637c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 32647c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 32657c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 32667c478bd9Sstevel@tonic-gate } 32677c478bd9Sstevel@tonic-gate 32687c478bd9Sstevel@tonic-gate return (exit_status); 32697c478bd9Sstevel@tonic-gate } 32707c478bd9Sstevel@tonic-gate 32717c478bd9Sstevel@tonic-gate if (opt_mode == 'x') { 32727c478bd9Sstevel@tonic-gate explain(opt_verbose, argc, argv); 32737c478bd9Sstevel@tonic-gate 32747c478bd9Sstevel@tonic-gate return (exit_status); 32757c478bd9Sstevel@tonic-gate } 32767c478bd9Sstevel@tonic-gate 32777c478bd9Sstevel@tonic-gate 32787c478bd9Sstevel@tonic-gate if (opt_snum == 0) { 32797c478bd9Sstevel@tonic-gate /* Default sort. */ 32807c478bd9Sstevel@tonic-gate add_sort_column("state", 0); 32817c478bd9Sstevel@tonic-gate add_sort_column("stime", 0); 32827c478bd9Sstevel@tonic-gate add_sort_column("fmri", 0); 32837c478bd9Sstevel@tonic-gate } 32847c478bd9Sstevel@tonic-gate 32857c478bd9Sstevel@tonic-gate if (columns_str == NULL) { 32867c478bd9Sstevel@tonic-gate if (!opt_verbose) 32877c478bd9Sstevel@tonic-gate columns_str = safe_strdup("state,stime,fmri"); 32887c478bd9Sstevel@tonic-gate else 32897c478bd9Sstevel@tonic-gate columns_str = 32907c478bd9Sstevel@tonic-gate safe_strdup("state,nstate,stime,ctid,fmri"); 32917c478bd9Sstevel@tonic-gate } 32927c478bd9Sstevel@tonic-gate 32937c478bd9Sstevel@tonic-gate /* Decode columns_str into opt_columns. */ 32947c478bd9Sstevel@tonic-gate line_sz = 0; 32957c478bd9Sstevel@tonic-gate 32967c478bd9Sstevel@tonic-gate opt_cnum = 1; 32977c478bd9Sstevel@tonic-gate for (cp = columns_str; *cp != '\0'; ++cp) 32987c478bd9Sstevel@tonic-gate if (*cp == ',') 32997c478bd9Sstevel@tonic-gate ++opt_cnum; 33007c478bd9Sstevel@tonic-gate 33017c478bd9Sstevel@tonic-gate opt_columns = malloc(opt_cnum * sizeof (*opt_columns)); 33027c478bd9Sstevel@tonic-gate if (opt_columns == NULL) 33037c478bd9Sstevel@tonic-gate uu_die(gettext("Too many columns.\n")); 33047c478bd9Sstevel@tonic-gate 33057c478bd9Sstevel@tonic-gate for (n = 0; *columns_str != '\0'; ++n) { 33067c478bd9Sstevel@tonic-gate i = getcolumnopt(&columns_str); 33077c478bd9Sstevel@tonic-gate if (i == -1) 33087c478bd9Sstevel@tonic-gate uu_die(gettext("Unknown column \"%s\".\n"), 33097c478bd9Sstevel@tonic-gate columns_str); 33107c478bd9Sstevel@tonic-gate 33117c478bd9Sstevel@tonic-gate if (strcmp(columns[i].name, "N") == 0 || 33127c478bd9Sstevel@tonic-gate strcmp(columns[i].name, "SN") == 0 || 33137c478bd9Sstevel@tonic-gate strcmp(columns[i].name, "NSTA") == 0 || 33147c478bd9Sstevel@tonic-gate strcmp(columns[i].name, "NSTATE") == 0) 33157c478bd9Sstevel@tonic-gate opt_nstate_shown = 1; 33167c478bd9Sstevel@tonic-gate 33177c478bd9Sstevel@tonic-gate opt_columns[n] = i; 33187c478bd9Sstevel@tonic-gate line_sz += columns[i].width + 1; 33197c478bd9Sstevel@tonic-gate } 33207c478bd9Sstevel@tonic-gate 33217c478bd9Sstevel@tonic-gate 33227c478bd9Sstevel@tonic-gate if ((lines_pool = uu_avl_pool_create("lines_pool", 33237c478bd9Sstevel@tonic-gate sizeof (struct avl_string), offsetof(struct avl_string, node), 33247c478bd9Sstevel@tonic-gate line_cmp, UU_AVL_DEBUG)) == NULL || 33257c478bd9Sstevel@tonic-gate (lines = uu_avl_create(lines_pool, NULL, 0)) == NULL) 33267c478bd9Sstevel@tonic-gate uu_die(gettext("Unexpected libuutil error: %s. Exiting.\n"), 33277c478bd9Sstevel@tonic-gate uu_strerror(uu_error())); 33287c478bd9Sstevel@tonic-gate 33297c478bd9Sstevel@tonic-gate switch (opt_mode) { 33307c478bd9Sstevel@tonic-gate case 0: 33317c478bd9Sstevel@tonic-gate ht_init(); 33327c478bd9Sstevel@tonic-gate 33337c478bd9Sstevel@tonic-gate /* Always show all FMRIs when given arguments or restarters */ 33347c478bd9Sstevel@tonic-gate if (argc != 0 || restarters != NULL) 33357c478bd9Sstevel@tonic-gate show_all = 1; 33367c478bd9Sstevel@tonic-gate 33377c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, 33387c478bd9Sstevel@tonic-gate SCF_WALK_MULTIPLE | SCF_WALK_LEGACY, 33397c478bd9Sstevel@tonic-gate show_all ? list_instance : list_if_enabled, NULL, 33407c478bd9Sstevel@tonic-gate &exit_status, uu_warn)) != 0) { 33417c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 33427c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 33437c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 33447c478bd9Sstevel@tonic-gate } 33457c478bd9Sstevel@tonic-gate break; 33467c478bd9Sstevel@tonic-gate 33477c478bd9Sstevel@tonic-gate case 'd': 33487c478bd9Sstevel@tonic-gate if (argc == 0) 33497c478bd9Sstevel@tonic-gate argserr(progname); 33507c478bd9Sstevel@tonic-gate 33517c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, 33527c478bd9Sstevel@tonic-gate SCF_WALK_MULTIPLE, list_dependencies, NULL, 33537c478bd9Sstevel@tonic-gate &exit_status, uu_warn)) != 0) { 33547c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 33557c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 33567c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 33577c478bd9Sstevel@tonic-gate } 33587c478bd9Sstevel@tonic-gate break; 33597c478bd9Sstevel@tonic-gate 33607c478bd9Sstevel@tonic-gate case 'D': 33617c478bd9Sstevel@tonic-gate if (argc == 0) 33627c478bd9Sstevel@tonic-gate argserr(progname); 33637c478bd9Sstevel@tonic-gate 33647c478bd9Sstevel@tonic-gate provider_scope = safe_malloc(max_scf_fmri_length); 33657c478bd9Sstevel@tonic-gate provider_svc = safe_malloc(max_scf_fmri_length); 33667c478bd9Sstevel@tonic-gate provider_inst = safe_malloc(max_scf_fmri_length); 33677c478bd9Sstevel@tonic-gate 33687c478bd9Sstevel@tonic-gate if ((err = scf_walk_fmri(h, argc, argv, 33697c478bd9Sstevel@tonic-gate SCF_WALK_MULTIPLE | SCF_WALK_SERVICE, 33707c478bd9Sstevel@tonic-gate list_dependents, NULL, &exit_status, uu_warn)) != 0) { 33717c478bd9Sstevel@tonic-gate uu_warn(gettext("failed to iterate over " 33727c478bd9Sstevel@tonic-gate "instances: %s\n"), scf_strerror(err)); 33737c478bd9Sstevel@tonic-gate exit_status = UU_EXIT_FATAL; 33747c478bd9Sstevel@tonic-gate } 33757c478bd9Sstevel@tonic-gate 33767c478bd9Sstevel@tonic-gate free(provider_scope); 33777c478bd9Sstevel@tonic-gate free(provider_svc); 33787c478bd9Sstevel@tonic-gate free(provider_inst); 33797c478bd9Sstevel@tonic-gate break; 33807c478bd9Sstevel@tonic-gate 33817c478bd9Sstevel@tonic-gate default: 33827c478bd9Sstevel@tonic-gate assert(0); 33837c478bd9Sstevel@tonic-gate abort(); 33847c478bd9Sstevel@tonic-gate } 33857c478bd9Sstevel@tonic-gate 33867c478bd9Sstevel@tonic-gate if (show_header) 33877c478bd9Sstevel@tonic-gate print_header(); 33887c478bd9Sstevel@tonic-gate 33897c478bd9Sstevel@tonic-gate (void) uu_avl_walk(lines, print_line, NULL, 0); 33907c478bd9Sstevel@tonic-gate 33917c478bd9Sstevel@tonic-gate return (exit_status); 33927c478bd9Sstevel@tonic-gate } 3393