cmd/hotplug/hotplug.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#include <libintl.h>
#include <alloca.h>
#include <getopt.h>
#include <libhotplug.h>
#include <sys/types.h>
#include <sys/sunddi.h>
#include <sys/ddi_hp.h>

#if !defined(TEXT_DOMAIN)       /* should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it wasn't */
#endif

/*
 * Function prototypes.
 */
static int  cmd_list(int, char **, const char *);
static int  cmd_online(int, char **, const char *);
static int  cmd_offline(int, char **, const char *);
static int  cmd_enable(int, char **, const char *);
static int  cmd_disable(int, char **, const char *);
static int  cmd_poweron(int, char **, const char *);
static int  cmd_poweroff(int, char **, const char *);
static int  cmd_getpriv(int, char **, const char *);
static int  cmd_setpriv(int, char **, const char *);
static int  cmd_changestate(int, char **, const char *);
static void parse_common(int, char **, const char *);
static void parse_flags(int, char **, int *, const char *);
static void parse_target(int, char **, char **, char **, const char *);
static void parse_options(int, char **, char **, const char *);
static void bad_option(int, int, const char *);
static void usage(const char *);
static int  list_cb(hp_node_t, void *);
static int  list_long_cb(hp_node_t, void *);
static int  error_cb(hp_node_t, void *);
static void print_options(const char *);
static void print_error(int);
static int  state_atoi(char *);
static char *state_itoa(int);
static short    valid_target(int);

/*
 * Define a conversion table for hotplug states.
 */
typedef struct {
    int state;
    char    *state_str;
    short   valid_target;
} hpstate_t;

static hpstate_t hpstates[] = {
    { DDI_HP_CN_STATE_EMPTY,    "EMPTY",    0 },
    { DDI_HP_CN_STATE_PRESENT,  "PRESENT",  1 },
    { DDI_HP_CN_STATE_POWERED,  "POWERED",  1 },
    { DDI_HP_CN_STATE_ENABLED,  "ENABLED",  1 },
    { DDI_HP_CN_STATE_PORT_EMPTY,   "PORT-EMPTY",   0 },
    { DDI_HP_CN_STATE_PORT_PRESENT, "PORT-PRESENT", 1 },
    { DDI_HP_CN_STATE_OFFLINE,  "OFFLINE",  1 },
    { DDI_HP_CN_STATE_ATTACHED, "ATTACHED", 0 },
    { DDI_HP_CN_STATE_MAINTENANCE,  "MAINTENANCE",  0 },
    { DDI_HP_CN_STATE_ONLINE,   "ONLINE",   1 },
    { 0, 0, 0 }
};

/*
 * Define tables of supported subcommands.
 */
typedef struct {
    char        *usage_str;
    char        *cmd_str;
    int     (*func)(int argc, char *argv[], const char *usage_str);
} subcmd_t;

static subcmd_t subcmds[] = {
    { "list       [-l] [-v] [<path> [<connection>]]", "list", cmd_list },
    { "online     <path> <port>", "online", cmd_online },
    { "offline    [-f] [-q] <path> <port>", "offline", cmd_offline },
    { "enable     <path> <connector>", "enable", cmd_enable },
    { "disable    [-f] [-q] <path> <connector>", "disable", cmd_disable },
    { "poweron    <path> <connector>", "poweron", cmd_poweron },
    { "poweroff   [-f] [-q] <path> <connector>", "poweroff", cmd_poweroff },
    { "get        -o <options> <path> <connector>", "get", cmd_getpriv },
    { "set        -o <options> <path> <connector>", "set", cmd_setpriv }
};

static subcmd_t hidden_subcmds[] = {
    { "changestate  [-f] [-q] -s <state> <path> <connection>",
        "changestate", cmd_changestate }
};

/*
 * Define tables of command line options.
 */
static const struct option common_opts[] = {
    { "help",   no_argument,        0, '?' },
    { "version",    no_argument,        0, 'V' },
    { 0, 0, 0, 0 }
};

static const struct option list_opts[] = {
    { "list-path",  no_argument,        0, 'l' },
    { "verbose",    no_argument,        0, 'v' },
    { 0, 0, 0, 0 }
};

static const struct option flag_opts[] = {
    { "force",  no_argument,        0, 'f' },
    { "query",  no_argument,        0, 'q' },
    { 0, 0, 0, 0 }
};

static const struct option private_opts[] = {
    { "options",    required_argument,  0, 'o' },
    { 0, 0, 0, 0 }
};

static const struct option changestate_opts[] = {
    { "force",  no_argument,        0, 'f' },
    { "query",  no_argument,        0, 'q' },
    { "state",  required_argument,  0, 's' },
    { 0, 0, 0, 0 }
};

/*
 * Define exit codes.
 */
#define EXIT_OK     0
#define EXIT_EINVAL 1   /* invalid arguments */
#define EXIT_ENOENT 2   /* path or connection doesn't exist */
#define EXIT_FAILED 3   /* operation failed */
#define EXIT_UNAVAIL    4   /* service not available */

/*
 * Global variables.
 */
static char     *prog;
static char version[] = "1.0";
extern int  errno;

/*
 * main()
 *
 *  The main routine determines which subcommand is used,
 *  and dispatches control to the corresponding function.
 */
int
main(int argc, char *argv[])
{
    int         i, rv;

    (void) setlocale(LC_ALL, "");
    (void) textdomain(TEXT_DOMAIN);

    if ((prog = strrchr(argv[0], '/')) == NULL)
        prog = argv[0];
    else
        prog++;

    if (argc < 2) {
        usage(NULL);
        return (EXIT_EINVAL);
    }

    parse_common(argc, argv, NULL);

    /* Check the list of defined subcommands. */
    for (i = 0; i < (sizeof (subcmds) / sizeof (subcmd_t)); i++) {
        if (strcmp(argv[1], subcmds[i].cmd_str) == 0) {
            rv = subcmds[i].func(argc - 1, &argv[1],
                subcmds[i].usage_str);
            goto finished;
        }
    }

    /* Check the list of hidden subcommands. */
    for (i = 0; i < (sizeof (hidden_subcmds) / sizeof (subcmd_t)); i++) {
        if (strcmp(argv[1], hidden_subcmds[i].cmd_str) == 0) {
            rv = hidden_subcmds[i].func(argc - 1, &argv[1],
                hidden_subcmds[i].usage_str);
            goto finished;
        }
    }

    /* No matching subcommand found. */
    (void) fprintf(stderr, gettext("ERROR: %s: unknown subcommand '%s'\n"),
        prog, argv[1]);
    usage(NULL);
    exit(EXIT_EINVAL);

finished:
    /* Determine exit code */
    switch (rv) {
    case 0:
        break;
    case EINVAL:
        return (EXIT_EINVAL);
    case ENXIO:
    case ENOENT:
        return (EXIT_ENOENT);
    case EBADF:
        return (EXIT_UNAVAIL);
    default:
        return (EXIT_FAILED);
    }

    return (EXIT_OK);
}

/*
 * cmd_list()
 *
 *  Subcommand to list hotplug information.
 */
static int
cmd_list(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    char        *path = NULL;
    char        *connection = NULL;
    boolean_t   long_flag = B_FALSE;
    int     flags = 0;
    int     opt;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    while ((opt = getopt_clip(argc, argv, "lv", list_opts, NULL)) != -1) {
        switch (opt) {
        case 'l':
            long_flag = B_TRUE;
            break;
        case 'v':
            flags |= HPINFOUSAGE;
            break;
        default:
            bad_option(opt, optopt, usage_str);
            break;
        }
    }
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Default path is "/" */
    if (path == NULL)
        path = "/";

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, flags)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Display hotplug information */
    (void) hp_traverse(root, NULL, long_flag ? list_long_cb : list_cb);

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (0);
}

/*
 * cmd_online()
 *
 *  Subcommand to online a hotplug port.
 */
static int
cmd_online(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Path and connection are required */
    if ((path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a port */
    if (hp_type(root) != HP_NODE_PORT) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a port).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /* Do state change */
    rv = hp_set_state(root, 0, DDI_HP_CN_STATE_ONLINE, &results);

    /* Display results */
    if (rv == EIO) {
        (void) fprintf(stderr, gettext("ERROR: failed to attach device "
            "drivers or other internal errors.\n"));
    } else if (rv != 0) {
        print_error(rv);
    }
    if (results != NULL) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_offline()
 *
 *  Subcommand to offline a hotplug port.
 */
static int
cmd_offline(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     flags = 0;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_flags(argc, argv, &flags, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Path and connection are required */
    if ((path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a port */
    if (hp_type(root) != HP_NODE_PORT) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a port).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /* Do state change */
    rv = hp_set_state(root, flags, DDI_HP_CN_STATE_OFFLINE, &results);

    /* Display results */
    print_error(rv);
    if (results != NULL) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_enable()
 *
 *  Subcommand to enable a hotplug connector.
 */
static int
cmd_enable(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Path and connection are required */
    if ((path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a connector */
    if (hp_type(root) != HP_NODE_CONNECTOR) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a connector).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /* Do state change */
    rv = hp_set_state(root, 0, DDI_HP_CN_STATE_ENABLED, &results);

    /* Display results */
    print_error(rv);
    if (results != NULL) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_disable()
 *
 *  Subcommand to disable a hotplug connector.
 */
static int
cmd_disable(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     flags = 0;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_flags(argc, argv, &flags, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Path and connection are required */
    if ((path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a connector */
    if (hp_type(root) != HP_NODE_CONNECTOR) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a connector).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /*
     * Do nothing unless the connector is in the ENABLED state.
     * Otherwise this subcommand becomes an alias for 'poweron.'
     */
    if (hp_state(root) != DDI_HP_CN_STATE_ENABLED) {
        hp_fini(root);
        return (0);
    }

    /* Do state change */
    rv = hp_set_state(root, flags, DDI_HP_CN_STATE_POWERED, &results);

    /* Display results */
    print_error(rv);
    if (results != NULL) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_poweron()
 *
 *  Subcommand to power on a hotplug connector.
 */
static int
cmd_poweron(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Path and connection are required */
    if ((path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a connector */
    if (hp_type(root) != HP_NODE_CONNECTOR) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a connector).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /*
     * Do nothing if the connector is already powered.
     * Otherwise this subcommand becomes an alias for 'disable.'
     */
    if (hp_state(root) >= DDI_HP_CN_STATE_POWERED) {
        hp_fini(root);
        return (0);
    }

    /* Do state change */
    rv = hp_set_state(root, 0, DDI_HP_CN_STATE_POWERED, &results);

    /* Display results */
    print_error(rv);
    if (results != NULL) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_poweroff()
 *
 *  Subcommand to power off a hotplug connector.
 */
static int
cmd_poweroff(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     flags = 0;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_flags(argc, argv, &flags, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Path and connection are required */
    if ((path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a connector */
    if (hp_type(root) != HP_NODE_CONNECTOR) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a connector).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /* Do state change */
    rv = hp_set_state(root, flags, DDI_HP_CN_STATE_PRESENT, &results);

    /* Display results */
    print_error(rv);
    if (results != NULL) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_getpriv()
 *
 *  Subcommand to get and display bus private options.
 */
static int
cmd_getpriv(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    char        *path = NULL;
    char        *connection = NULL;
    char        *options = NULL;
    char        *results = NULL;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_options(argc, argv, &options, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Options, path, and connection are all required */
    if ((options == NULL) || (path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a connector */
    if (hp_type(root) != HP_NODE_CONNECTOR) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a connector).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /* Do the operation */
    rv = hp_get_private(root, options, &results);

    /* Display results */
    if (rv == ENOTSUP) {
        (void) fprintf(stderr,
            gettext("ERROR: unsupported property name or value.\n"));
        (void) fprintf(stderr,
            gettext("(Properties may depend upon connector state.)\n"));
    } else if (rv != 0) {
        print_error(rv);
    }
    if (results != NULL) {
        print_options(results);
        free(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_setpriv()
 *
 *  Subcommand to set bus private options.
 */
static int
cmd_setpriv(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    char        *path = NULL;
    char        *connection = NULL;
    char        *options = NULL;
    char        *results = NULL;
    int     rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    parse_options(argc, argv, &options, usage_str);
    parse_target(argc, argv, &path, &connection, usage_str);

    /* Options, path, and connection are all required */
    if ((options == NULL) || (path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Verify target is a connector */
    if (hp_type(root) != HP_NODE_CONNECTOR) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target (must be a connector).\n"));
        hp_fini(root);
        return (EINVAL);
    }

    /* Do the operation */
    rv = hp_set_private(root, options, &results);

    /* Display results */
    if (rv == ENOTSUP) {
        (void) fprintf(stderr,
            gettext("ERROR: unsupported property name or value.\n"));
        (void) fprintf(stderr,
            gettext("(Properties may depend upon connector state.)\n"));
    } else if (rv != 0) {
        print_error(rv);
    }
    if (results != NULL) {
        print_options(results);
        free(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * cmd_changestate()
 *
 *  Subcommand to initiate a state change operation.  This is
 *  a hidden subcommand to directly set a connector or port to
 *  a specific target state.
 */
static int
cmd_changestate(int argc, char *argv[], const char *usage_str)
{
    hp_node_t   root;
    hp_node_t   results = NULL;
    char        *path = NULL;
    char        *connection = NULL;
    int     state = -1;
    int     flags = 0;
    int     opt, rv;

    /* Parse command line options */
    parse_common(argc, argv, usage_str);
    while ((opt = getopt_clip(argc, argv, "fqs:", changestate_opts,
        NULL)) != -1) {
        switch (opt) {
        case 'f':
            flags |= HPFORCE;
            break;
        case 'q':
            flags |= HPQUERY;
            break;
        case 's':
            if ((state = state_atoi(optarg)) == -1) {
                (void) printf("ERROR: invalid target state\n");
                return (EINVAL);
            }
            break;
        default:
            bad_option(opt, optopt, usage_str);
            break;
        }
    }
    parse_target(argc, argv, &path, &connection, usage_str);

    /* State, path, and connection are all required */
    if ((state == -1) || (path == NULL) || (connection == NULL)) {
        (void) fprintf(stderr, gettext("ERROR: too few arguments.\n"));
        usage(usage_str);
        return (EINVAL);
    }

    /* Check that target state is valid */
    if (valid_target(state) == 0) {
        (void) fprintf(stderr,
            gettext("ERROR: invalid target state\n"));
        return (EINVAL);
    }

    /* Get hotplug information snapshot */
    if ((root = hp_init(path, connection, 0)) == NULL) {
        print_error(errno);
        return (errno);
    }

    /* Initiate state change operation on root of snapshot */
    rv = hp_set_state(root, flags, state, &results);

    /* Display results */
    print_error(rv);
    if (results) {
        (void) hp_traverse(results, NULL, error_cb);
        hp_fini(results);
    }

    /* Discard hotplug information snapshot */
    hp_fini(root);

    return (rv);
}

/*
 * parse_common()
 *
 *  Parse command line options that are common to the
 *  entire program, and to each of its subcommands.
 */
static void
parse_common(int argc, char *argv[], const char *usage_str)
{
    int     opt;
    extern int  opterr;
    extern int  optind;

    /* Turn off error reporting */
    opterr = 0;

    while ((opt = getopt_clip(argc, argv, "?V", common_opts, NULL)) != -1) {
        switch (opt) {
        case '?':
            if (optopt == '?') {
                usage(usage_str);
                exit(0);
            }
            break;
        case 'V':
            (void) printf(gettext("%s: Version %s\n"),
                prog, version);
            exit(0);
        default:
            break;
        }
    }

    /* Reset option index */
    optind = 1;
}

/*
 * parse_flags()
 *
 *  Parse command line flags common to all downward state
 *  change operations (offline, disable, poweoff).
 */
static void
parse_flags(int argc, char *argv[], int *flagsp, const char *usage_str)
{
    int opt;
    int flags = 0;

    while ((opt = getopt_clip(argc, argv, "fq", flag_opts, NULL)) != -1) {
        switch (opt) {
        case 'f':
            flags |= HPFORCE;
            break;
        case 'q':
            flags |= HPQUERY;
            break;
        default:
            bad_option(opt, optopt, usage_str);
            break;
        }
    }

    *flagsp = flags;
}

/*
 * parse_options()
 *
 *  Parse command line options common to the bus private set and
 *  get subcommands.
 */
static void
parse_options(int argc, char *argv[], char **optionsp, const char *usage_str)
{
    int opt;

    while ((opt = getopt_clip(argc, argv, "o:", private_opts,
        NULL)) != -1) {
        switch (opt) {
        case 'o':
            *optionsp = optarg;
            break;
        default:
            bad_option(opt, optopt, usage_str);
            break;
        }
    }
}

/*
 * parse_target()
 *
 *  Parse the target path and connection name from the command line.
 */
static void
parse_target(int argc, char *argv[], char **pathp, char **connectionp,
    const char *usage_str)
{
    extern int  optind;

    if (optind < argc)
        *pathp = argv[optind++];

    if (optind < argc)
        *connectionp = argv[optind++];

    if (optind < argc) {
        (void) fprintf(stderr, gettext("ERROR: too many arguments.\n"));
        usage(usage_str);
        exit(EINVAL);
    }
}

/*
 * bad_option()
 *
 *  Routine to handle bad command line options.
 */
static void
bad_option(int opt, int optopt, const char *usage_str)
{
    switch (opt) {
    case ':':
        (void) fprintf(stderr,
            gettext("ERROR: option '%c' requires an argument.\n"),
            optopt);
        break;
    default:
        if (optopt == '?') {
            usage(usage_str);
            exit(EXIT_OK);
        }
        (void) fprintf(stderr,
            gettext("ERROR: unrecognized option '%c'.\n"), optopt);
        break;
    }

    usage(usage_str);

    exit(EXIT_EINVAL);
}

/*
 * usage()
 *
 *  Display general usage of the command.  Including
 *  the usage synopsis of each defined subcommand.
 */
static void
usage(const char *usage_str)
{
    int i;

    if (usage_str != NULL) {
        (void) fprintf(stderr, gettext("Usage:   %s  %s\n\n"),
            prog, usage_str);
        return;
    }

    (void) fprintf(stderr, gettext("Usage:  %s  <subcommand> [<args>]\n\n"),
        prog);

    (void) fprintf(stderr, gettext("Subcommands:\n\n"));

    for (i = 0; i < (sizeof (subcmds) / sizeof (subcmd_t)); i++)
        (void) fprintf(stderr, "   %s\n\n", subcmds[i].usage_str);
}

/*
 * list_cb()
 *
 *  Callback function for hp_traverse(), to display nodes
 *  of a hotplug information snapshot.  (Short version.)
 */
/*ARGSUSED*/
static int
list_cb(hp_node_t node, void *arg)
{
    hp_node_t   parent;

    /* Indent */
    for (parent = hp_parent(node); parent; parent = hp_parent(parent))
        if (hp_type(parent) == HP_NODE_DEVICE)
            (void) printf("     ");

    switch (hp_type(node)) {
    case HP_NODE_DEVICE:
        (void) printf("%s\n", hp_name(node));
        break;

    case HP_NODE_CONNECTOR:
        (void) printf("[%s]", hp_name(node));
        (void) printf("  (%s)", state_itoa(hp_state(node)));
        (void) printf("\n");
        break;

    case HP_NODE_PORT:
        (void) printf("<%s>", hp_name(node));
        (void) printf("  (%s)", state_itoa(hp_state(node)));
        (void) printf("\n");
        break;

    case HP_NODE_USAGE:
        (void) printf("{ %s }\n", hp_usage(node));
        break;
    }

    return (HP_WALK_CONTINUE);
}

/*
 * list_long_cb()
 *
 *  Callback function for hp_traverse(), to display nodes
 *  of a hotplug information snapshot.  (Long version.)
 */
/*ARGSUSED*/
static int
list_long_cb(hp_node_t node, void *arg)
{
    char    path[MAXPATHLEN];
    char    connection[MAXPATHLEN];

    if (hp_type(node) != HP_NODE_USAGE) {
        if (hp_path(node, path, connection) != 0)
            return (HP_WALK_CONTINUE);
        (void) printf("%s", path);
    }

    switch (hp_type(node)) {
    case HP_NODE_CONNECTOR:
        (void) printf(" [%s]", connection);
        (void) printf(" (%s)", state_itoa(hp_state(node)));
        break;

    case HP_NODE_PORT:
        (void) printf(" <%s>", connection);
        (void) printf(" (%s)", state_itoa(hp_state(node)));
        break;

    case HP_NODE_USAGE:
        (void) printf("    { %s }", hp_usage(node));
        break;
    }

    (void) printf("\n");

    return (HP_WALK_CONTINUE);
}

/*
 * error_cb()
 *
 *  Callback function for hp_traverse(), to display
 *  error results from a state change operation.
 */
/*ARGSUSED*/
static int
error_cb(hp_node_t node, void *arg)
{
    hp_node_t   child;
    char        *usage_str;
    static char path[MAXPATHLEN];
    static char connection[MAXPATHLEN];

    if (((child = hp_child(node)) != NULL) &&
        (hp_type(child) == HP_NODE_USAGE)) {
        if (hp_path(node, path, connection) == 0)
            (void) printf("%s:\n", path);
        return (HP_WALK_CONTINUE);
    }

    if ((hp_type(node) == HP_NODE_USAGE) &&
        ((usage_str = hp_usage(node)) != NULL))
        (void) printf("   { %s }\n", usage_str);

    return (HP_WALK_CONTINUE);
}

/*
 * print_options()
 *
 *  Parse and display bus private options.  The options are
 *  formatted as a string which conforms to the getsubopt(3C)
 *  format.  This routine only splits the string elements as
 *  separated by commas, and displays each portion on its own
 *  separate line of output.
 */
static void
print_options(const char *options)
{
    char    *buf, *curr, *next;
    size_t  len;

    /* Do nothing if options string is empty */
    if ((len = strlen(options)) == 0)
        return;

    /* To avoid modifying the input string, make a copy on the stack */
    if ((buf = (char *)alloca(len + 1)) == NULL) {
        (void) printf("%s\n", options);
        return;
    }
    (void) strlcpy(buf, options, len + 1);

    /* Iterate through each comma-separated name/value pair */
    curr = buf;
    do {
        if ((next = strchr(curr, ',')) != NULL) {
            *next = '\0';
            next++;
        }
        (void) printf("%s\n", curr);
    } while ((curr = next) != NULL);
}

/*
 * print_error()
 *
 *  Common routine to print error numbers in an appropriate way.
 *  Prints nothing if error code is 0.
 */
static void
print_error(int error)
{
    switch (error) {
    case 0:
        /* No error */
        return;
    case EACCES:
        (void) fprintf(stderr,
            gettext("ERROR: operation not authorized.\n"));
        break;
    case EBADF:
        (void) fprintf(stderr,
            gettext("ERROR: hotplug service is not available.\n"));
        break;
    case EBUSY:
        (void) fprintf(stderr,
            gettext("ERROR: devices or resources are busy.\n"));
        break;
    case EEXIST:
        (void) fprintf(stderr,
            gettext("ERROR: resource already exists.\n"));
        break;
    case EFAULT:
        (void) fprintf(stderr,
            gettext("ERROR: internal failure in hotplug service.\n"));
        break;
    case EINVAL:
        (void) fprintf(stderr,
            gettext("ERROR: invalid arguments.\n"));
        break;
    case ENOENT:
        (void) fprintf(stderr,
            gettext("ERROR: there are no connections to display.\n"));
        (void) fprintf(stderr,
            gettext("(See hotplug(1m) for more information.)\n"));
        break;
    case ENXIO:
        (void) fprintf(stderr,
            gettext("ERROR: no such path or connection.\n"));
        break;
    case ENOMEM:
        (void) fprintf(stderr,
            gettext("ERROR: not enough memory.\n"));
        break;
    case ENOTSUP:
        (void) fprintf(stderr,
            gettext("ERROR: operation not supported.\n"));
        break;
    case EIO:
        (void) fprintf(stderr,
            gettext("ERROR: hardware or driver specific failure.\n"));
        break;
    default:
        (void) fprintf(stderr, gettext("ERROR: operation failed: %s\n"),
            strerror(error));
        break;
    }
}

/*
 * state_atoi()
 *
 *  Convert a hotplug state from a string to an integer.
 */
static int
state_atoi(char *state)
{
    int i;

    for (i = 0; hpstates[i].state_str != NULL; i++)
        if (strcasecmp(state, hpstates[i].state_str) == 0)
            return (hpstates[i].state);

    return (-1);
}

/*
 * state_itoa()
 *
 *  Convert a hotplug state from an integer to a string.
 */
static char *
state_itoa(int state)
{
    static char unknown[] = "UNKNOWN";
    int     i;

    for (i = 0; hpstates[i].state_str != NULL; i++)
        if (state == hpstates[i].state)
            return (hpstates[i].state_str);

    return (unknown);
}

/*
 * valid_target()
 *
 *  Check if a state is a valid target for a changestate command.
 */
static short
valid_target(int state)
{
    int i;

    for (i = 0; hpstates[i].state_str != NULL; i++)
        if (state == hpstates[i].state)
            return (hpstates[i].valid_target);

    return (0);
}