/*
 * 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 (c) 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * nwamadm is a command interpreter to administer NWAM profiles.  It
 * is all in C (i.e., no lex/yacc), and all the argument passing is
 * argc/argv based.  main() calls the command's handler function,
 * which first calls parse_argv() to parse the input arguments and set
 * approriate variables for each command.  The rest of the program is
 * helper functions for the handler functions.
 */

#include <arpa/inet.h>
#include <assert.h>
#include <errno.h>
#include <libdlwlan.h>
#include <libinetutil.h>
#include <libnwam.h>
#include <libscf.h>
#include <locale.h>
#include <netinet/in.h>
#include <ofmt.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

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

typedef void (cmd_func_t)(int, char **);

struct cmd {
        uint_t          cmd_num;                /* command number */
        const char      *cmd_name;              /* command name */
        cmd_func_t      *cmd_handler;           /* function to call */
        const char      *cmd_usage;             /* short form help */
        const char      *cmd_desc;              /* command description */
        boolean_t       cmd_needs_nwamd;        /* nwam needs to run */
};

/* constants for commands */
#define CMD_HELP        0
#define CMD_ENABLE      1
#define CMD_DISABLE     2
#define CMD_LIST        3
#define CMD_SHOW_EVENTS 4
#define CMD_SCAN_WIFI   5
#define CMD_SELECT_WIFI 6

#define CMD_MIN         CMD_HELP
#define CMD_MAX         CMD_SELECT_WIFI

/* functions to call */
static cmd_func_t help_func, enable_func, disable_func, list_func;
static cmd_func_t show_events_func, scan_wifi_func, select_wifi_func;
static ofmt_cb_t print_list_cb;

/* table of commands and usage */
static struct cmd cmdtab[] = {
        { CMD_HELP,             "help",         help_func,
            "help",
            "Print this usage message.",                B_FALSE         },
        { CMD_ENABLE,           "enable",       enable_func,
            "enable [-p <profile-type>] [-c <ncu-class>] <object-name>",
            "Enable the specified profile.",            B_FALSE         },
        { CMD_DISABLE,          "disable",      disable_func,
            "disable [-p <profile-type>] [-c <ncu-class>] <object-name>",
            "Disable the specified profile.",           B_FALSE         },
        { CMD_LIST,             "list",         list_func,
            "list [-x] [-p <profile-type>] [-c <ncu-class>] [<object-name>]",
            "List profiles and their current states.",  B_TRUE          },
        { CMD_SHOW_EVENTS,      "show-events",  show_events_func,
            "show-events",
            "Display all events.",                      B_TRUE          },
        { CMD_SCAN_WIFI,        "scan-wifi",    scan_wifi_func,
            "scan-wifi <link-name>",
            "Request a WiFi scan for the selected link.", B_TRUE        },
        { CMD_SELECT_WIFI,      "select-wifi",  select_wifi_func,
            "select-wifi <link-name>",
            "Make a WLAN selection from the last WiFi scan.", B_TRUE    }
};

/* Structure for "nwamadm list" output */

typedef struct profile_entry {
        nwam_object_type_t      p_type;
        nwam_ncu_class_t        p_ncu_class;
        char                    p_name[NWAM_MAX_NAME_LEN];
        nwam_state_t            p_state;
        nwam_aux_state_t        p_aux_state;
} profile_entry_t;

/* widths of colums for printing */
#define TYPE_WIDTH              12      /* width of TYPE column */
#define PROFILE_WIDTH           15      /* width of PROFILE column */
#define STATE_WIDTH             15      /* width of STATE column */
#define AUXSTATE_WIDTH          36      /* width of AUXILIARY STATE column */

#define EVENT_WIDTH             15      /* width of EVENT column */
#define DESCRIPTION_WIDTH       64      /* width of DESCRIPTION column */

/* id for columns of "nwamadm list" */
typedef enum {
        LIST_TYPE,
        LIST_PROFILE,
        LIST_STATE,
        LIST_AUXSTATE
} list_field_id_t;

static const ofmt_field_t list_fields[] = {
        /* header,              width,          id,             callback */
        { "TYPE",               TYPE_WIDTH,     LIST_TYPE,      print_list_cb },
        { "PROFILE",            PROFILE_WIDTH,  LIST_PROFILE,   print_list_cb },
        { "STATE",              STATE_WIDTH,    LIST_STATE,     print_list_cb },
        { "AUXILIARY STATE",    AUXSTATE_WIDTH, LIST_AUXSTATE,  print_list_cb },
        { NULL,                 0,              0,              NULL }
};

/* Global variables */

/* set early in main(), never modified thereafter, used all over the place */
static char *execname;

/* whether the auxilary states are to be printed or not */
static boolean_t extended_list = B_FALSE;

/* Functions */

static const char *
cmd_to_str(int cmd_num)
{
        assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX);
        return (cmdtab[cmd_num].cmd_name);
}

/* returns description of given command */
static const char *
long_help(int cmd_num)
{
        assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX);
        return (gettext(cmdtab[cmd_num].cmd_desc));
}

/*
 * Called with explicit B_TRUE when help is explicitly required,
 * B_FALSE for errors
 */
static void
usage(boolean_t explicit)
{
        int     i;
        FILE    *fd = explicit ? stdout : stderr;

        (void) fprintf(fd, gettext("usage: <subcommand> <args> ...\n"));
        for (i = CMD_MIN; i <= CMD_MAX; i++) {
                (void) fprintf(fd, "\t%s\n", cmdtab[i].cmd_usage);
                if (explicit)
                        (void) fprintf(fd, "\t\t%s\n\n", long_help(i));
        }
}

/* PRINTFLIKE1 */
static void
die(const char *format, ...)
{
        va_list alist;

        format = gettext(format);
        (void) fprintf(stderr, "%s: ", execname);

        va_start(alist, format);
        (void) vfprintf(stderr, format, alist);
        va_end(alist);
        (void) fprintf(stderr, "\n");

        exit(EXIT_FAILURE);
}

/* PRINTFLIKE2 */
static void
die_nwamerr(nwam_error_t err, const char *format, ...)
{
        va_list alist;

        format = gettext(format);
        (void) fprintf(stderr, "%s: ", execname);

        va_start(alist, format);
        (void) vfprintf(stderr, format, alist);
        va_end(alist);
        (void) fprintf(stderr, ": %s\n", nwam_strerror(err));

        exit(EXIT_FAILURE);
}

/* prints the usage for cmd_num and exits */
static void
die_usage(int cmd_num)
{
        assert(cmd_num >= CMD_MIN && cmd_num <= CMD_MAX);

        (void) fprintf(stderr, "%s: %s\n", gettext("usage"),
            cmdtab[cmd_num].cmd_usage);
        (void) fprintf(stderr, "\t%s\n", long_help(cmd_num));

        exit(EXIT_FAILURE);
}

/*
 * Prints the usage and description of all commands
 */
/* ARGSUSED */
static void
help_func(int argc, char *argv[])
{
        usage(B_TRUE);
}

/* determines if the NCP is active or not.  If so, sets arg and halts walk. */
static int
active_ncp_callback(nwam_ncp_handle_t ncph, void *arg)
{
        char                    **namep = arg;
        nwam_state_t            state = NWAM_STATE_UNINITIALIZED;
        nwam_aux_state_t        aux;

        (void) nwam_ncp_get_state(ncph, &state, &aux);
        if (state == NWAM_STATE_ONLINE) {
                if (nwam_ncp_get_name(ncph, namep) != NWAM_SUCCESS)
                        *namep = NULL;
                return (1);
        }

        return (0);
}

/* find the currently active NCP and returns its handle */
static nwam_ncp_handle_t
determine_active_ncp()
{
        char *active_ncp;
        nwam_ncp_handle_t ncph;
        nwam_error_t ret;

        if (nwam_walk_ncps(active_ncp_callback, &active_ncp, 0, NULL)
            == NWAM_WALK_HALTED) {
                if (active_ncp == NULL)
                        return (NULL);

                /* retrieve the NCP handle */
                ret = nwam_ncp_read(active_ncp, 0, &ncph);
                free(active_ncp);
                if (ret == NWAM_SUCCESS)
                        return (ncph);
        }

        return (NULL);
}

/* check if the given name is a valid loc, test by reading the given loc */
static boolean_t
valid_loc(const char *name)
{
        nwam_loc_handle_t loch;

        if (nwam_loc_read(name, 0, &loch) != NWAM_SUCCESS)
                return (B_FALSE);
        nwam_loc_free(loch);
        return (B_TRUE);
}

static boolean_t
valid_enm(const char *name)
{
        nwam_enm_handle_t enmh;

        if (nwam_enm_read(name, 0, &enmh) != NWAM_SUCCESS)
                return (B_FALSE);
        nwam_enm_free(enmh);
        return (B_TRUE);
}

static boolean_t
valid_ncp(const char *name)
{
        nwam_ncp_handle_t ncph;

        if (nwam_ncp_read(name, 0, &ncph) != NWAM_SUCCESS)
                return (B_FALSE);
        nwam_ncp_free(ncph);
        return (B_TRUE);
}

static boolean_t
valid_ncu(const char *name)
{
        nwam_ncp_handle_t ncph;
        nwam_ncu_handle_t ncuh;
        nwam_error_t    ret;

        if ((ncph = determine_active_ncp()) == NULL)
                return (B_FALSE);

        ret = nwam_ncu_read(ncph, name, NWAM_NCU_TYPE_ANY, 0, &ncuh);
        nwam_ncp_free(ncph);
        if (ret != NWAM_SUCCESS && ret != NWAM_ENTITY_MULTIPLE_VALUES)
                return (B_FALSE);
        nwam_ncu_free(ncuh);
        return (B_TRUE);
}

/*
 * Given a name, returns object type (loc, enm, ncp, or ncu) and how many
 * objects matched that name.
 */
static nwam_object_type_t
determine_object_type(const char *name, int *num)
{
        nwam_object_type_t type;
        int n = 0;

        /* see if a valid loc, enm, ncp and/or ncu exists with given name */
        if (valid_loc(name)) {
                n++;
                type = NWAM_OBJECT_TYPE_LOC;
        }
        if (valid_enm(name)) {
                n++;
                type = NWAM_OBJECT_TYPE_ENM;
        }
        if (valid_ncp(name)) {
                n++;
                type = NWAM_OBJECT_TYPE_NCP;
        }
        if (valid_ncu(name)) {
                n++;
                type = NWAM_OBJECT_TYPE_NCU;
        }

        /* if n > 1, then it means *type was set multiple times, undo it */
        if (n != 1)
                type = NWAM_OBJECT_TYPE_UNKNOWN;

        *num = n;
        return (type);
}

/*
 * Parses argv array and populates object_type and name.
 * Program exits on failure.
 */
static void
parse_argv(int argc, char *argv[], int cmd_num, nwam_object_type_t *object_type,
    nwam_ncu_type_t *ncu_type, nwam_ncu_class_t *ncu_class, const char **name)
{
        int                     arg;
        nwam_object_type_t      type = NWAM_OBJECT_TYPE_UNKNOWN;
        uint64_t                ncu = NWAM_NCU_TYPE_ANY;
        uint64_t                class = NWAM_NCU_CLASS_ANY;

        /* check argv for option */
        optind = 0;
        while ((arg = getopt(argc, argv, "?p:c:x")) != EOF) {
                switch (arg) {
                case 'p':
                        type = nwam_string_to_object_type(optarg);
                        if (type == NWAM_OBJECT_TYPE_UNKNOWN)
                                die("Invalid profile-type: %s", optarg);
                        break;
                case 'c':
                        if (nwam_value_string_get_uint64(NWAM_NCU_PROP_CLASS,
                            optarg, &class) != NWAM_SUCCESS) {
                                die("Invalid ncu-class: %s", optarg);
                        }
                        ncu = nwam_ncu_class_to_type(class);
                        if (ncu == NWAM_NCU_TYPE_ANY ||
                            ncu == NWAM_NCU_TYPE_UNKNOWN)
                                die("Invalid ncu-class: %s", optarg);
                        break;
                case 'x':
                        /* -x is only for list */
                        if (cmd_num != CMD_LIST)
                                die("-x can only be used with 'list'");
                        extended_list = B_TRUE;
                        break;
                case '?':
                default:
                        die_usage(cmd_num);
                }
        }

        if (ncu != NWAM_NCU_TYPE_ANY) {
                /* If -c is given, -p must be NCU. If unspecified, assume NCU */
                if (type != NWAM_OBJECT_TYPE_UNKNOWN &&
                    type != NWAM_OBJECT_TYPE_NCU)
                        die("'-c <ncu-class>' can only be used for ncu");

                type = NWAM_OBJECT_TYPE_NCU;
        }

        /* name is mandatory for enable and disable, but not for list */
        if (optind == (argc-1))
                *name = argv[optind];
        else if (argc != optind)
                die("too many profile names given");
        else if (cmd_num != CMD_LIST)
                die("no profile name given");

        /*
         * No need to determine type for list.
         * If -p is not given for enable or disable, then determine type.
         */
        if (cmd_num != CMD_LIST && type == NWAM_OBJECT_TYPE_UNKNOWN) {
                int num = 0;

                type = determine_object_type(*name, &num);
                if (num == 0) {
                        die("no profile matched '%s'", *name);
                } else if (num > 1) {
                        die("more than one profile matched '%s' - use "
                            "'-p <profile-type>' to specify a profile type.",
                            *name);
                }
        }

        *object_type = type;
        *ncu_type = ncu;
        *ncu_class = class;
}

/* Enables/Disables profiles depending on boolean */
static nwam_error_t
loc_action(const char *name, boolean_t enable, char **realnamep)
{
        nwam_loc_handle_t loch;
        nwam_error_t ret;

        if ((ret = nwam_loc_read(name, 0, &loch)) != NWAM_SUCCESS)
                return (ret);

        if (enable)
                ret = nwam_loc_enable(loch);
        else
                ret = nwam_loc_disable(loch);

        (void) nwam_loc_get_name(loch, realnamep);
        nwam_loc_free(loch);
        return (ret);
}

static nwam_error_t
enm_action(const char *name, boolean_t enable, char **realnamep)
{
        nwam_enm_handle_t enmh;
        nwam_error_t ret;

        if ((ret = nwam_enm_read(name, 0, &enmh)) != NWAM_SUCCESS)
                return (ret);

        if (enable)
                ret = nwam_enm_enable(enmh);
        else
                ret = nwam_enm_disable(enmh);

        (void) nwam_enm_get_name(enmh, realnamep);
        nwam_enm_free(enmh);
        return (ret);
}

static nwam_error_t
ncu_action(const char *name, nwam_ncp_handle_t ncph, nwam_ncu_type_t type,
    boolean_t enable, char **realnamep)
{
        nwam_ncu_handle_t ncuh;
        nwam_error_t ret;
        boolean_t retrieved_ncph = B_FALSE;

        if (ncph == NULL) {
                if ((ncph = determine_active_ncp()) == NULL)
                        return (NWAM_ENTITY_NOT_FOUND);
                retrieved_ncph = B_TRUE;
        }

        ret = nwam_ncu_read(ncph, name, type, 0, &ncuh);
        switch (ret) {
        case NWAM_SUCCESS:
                if (enable)
                        ret = nwam_ncu_enable(ncuh);
                else
                        ret = nwam_ncu_disable(ncuh);
                (void) nwam_ncu_get_name(ncuh, realnamep);
                nwam_ncu_free(ncuh);
                break;
        case NWAM_ENTITY_MULTIPLE_VALUES:
                /* Call ncu_action() for link and interface types */
                ret = ncu_action(name, ncph, NWAM_NCU_TYPE_LINK, enable,
                    realnamep);
                if (ret != NWAM_SUCCESS)
                        break;

                ret = ncu_action(name, ncph, NWAM_NCU_TYPE_INTERFACE, enable,
                    realnamep);
                break;
        }
        if (retrieved_ncph)
                nwam_ncp_free(ncph);

        return (ret);
}

/*
 * If more than one type of profile with the same name, return error.
 * In such situations, the -p option must be used.
 * If a location is enabled when a different one is already enabled, then
 * that location is disabled automatically by nwamd.
 */
static void
enable_func(int argc, char *argv[])
{
        nwam_error_t            ret;
        nwam_object_type_t      type = NWAM_OBJECT_TYPE_UNKNOWN;
        nwam_ncu_type_t         ncu_type = NWAM_NCU_TYPE_ANY;
        nwam_ncu_class_t        ncu_class = NWAM_NCU_CLASS_ANY;
        const char              *name;
        char                    *realname = NULL;

        /* parse_argv() returns only on success */
        parse_argv(argc, argv, CMD_ENABLE, &type, &ncu_type, &ncu_class, &name);

        /*
         * NCPs and Locations don't need to disable the currently active
         * profile - nwamd automatically switches to the new active profile.
         * and will disable it if necessary.
         */

        /* activate given profile */
        switch (type) {
        case NWAM_OBJECT_TYPE_LOC:
                ret = loc_action(name, B_TRUE, &realname);
                break;
        case NWAM_OBJECT_TYPE_ENM:
                ret = enm_action(name, B_TRUE, &realname);
                break;
        case NWAM_OBJECT_TYPE_NCP:
        {
                nwam_ncp_handle_t ncph;

                if ((ret = nwam_ncp_read(name, 0, &ncph)) != NWAM_SUCCESS)
                        break;

                ret = nwam_ncp_enable(ncph);
                (void) nwam_ncp_get_name(ncph, &realname);
                nwam_ncp_free(ncph);
                break;
        }
        case NWAM_OBJECT_TYPE_NCU:
                ret = ncu_action(name, NULL, ncu_type, B_TRUE, &realname);
                break;
        }

        switch (ret) {
        case NWAM_SUCCESS:
                (void) printf(gettext("Enabling %s '%s'\n"),
                    nwam_object_type_to_string(type),
                    realname != NULL ? realname : name);
                break;
        case NWAM_ENTITY_NOT_MANUAL:
                die("Only profiles with manual activation-mode can be enabled");
                break;
        default:
                die_nwamerr(ret, "Could not enable %s '%s'",
                    nwam_object_type_to_string(type),
                    realname != NULL ? realname : name);
        }
        free(realname);
}

/*
 * Disables a given profile.  Similar to enable, the -p option must be used
 * if more than one type of profile is matched by the given name.
 */
static void
disable_func(int argc, char *argv[])
{
        nwam_error_t            ret;
        nwam_object_type_t      type = NWAM_OBJECT_TYPE_UNKNOWN;
        nwam_ncu_type_t         ncu_type = NWAM_NCU_TYPE_ANY;
        nwam_ncu_class_t        ncu_class = NWAM_NCU_CLASS_ANY;
        const char              *name;
        char                    *realname = NULL;

        /* parse_argv() returns only on success */
        parse_argv(argc, argv, CMD_DISABLE, &type, &ncu_type, &ncu_class,
            &name);

        /* deactivate the given profile */
        switch (type) {
        case NWAM_OBJECT_TYPE_LOC:
                ret = loc_action(name, B_FALSE, &realname);
                break;
        case NWAM_OBJECT_TYPE_ENM:
                ret = enm_action(name, B_FALSE, &realname);
                break;
        case NWAM_OBJECT_TYPE_NCU:
                ret = ncu_action(name, NULL, ncu_type, B_FALSE, &realname);
                break;
        case NWAM_OBJECT_TYPE_NCP:
                die("ncp's cannot be disabled.  Enable a different ncp to "
                    "switch to that ncp");
        }

        switch (ret) {
        case NWAM_SUCCESS:
                (void) printf(gettext("Disabling %s '%s'\n"),
                    nwam_object_type_to_string(type),
                    realname != NULL ? realname : name);
                break;
        case NWAM_ENTITY_NOT_MANUAL:
                die("Only profiles with manual activation-mode can be "
                    "disabled");
                break;
        default:
                die_nwamerr(ret, "Could not disable %s '%s'",
                    nwam_object_type_to_string(type),
                    realname != NULL ? realname : name);
        }
        free(realname);
}

/* prints each column */
static boolean_t
print_list_cb(ofmt_arg_t *ofarg, char *buf, uint_t bufsize)
{
        profile_entry_t *pent = ofarg->ofmt_cbarg;

        switch (ofarg->ofmt_id) {
        case LIST_TYPE:
                /* ncu:ip or ncu:phys for NCUs; ncp, loc, enm for others */
                if (pent->p_type == NWAM_OBJECT_TYPE_NCU) {
                        const char *class;
                        if (nwam_uint64_get_value_string(NWAM_NCU_PROP_CLASS,
                            pent->p_ncu_class, &class) != NWAM_SUCCESS)
                                class = ""; /* empty */
                        (void) snprintf(buf, bufsize, "%s:%s",
                            nwam_object_type_to_string(pent->p_type), class);
                } else {
                        (void) strlcpy(buf,
                            nwam_object_type_to_string(pent->p_type), bufsize);
                }
                break;
        case LIST_PROFILE:
                (void) strlcpy(buf, pent->p_name, bufsize);
                break;
        case LIST_STATE:
                (void) strlcpy(buf, nwam_state_to_string(pent->p_state),
                    bufsize);
                break;
        case LIST_AUXSTATE:
                (void) strlcpy(buf,
                    nwam_aux_state_to_string(pent->p_aux_state), bufsize);
                break;
        default:
                die("invalid print_list_cb() input: %d", ofarg->ofmt_id);
                break;
        }
        return (B_TRUE);
}

/* returns the state and auxilliary state of the object */
static nwam_state_t
determine_object_state(nwam_object_type_t type, void *handle,
    nwam_aux_state_t *aux_statep)
{
        nwam_state_t state;
        nwam_aux_state_t astate;
        nwam_error_t ret;

        switch (type) {
        case NWAM_OBJECT_TYPE_ENM:
                ret = nwam_enm_get_state(handle, &state, &astate);
                break;
        case NWAM_OBJECT_TYPE_LOC:
                ret = nwam_loc_get_state(handle, &state, &astate);
                break;
        case NWAM_OBJECT_TYPE_NCP:
                ret = nwam_ncp_get_state(handle, &state, &astate);
                break;
        case NWAM_OBJECT_TYPE_NCU:
                ret = nwam_ncu_get_state(handle, &state, &astate);
                break;
        default:
                /* NOTREACHED */
                break;
        }

        if (ret == NWAM_PERMISSION_DENIED) {
                die_nwamerr(ret, "could not get object state");
        } else if (ret != NWAM_SUCCESS) {
                state = NWAM_STATE_UNINITIALIZED;
                astate = NWAM_AUX_STATE_UNINITIALIZED;
        }

        if (aux_statep != NULL)
                *aux_statep = astate;
        return (state);
}

/* populate profile_entry_t with values for object with given handle */
static int
add_to_profile_entry(nwam_object_type_t type, void *handle,
    profile_entry_t *pent)
{
        char            *name;
        nwam_error_t    ret;

        pent->p_type = type;
        if (type == NWAM_OBJECT_TYPE_NCU) {
                nwam_ncu_class_t class;
                if ((ret = nwam_ncu_get_ncu_class(handle, &class))
                    != NWAM_SUCCESS)
                        return (ret);
                pent->p_ncu_class = class;
        } else {
                pent->p_ncu_class = -1;
        }

        switch (type) {
        case NWAM_OBJECT_TYPE_ENM:
                ret = nwam_enm_get_name(handle, &name);
                break;
        case NWAM_OBJECT_TYPE_LOC:
                ret = nwam_loc_get_name(handle, &name);
                break;
        case NWAM_OBJECT_TYPE_NCP:
                ret = nwam_ncp_get_name(handle, &name);
                break;
        case NWAM_OBJECT_TYPE_NCU:
                ret = nwam_ncu_get_name(handle, &name);
                break;
        default:
                /* NOTREACHED */
                break;
        }
        if (ret != NWAM_SUCCESS) {
                return (ret);
        }
        (void) strlcpy(pent->p_name, name, sizeof (pent->p_name));
        free(name);

        pent->p_state = determine_object_state(type, handle,
            &pent->p_aux_state);

        return (NWAM_SUCCESS);
}

/* callback functions used by walk */

static int
list_ncu_cb(nwam_ncu_handle_t ncuh, void *arg)
{
        ofmt_handle_t   ofmt = arg;
        profile_entry_t pent;
        nwam_error_t    ret;

        bzero(&pent, sizeof (profile_entry_t));
        ret = add_to_profile_entry(NWAM_OBJECT_TYPE_NCU, ncuh, &pent);
        if (ret != NWAM_SUCCESS)
                die_nwamerr(ret, "could not add ncu to list");
        ofmt_print(ofmt, &pent);
        return (0);
}

static int
list_ncp_cb(nwam_ncp_handle_t ncph, void *arg)
{
        ofmt_handle_t   ofmt = arg;
        profile_entry_t pent;
        nwam_error_t    ret;
        nwam_state_t    state;

        bzero(&pent, sizeof (profile_entry_t));
        ret = add_to_profile_entry(NWAM_OBJECT_TYPE_NCP, ncph, &pent);
        if (ret != NWAM_SUCCESS)
                die_nwamerr(ret, "could not add ncp to list");
        ofmt_print(ofmt, &pent);

        state = determine_object_state(NWAM_OBJECT_TYPE_NCP, ncph, NULL);
        if (state == NWAM_STATE_ONLINE) {
                (void) nwam_ncp_walk_ncus(ncph, list_ncu_cb, ofmt,
                    NWAM_FLAG_NCU_TYPE_ALL, NULL);
        }
        return (0);
}

static int
list_loc_cb(nwam_loc_handle_t loch, void *arg)
{
        ofmt_handle_t   ofmt = arg;
        profile_entry_t pent;
        nwam_error_t    ret;

        bzero(&pent, sizeof (profile_entry_t));
        ret = add_to_profile_entry(NWAM_OBJECT_TYPE_LOC, loch, &pent);
        if (ret != NWAM_SUCCESS)
                die_nwamerr(ret, "could not add loc to list");
        ofmt_print(ofmt, &pent);
        return (0);
}

static int
list_enm_cb(nwam_enm_handle_t enmh, void *arg)
{
        ofmt_handle_t   ofmt = arg;
        profile_entry_t pent;
        nwam_error_t    ret;

        bzero(&pent, sizeof (profile_entry_t));
        ret = add_to_profile_entry(NWAM_OBJECT_TYPE_ENM, enmh, &pent);
        if (ret != NWAM_SUCCESS)
                die_nwamerr(ret, "could not add enm to list");
        ofmt_print(ofmt, &pent);
        return (0);
}

/*
 * lists all profiles and their state
 */
static void
list_func(int argc, char *argv[])
{
        nwam_error_t            ret = NWAM_SUCCESS;
        nwam_object_type_t      type = NWAM_OBJECT_TYPE_UNKNOWN;
        nwam_ncu_type_t         ncu_type = NWAM_NCU_TYPE_ANY;
        nwam_ncu_class_t        ncu_class = NWAM_NCU_CLASS_ANY;
        char                    *name = NULL;

        ofmt_handle_t   ofmt;
        ofmt_status_t   oferr;
        char            *default_fields = "type,profile,state";
        char            *extended_fields = "type,profile,state,auxiliary state";
        char            *fields = NULL;

        /* parse_argv() returns only on success */
        parse_argv(argc, argv, CMD_LIST, &type, &ncu_type, &ncu_class,
            (const char **)&name);

        if (extended_list)
                fields = extended_fields;
        else
                fields = default_fields;
        oferr = ofmt_open(fields, list_fields, 0, 0, &ofmt);
        if (oferr != OFMT_SUCCESS) {
                char buf[OFMT_BUFSIZE];
                (void) ofmt_strerror(ofmt, oferr, buf, sizeof (buf));
                die("ofmt_open() failed: %s", buf);
        }

        /* object-name given in command-line */
        if (name != NULL) {
                boolean_t found = B_FALSE;

                /*
                 * If objects with different types have the same name
                 * (type = UNKNOWN), then try to open handle for each object
                 * and print if successful.
                 */
                if (type == NWAM_OBJECT_TYPE_NCP ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        nwam_ncp_handle_t ncph;
                        if (nwam_ncp_read(name, 0, &ncph) == NWAM_SUCCESS) {
                                found = B_TRUE;
                                (void) list_ncp_cb(ncph, ofmt);
                                nwam_ncp_free(ncph);
                        }
                }
                if (type == NWAM_OBJECT_TYPE_NCU ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        nwam_ncp_handle_t ncph;
                        nwam_ncu_handle_t ncuh;

                        if ((ncph = determine_active_ncp()) != NULL) {
                                ret = nwam_ncu_read(ncph, name, ncu_type, 0,
                                    &ncuh);
                                if (ret == NWAM_ENTITY_MULTIPLE_VALUES) {
                                        found = B_TRUE;
                                        if (nwam_ncu_read(ncph, name,
                                            NWAM_NCU_TYPE_LINK, 0, &ncuh)
                                            == NWAM_SUCCESS) {
                                                (void) list_ncu_cb(ncuh, ofmt);
                                                nwam_ncu_free(ncuh);
                                        }
                                        if (nwam_ncu_read(ncph, name,
                                            NWAM_NCU_TYPE_INTERFACE, 0, &ncuh)
                                            == NWAM_SUCCESS) {
                                                (void) list_ncu_cb(ncuh, ofmt);
                                                nwam_ncu_free(ncuh);
                                        }
                                } else if (ret == NWAM_SUCCESS) {
                                        found = B_TRUE;
                                        (void) list_ncu_cb(ncuh, ofmt);
                                        nwam_ncu_free(ncuh);
                                }
                                nwam_ncp_free(ncph);
                        }
                }
                if (type == NWAM_OBJECT_TYPE_LOC ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        nwam_loc_handle_t loch;
                        if (nwam_loc_read(name, 0, &loch) == NWAM_SUCCESS) {
                                found = B_TRUE;
                                (void) list_loc_cb(loch, ofmt);
                                nwam_loc_free(loch);
                        }
                }
                if (type == NWAM_OBJECT_TYPE_ENM ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        nwam_enm_handle_t enmh;
                        if (nwam_enm_read(name, 0, &enmh) == NWAM_SUCCESS) {
                                found = B_TRUE;
                                (void) list_enm_cb(enmh, ofmt);
                                nwam_enm_free(enmh);
                        }
                }
                /* If at least object is found, don't return error */
                if (found)
                        ret = NWAM_SUCCESS;
                else
                        ret = NWAM_ENTITY_NOT_FOUND;
        }

        /* object-name not given in command-line */
        if (name == NULL) {
                /*
                 * If type given (type != UNKNOWN), just walk objects in that
                 * type.  Otherwise, walk all ncp, ncu, loc and enm.
                 */
                if (type == NWAM_OBJECT_TYPE_NCP ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        ret = nwam_walk_ncps(list_ncp_cb, ofmt, 0, NULL);
                        if (ret != NWAM_SUCCESS)
                                goto done;
                }
                /* no UNKNOWN for NCUs.  They walked with active NCP above */
                if (type == NWAM_OBJECT_TYPE_NCU) {
                        nwam_ncp_handle_t ncph;
                        if ((ncph = determine_active_ncp()) != NULL) {
                                ret = nwam_ncp_walk_ncus(ncph, list_ncu_cb,
                                    ofmt, nwam_ncu_class_to_flag(ncu_class),
                                    NULL);
                                nwam_ncp_free(ncph);
                                if (ret != NWAM_SUCCESS)
                                        goto done;
                        }
                }
                if (type == NWAM_OBJECT_TYPE_LOC ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        ret = nwam_walk_locs(list_loc_cb, ofmt,
                            NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
                        if (ret != NWAM_SUCCESS)
                                goto done;
                }
                if (type == NWAM_OBJECT_TYPE_ENM ||
                    type == NWAM_OBJECT_TYPE_UNKNOWN) {
                        ret = nwam_walk_enms(list_enm_cb, ofmt,
                            NWAM_FLAG_ACTIVATION_MODE_ALL, NULL);
                        if (ret != NWAM_SUCCESS)
                                goto done;
                }
        }

done:
        ofmt_close(ofmt);
        if (ret == NWAM_ENTITY_NOT_FOUND && name != NULL)
                die("no profile matched '%s'", name);
        else if (ret != NWAM_SUCCESS)
                die_nwamerr(ret, "list failed during walk");
}

/*
 * Print NWAM events.
 */
static void
eventhandler(nwam_event_t event)
{
        char description[DESCRIPTION_WIDTH];
        char statestr[DESCRIPTION_WIDTH];
        char objstr[DESCRIPTION_WIDTH];
        char *object = NULL;
        const char *action = NULL;
        char *state = NULL;
        boolean_t display = B_TRUE;
        int i;
        nwam_wlan_t *wlans;

        (void) strlcpy(description, "-", sizeof (description));

        switch (event->nwe_type) {
        case NWAM_EVENT_TYPE_OBJECT_ACTION:
                action = nwam_action_to_string
                    (event->nwe_data.nwe_object_action.nwe_action);
                (void) snprintf(objstr, sizeof (objstr), "%s %s",
                    nwam_object_type_to_string
                    (event->nwe_data.nwe_object_action.nwe_object_type),
                    event->nwe_data.nwe_object_action.nwe_name);
                object = objstr;
                break;

        case NWAM_EVENT_TYPE_OBJECT_STATE:
                (void) snprintf(statestr, sizeof (statestr), "%s, %s",
                    nwam_state_to_string
                    (event->nwe_data.nwe_object_state.nwe_state),
                    nwam_aux_state_to_string
                    (event->nwe_data.nwe_object_state.nwe_aux_state));
                state = statestr;

                (void) snprintf(objstr, sizeof (objstr), "%s %s",
                    nwam_object_type_to_string
                    (event->nwe_data.nwe_object_state.nwe_object_type),
                    event->nwe_data.nwe_object_state.nwe_name);
                object = objstr;
                break;

        case NWAM_EVENT_TYPE_PRIORITY_GROUP:
                (void) snprintf(description, DESCRIPTION_WIDTH,
                    "priority-group: %d",
                    event->nwe_data.nwe_priority_group_info.nwe_priority);
                break;

        case NWAM_EVENT_TYPE_WLAN_SCAN_REPORT:
                (void) printf("%-*s \n", EVENT_WIDTH,
                    nwam_event_type_to_string(event->nwe_type));
                wlans = event->nwe_data.nwe_wlan_info.nwe_wlans;
                for (i = 0;
                    i < event->nwe_data.nwe_wlan_info.nwe_num_wlans;
                    i++) {
                        (void) snprintf(description, DESCRIPTION_WIDTH,
                            "%d: %c%c ESSID %s BSSID %s", i + 1,
                            wlans[i].nww_selected ? 'S' : '-',
                            wlans[i].nww_connected ? 'C' : '-',
                            wlans[i].nww_essid, wlans[i].nww_bssid);
                        (void) printf("%-*s %-*s\n", EVENT_WIDTH, "-",
                            DESCRIPTION_WIDTH, description);
                }
                display = B_FALSE;
                break;

        case NWAM_EVENT_TYPE_WLAN_NEED_CHOICE:
                (void) printf("%-*s \n", EVENT_WIDTH,
                    nwam_event_type_to_string(event->nwe_type));
                display = B_FALSE;
                break;

        case NWAM_EVENT_TYPE_WLAN_NEED_KEY:
                (void) printf("%-*s \n", EVENT_WIDTH,
                    nwam_event_type_to_string(event->nwe_type));
                display = B_FALSE;
                break;

        case NWAM_EVENT_TYPE_WLAN_CONNECTION_REPORT:
                (void) snprintf(description, DESCRIPTION_WIDTH,
                    gettext("connect to WLAN ESSID %s, BSSID %s %s"),
                    event->nwe_data.nwe_wlan_info.nwe_wlans[0].nww_essid,
                    event->nwe_data.nwe_wlan_info.nwe_wlans[0].nww_bssid,
                    event->nwe_data.nwe_wlan_info.nwe_connected ?
                    "succeeded" : "failed");
                break;

        case NWAM_EVENT_TYPE_INFO:
                (void) snprintf(description, sizeof (description),
                    "%s", event->nwe_data.nwe_info.nwe_message);
                break;

        case NWAM_EVENT_TYPE_IF_ACTION:
                action = nwam_action_to_string
                    (event->nwe_data.nwe_if_action.nwe_action);
                object = event->nwe_data.nwe_if_action.nwe_name;
                break;

        case NWAM_EVENT_TYPE_IF_STATE:
                object = event->nwe_data.nwe_if_state.nwe_name;
                if (event->nwe_data.nwe_if_state.nwe_addr_valid) {
                        struct sockaddr_storage *address =
                            &(event->nwe_data.nwe_if_state.nwe_addr);
                        struct sockaddr_storage *netmask =
                            &(event->nwe_data.nwe_if_state.nwe_netmask);
                        struct sockaddr_in *v4addr;
                        struct sockaddr_in6 *v6addr;
                        char addrstr[NWAM_MAX_VALUE_LEN];
                        int plen = mask2plen((struct sockaddr *)netmask);

                        switch (address->ss_family) {
                        case AF_INET:
                                v4addr = (struct sockaddr_in *)address;
                                (void) inet_ntop(AF_INET, &v4addr->sin_addr,
                                    addrstr, sizeof (addrstr));
                                break;
                        case AF_INET6:
                                v6addr = (struct sockaddr_in6 *)address;
                                (void) inet_ntop(AF_INET6, &v6addr->sin6_addr,
                                    addrstr, sizeof (addrstr));
                                break;
                        }
                        (void) snprintf(statestr, sizeof (statestr),
                            "flags %x addr %s/%d",
                            event->nwe_data.nwe_if_state.nwe_flags,
                            addrstr, plen);
                } else {
                        (void) snprintf(statestr, sizeof (statestr),
                            "flags %x", event->nwe_data.nwe_if_state.nwe_flags);
                }
                state = statestr;
                break;

        case NWAM_EVENT_TYPE_LINK_ACTION:
                action = nwam_action_to_string
                    (event->nwe_data.nwe_link_action.nwe_action);
                object = event->nwe_data.nwe_link_action.nwe_name;
                break;

        case NWAM_EVENT_TYPE_LINK_STATE:
                state = event->nwe_data.nwe_link_state.nwe_link_up ?
                    "up" : "down";
                object = event->nwe_data.nwe_link_state.nwe_name;
                break;
        }

        if (object != NULL && action != NULL) {
                (void) snprintf(description, sizeof (description),
                    "%s -> action %s", object, action);
        } else if (object != NULL && state != NULL) {
                (void) snprintf(description, sizeof (description),
                    "%s -> state %s", object, state);
        }

        if (display) {
                (void) printf("%-*s %-*s\n", EVENT_WIDTH,
                    nwam_event_type_to_string(event->nwe_type),
                    DESCRIPTION_WIDTH,
                    description);
        }
}

/*
 * listens for events and displays them via the eventhandler() function above.
 */
/* ARGSUSED */
static void
show_events_func(int argc, char *argv[])
{
        nwam_error_t err;
        nwam_event_t event;

        err = nwam_events_init();

        if (err != NWAM_SUCCESS)
                die_nwamerr(err, "could not bind to receive events");

        /* print header */
        (void) printf("%-*s %-*s\n", EVENT_WIDTH, "EVENT",
            DESCRIPTION_WIDTH, "DESCRIPTION");

        do {
                /*
                 * Needed for stdout redirection to ensure event output is
                 * regularly flushed to file.
                 */
                (void) fflush(stdout);
                err = nwam_event_wait(&event);
                if (err == NWAM_SUCCESS) {
                        eventhandler(event);
                        nwam_event_free(event);
                }
        } while (err == NWAM_SUCCESS);
        die_nwamerr(err, "event handling stopped");
}

/* May need to convert case-insensitive link name match to case-sensitive one */
static nwam_error_t
name_to_linkname(char *name, char **linknamep)
{
        nwam_error_t err;
        nwam_ncp_handle_t ncph = NULL;
        nwam_ncu_handle_t ncuh = NULL;

        if ((ncph = determine_active_ncp()) == NULL)
                return (NWAM_ENTITY_NOT_FOUND);

        err = nwam_ncu_read(ncph, name, NWAM_NCU_TYPE_LINK, 0, &ncuh);
        if (err == NWAM_SUCCESS)
                err = nwam_ncu_get_name(ncuh, linknamep);

        nwam_ncp_free(ncph);
        nwam_ncu_free(ncuh);
        return (err);
}

static void
scan_wifi_func(int argc, char *argv[])
{
        nwam_error_t err;
        char *linkname = NULL;

        if (argc != 1)
                die_usage(CMD_SCAN_WIFI);

        if ((err = name_to_linkname(argv[0], &linkname)) != NWAM_SUCCESS)
                die_nwamerr(err, "scan request failed for %s", argv[0]);

        err = nwam_wlan_scan(linkname);

        if (err != NWAM_SUCCESS)
                die_nwamerr(err, "scan request failed for %s", linkname);

        free(linkname);
}

static void
select_wifi_func(int argc, char *argv[])
{
        nwam_error_t err;
        char *linkname = NULL;
        uint_t i, choice, num_wlans = 0;
        uint32_t security_mode;
        boolean_t have_key = B_FALSE;
        nwam_wlan_t *wlans = NULL;
        char choicestr[NWAM_MAX_VALUE_LEN];
        char modestr[NWAM_MAX_VALUE_LEN];
        char essid[NWAM_MAX_VALUE_LEN];
        char bssid[NWAM_MAX_VALUE_LEN];

        if (argc != 1)
                die_usage(CMD_SELECT_WIFI);

        if ((err = name_to_linkname(argv[0], &linkname)) != NWAM_SUCCESS) {
                die_nwamerr(err, "could not retrieve scan results for %s",
                    argv[0]);
        }
        err = nwam_wlan_get_scan_results(linkname, &num_wlans, &wlans);

        if (err != NWAM_SUCCESS) {
                die_nwamerr(err, "could not retrieve scan results for %s",
                    linkname);
        }
        bssid[0] = '\0';

        /* Loop until valid selection made */
        for (;;) {
                (void) printf("\n");
                /* Display WLAN choices for user to select from */
                for (i = 0; i < num_wlans; i++) {
                        (void) printf("%d: ESSID %s BSSID %s\n",
                            i + 1, wlans[i].nww_essid, wlans[i].nww_bssid);
                }
                (void) printf(gettext("%d: Other\n"), i + 1);

                (void) printf(gettext("\nChoose WLAN to connect to [1-%d]: "),
                    i + 1);

                if (fgets(choicestr, sizeof (choicestr), stdin) != NULL &&
                    (choice = atoi(choicestr)) >= 1 && choice <= (i + 1))
                        break;
        }

        if (choice == i + 1 || wlans[choice - 1].nww_essid[0] == '\0') {
                nwam_known_wlan_handle_t kwh = NULL;
                nwam_value_t keynameval = NULL;

                /* If "Other" or a hidden WLAN is selected, ask for ESSID */
                do {
                        (void) printf(gettext("\nEnter WLAN name: "));
                        while (fgets(essid, sizeof (essid), stdin) == NULL) {}
                        essid[strlen(essid) - 1] = '\0';
                } while (strspn(essid, " \t") == strlen(essid));

                /* If "Other" was selected, secmode must be specified. */
                if (choice == i + 1) {
                        for (;;) {
                                (void) printf(gettext("1: None\n"));
                                (void) printf(gettext("2: WEP\n"));
                                (void) printf(gettext("3: WPA\n"));
                                (void) printf(gettext("Enter security mode: "));
                                if (fgets(modestr, sizeof (choicestr), stdin)
                                    != NULL &&
                                    (security_mode = atoi(modestr)) >= 1 &&
                                    security_mode <= 3)
                                        break;
                        }
                } else {
                        security_mode = wlans[choice - 1].nww_security_mode;
                        have_key = wlans[choice - 1].nww_have_key;
                }

                /*
                 * We have to determine if we have a key for this ESSID from
                 * the known WLAN list, since we cannot determine this from
                 * the scan results.
                 */
                if (nwam_known_wlan_read(essid, 0, &kwh) == NWAM_SUCCESS &&
                    nwam_known_wlan_get_prop_value(kwh,
                    NWAM_KNOWN_WLAN_PROP_KEYNAME, &keynameval) == NWAM_SUCCESS)
                        have_key = B_TRUE;
                else
                        have_key = B_FALSE;

                nwam_value_free(keynameval);
                nwam_known_wlan_free(kwh);
        } else {
                (void) strlcpy(essid, wlans[choice - 1].nww_essid,
                    sizeof (essid));
                (void) strlcpy(bssid, wlans[choice - 1].nww_bssid,
                    sizeof (bssid));
                security_mode = wlans[choice - 1].nww_security_mode;
                have_key = wlans[choice - 1].nww_have_key;
        }

        if (security_mode != DLADM_WLAN_SECMODE_NONE && !have_key) {
                uint_t keyslot = 1;
                char key[NWAM_MAX_VALUE_LEN];
                char slotstr[NWAM_MAX_VALUE_LEN];

                do {
                        (void) printf(gettext("\nEnter WLAN key for "
                            "ESSID %s: "), essid);
                        while (fgets(key, sizeof (key), stdin) == NULL) {}
                        key[strlen(key) - 1] = '\0';
                } while (strspn(key, " \t") == strlen(key));

                if (security_mode == DLADM_WLAN_SECMODE_WEP) {
                        for (;;) {
                                (void) printf(
                                    gettext("\nEnter key slot [1-4]: "));
                                if (fgets(slotstr, sizeof (slotstr), stdin)
                                    != NULL && (keyslot = atoi(slotstr)) >= 1 &&
                                    keyslot <= 4)
                                        break;
                        }
                }

                err = nwam_wlan_set_key(linkname, essid, bssid, security_mode,
                    keyslot, key);
                if (err != NWAM_SUCCESS)
                        die_nwamerr(err, "could not set WiFi key");
        }
        err = nwam_wlan_select(linkname, essid, bssid[0] != '\0' ? bssid : NULL,
            security_mode, B_TRUE);
        if (err != NWAM_SUCCESS)
                die_nwamerr(err, "could not select WLAN %s", essid);
        free(wlans);
        free(linkname);
}

int
main(int argc, char *argv[])
{
        int i;
        char *state;

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

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

        if (argc < 2) {
                usage(B_FALSE);
                exit(EXIT_FAILURE);
        }

        for (i = CMD_MIN; i <= CMD_MAX; i++) {
                if (strcmp(argv[1], cmd_to_str(i)) == 0) {
                        if (cmdtab[i].cmd_needs_nwamd) {
                                state = smf_get_state(NWAM_FMRI);
                                if (state == NULL || strcmp(state,
                                    SCF_STATE_STRING_ONLINE) != 0) {
                                        free(state);
                                        die("enable '%s' to use '%s %s'",
                                            NWAM_FMRI, execname,
                                            cmd_to_str(cmdtab[i].cmd_num));
                                }
                                free(state);
                        }

                        cmdtab[i].cmd_handler(argc - 2, &(argv[2]));

                        exit(EXIT_SUCCESS);
                }
        }

        (void) fprintf(stderr, gettext("%s: unknown subcommand '%s'\n"),
            execname, argv[1]);
        usage(B_FALSE);

        return (1);
}