libnwam/common/libnwam_ncp.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 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <assert.h>
#include <ctype.h>
#include <libgen.h>
#include <netdb.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <libdladm.h>

#include "libnwam_impl.h"
#include <libnwam_priv.h>
#include <libnwam.h>

/*
 * Functions to support creating, modifying, destroying, querying the
 * state of and changing the state of NCP (Network Configuration Profiles)
 * and the NCUs (Network Configuration Units) that are contained in those
 * NCP objects.  An NCP is simply a container for a set of NCUs which represent
 * the datalink and interface configuration preferences for the system.
 * An NCP can consist a set of prioritized link NCUs, e.g. wired links preferred
 * over wireless, a set of manually enabled/diasbled NCUs, or a combination
 * of both. Interface NCUs inherit activation from their underlying links,
 * so if wired is preferred over wireless and a cable is plugged in,
 * the wired link NCU will be active, as will the IP interface NCU above it.
 */

/*
 * The NCU property table is used to mapping property types to property name
 * strings, their associated value types etc. The table is used for validation
 * purposes, and for commit()ing and read()ing NCUs.
 */

static nwam_error_t valid_type(nwam_value_t);
static nwam_error_t valid_class(nwam_value_t);
static nwam_error_t valid_ncp(nwam_value_t);
static nwam_error_t valid_priority_mode(nwam_value_t);
static nwam_error_t valid_ncu_activation_mode(nwam_value_t);
static nwam_error_t valid_link_autopush(nwam_value_t);
static nwam_error_t valid_link_mtu(nwam_value_t);
static nwam_error_t valid_ip_version(nwam_value_t);
static nwam_error_t valid_addrsrc_v4(nwam_value_t);
static nwam_error_t valid_addrsrc_v6(nwam_value_t);

struct nwam_prop_table_entry ncu_prop_table_entries[] = {
    {NWAM_NCU_PROP_TYPE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1, valid_type,
        "specifies the NCU type - valid values are \'datalink\' and \'ip\'",
        NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
    {NWAM_NCU_PROP_CLASS, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1,
        valid_class,
        "specifies the NCU class - valid values are "
        "\'phys\' and \'ip\'",
        NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
    {NWAM_NCU_PROP_PARENT_NCP, NWAM_VALUE_TYPE_STRING, B_FALSE, 1, 1,
        valid_ncp,
        "specifies the parent NCP name",
        NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
    {NWAM_NCU_PROP_ACTIVATION_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1,
        valid_ncu_activation_mode,
        "specifies the NCU activation mode - valid values are:\n"
        "\'prioritized\' and \'manual\'",
        NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
    {NWAM_NCU_PROP_ENABLED, NWAM_VALUE_TYPE_BOOLEAN, B_TRUE, 0, 1,
        nwam_valid_boolean,
        "specifies if manual NCU is to be enabled",
        NWAM_FLAG_NCU_TYPE_ALL, NWAM_FLAG_NCU_CLASS_ALL},
    {NWAM_NCU_PROP_PRIORITY_GROUP, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0, 1,
        nwam_valid_uint64,
        "specifies the priority grouping of NCUs - lower values are "
        "prioritized, negative values are invalid",
        NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
    {NWAM_NCU_PROP_PRIORITY_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0, 1,
        valid_priority_mode,
        "specifies the mode of prioritization - valid values are:\n"
        "\'exclusive\', \'shared\' and \'all\'",
        NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
    {NWAM_NCU_PROP_LINK_MAC_ADDR, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1,
        nwam_valid_mac_addr,
        "specifies MAC address of form aa:bb:cc:dd:ee:ff for the link",
        NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
    {NWAM_NCU_PROP_LINK_AUTOPUSH, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
        NWAM_MAX_NUM_VALUES, valid_link_autopush,
        "specifies modules to autopush on link",
        NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
    {NWAM_NCU_PROP_LINK_MTU, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0, 1,
        valid_link_mtu,
        "specifies MTU for link",
        NWAM_FLAG_NCU_TYPE_LINK, NWAM_FLAG_NCU_CLASS_ALL_LINK},
    {NWAM_NCU_PROP_IP_VERSION, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0,
        NWAM_MAX_NUM_VALUES, valid_ip_version,
        "specifies IP versions for IP NCU - valid values are:\n"
        "\'ipv4\' and \'ipv6\'",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
    {NWAM_NCU_PROP_IPV4_ADDRSRC, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0,
        NWAM_MAX_NUM_VALUES, valid_addrsrc_v4,
        "specifies IPv4 address source(s) - valid values are:\n"
        "\'dhcp\' and \'static\'",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
    {NWAM_NCU_PROP_IPV4_ADDR, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
        NWAM_MAX_NUM_VALUES, nwam_valid_host_v4,
        "specifies static IPv4 host address(es)",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
    {NWAM_NCU_PROP_IPV4_DEFAULT_ROUTE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
        1, nwam_valid_route_v4,
        "specifies per-interface default IPv4 route",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
    {NWAM_NCU_PROP_IPV6_ADDRSRC, NWAM_VALUE_TYPE_UINT64, B_FALSE, 0,
        NWAM_MAX_NUM_VALUES, valid_addrsrc_v6,
        "specifies IPv6 address source(s) - valid values are:\n"
        "\'dhcp\', \'autoconf\' and \'static\'.\n"
        "\'dhcp\' and \'autoconf\' are mandatory values.",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
    {NWAM_NCU_PROP_IPV6_ADDR, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
        NWAM_MAX_NUM_VALUES, nwam_valid_host_v6,
        "specifies static IPv6 host address(es)",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE},
    {NWAM_NCU_PROP_IPV6_DEFAULT_ROUTE, NWAM_VALUE_TYPE_STRING, B_FALSE, 0,
        1, nwam_valid_route_v6,
        "specifies per-interface default IPv6 route",
        NWAM_FLAG_NCU_TYPE_INTERFACE, NWAM_FLAG_NCU_CLASS_ALL_INTERFACE}
};

#define NWAM_NUM_NCU_PROPS  (sizeof (ncu_prop_table_entries) / \
                sizeof (*ncu_prop_table_entries))

struct nwam_prop_table ncu_prop_table =
    { NWAM_NUM_NCU_PROPS, ncu_prop_table_entries };

nwam_error_t
nwam_ncp_get_name(nwam_ncp_handle_t ncph, char **namep)
{
    return (nwam_get_name(ncph, namep));
}

static nwam_error_t
nwam_ncp_name_to_file(const char *name, char **filename)
{
    assert(name != NULL && filename != NULL);

    if ((*filename = malloc(MAXPATHLEN)) == NULL)
        return (NWAM_NO_MEMORY);

    (void) snprintf(*filename, MAXPATHLEN, "%s%s%s%s", NWAM_CONF_DIR,
        NWAM_NCP_CONF_FILE_PRE, name, NWAM_NCP_CONF_FILE_SUF);

    return (NWAM_SUCCESS);
}

/* ARGSUSED1 */
nwam_error_t
nwam_ncp_create(const char *name, uint64_t flags, nwam_ncp_handle_t *ncphp)
{
    nwam_error_t err;
    char *ncpfile;

    if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCP, name, ncphp))
        != NWAM_SUCCESS)
        return (err);

    /* Create empty container for NCUs */
    if ((err = nwam_ncp_name_to_file(name, &ncpfile))
        != NWAM_SUCCESS) {
        nwam_free(*ncphp);
        *ncphp = NULL;
        return (err);
    }

    if ((err = nwam_commit(ncpfile, *ncphp, flags)) != NWAM_SUCCESS) {
        nwam_free(*ncphp);
        *ncphp = NULL;
    }

    free(ncpfile);

    return (err);
}

/* Used by libnwam_files.c */
nwam_error_t
nwam_ncp_file_to_name(const char *path, char **name)
{
    char path_copy[MAXPATHLEN];
    char *filename, *suffix;

    assert(path != NULL && name != NULL);

    /* Make a copy as basename(3c) may modify string */
    (void) strlcpy(path_copy, path, MAXPATHLEN);

    if ((*name = malloc(NWAM_MAX_NAME_LEN)) == NULL)
        return (NWAM_NO_MEMORY);

    if ((filename = basename(path_copy)) == NULL) {
        free(*name);
        return (NWAM_ENTITY_INVALID);
    }

    /* Ensure filename begins/ends with right prefix/suffix */
    if (sscanf(filename, NWAM_NCP_CONF_FILE_PRE "%256[^\n]s", *name) < 1) {
        free(*name);
        return (NWAM_ENTITY_INVALID);
    }
    suffix = *name + strlen(*name) - strlen(NWAM_NCP_CONF_FILE_SUF);
    if (strstr(*name, NWAM_NCP_CONF_FILE_SUF) != suffix) {
        free(*name);
        return (NWAM_ENTITY_INVALID);
    }
    suffix[0] = '\0';

    return (NWAM_SUCCESS);
}

/* ARGSUSED1 */
nwam_error_t
nwam_ncp_read(const char *name, uint64_t flags, nwam_ncp_handle_t *ncphp)
{
    char *filename;
    nwam_error_t err;

    assert(name != NULL && ncphp != NULL);

    /* try to read the associated ncp configuration */
    if ((err = nwam_ncp_name_to_file(name, &filename)) != NWAM_SUCCESS) {
        *ncphp = NULL;
        return (err);
    }

    err = nwam_read(NWAM_OBJECT_TYPE_NCP, filename, name, flags, ncphp);
    free(filename);
    return (err);
}

static nwam_error_t
nwam_ncu_get_parent_ncp_name(nwam_ncu_handle_t ncuh, char **parentnamep)
{
    nwam_value_t parentval = NULL;
    char *parentname;
    nwam_error_t err;

    if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_PARENT_NCP,
        &parentval)) != NWAM_SUCCESS ||
        (err = nwam_value_get_string(parentval, &parentname))
        != NWAM_SUCCESS ||
        (*parentnamep = strdup(parentname)) == NULL) {
        if (parentval != NULL)
            nwam_value_free(parentval);
        *parentnamep = NULL;
        return (err);
    }
    nwam_value_free(parentval);

    return (NWAM_SUCCESS);
}

static int
nwam_ncp_copy_callback(nwam_ncu_handle_t oldncuh, void *arg)
{
    nwam_error_t err;
    nwam_ncu_handle_t newncuh = NULL;
    char *oldparent;
    char *oldfilename = NULL, *newfilename = NULL;
    nwam_ncp_handle_t newncph = (nwam_ncp_handle_t)arg;
    nwam_value_t newparentval;

    /* Get filenames for the new and old NCU's */
    if ((err = nwam_ncu_get_parent_ncp_name(oldncuh, &oldparent))
        != NWAM_SUCCESS)
        return (err);
    err = nwam_ncp_name_to_file(oldparent, &oldfilename);
    free(oldparent);
    if (err != NWAM_SUCCESS)
        return (err);
    if ((err = nwam_ncp_name_to_file(newncph->nwh_name, &newfilename))
        != NWAM_SUCCESS)
        goto fail;

    /* new NCU name (and typedname) is the same as the old name */
    if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCU, oldncuh->nwh_name,
        &newncuh)) != NWAM_SUCCESS)
        goto fail;
    /* Duplicate the old NCU's data */
    if ((err = nwam_dup_object_list(oldncuh->nwh_data,
        &(newncuh->nwh_data))) != NWAM_SUCCESS)
        goto fail;

    /* Update the parent property for the new NCU */
    if ((err = nwam_value_create_string(newncph->nwh_name, &newparentval))
        != NWAM_SUCCESS)
        goto fail;
    err = nwam_set_prop_value(newncuh->nwh_data, NWAM_NCU_PROP_PARENT_NCP,
        newparentval);
    nwam_value_free(newparentval);
    if (err != NWAM_SUCCESS)
        goto fail;

    /* Save the new NCU */
    err = nwam_commit(newfilename, newncuh, 0);

fail:
    free(oldfilename);
    free(newfilename);
    nwam_ncu_free(newncuh);
    return (err);
}

nwam_error_t
nwam_ncp_copy(nwam_ncp_handle_t oldncph, const char *newname,
    nwam_ncp_handle_t *newncphp)
{
    nwam_ncp_handle_t ncph;
    nwam_error_t err;
    int cb_ret;

    assert(oldncph != NULL && newname != NULL && newncphp != NULL);

    /* check if newname NCP already exists */
    if (nwam_ncp_read(newname, 0,  &ncph) == NWAM_SUCCESS) {
        nwam_ncp_free(ncph);
        *newncphp = NULL;
        return (NWAM_ENTITY_EXISTS);
    }

    /* create new handle */
    if ((err = nwam_ncp_create(newname, 0, newncphp)) != NWAM_SUCCESS)
        return (err);

    err = nwam_ncp_walk_ncus(oldncph, nwam_ncp_copy_callback, *newncphp,
        NWAM_FLAG_NCU_TYPE_CLASS_ALL, &cb_ret);
    if (err != NWAM_SUCCESS) {
        /* remove the NCP even if any NCU's had already been copied */
        (void) nwam_ncp_destroy(*newncphp, 0);
        *newncphp = NULL;
        if (err == NWAM_WALK_HALTED)
            return (cb_ret);
        else
            return (err);
    }

    return (NWAM_SUCCESS);
}

/*
 * Convert type to flag
 */
static uint64_t
nwam_ncu_type_to_flag(nwam_ncu_type_t type)
{
    switch (type) {
    case NWAM_NCU_TYPE_LINK:
        return (NWAM_FLAG_NCU_TYPE_LINK);
    case NWAM_NCU_TYPE_INTERFACE:
        return (NWAM_FLAG_NCU_TYPE_INTERFACE);
    case NWAM_NCU_TYPE_ANY:
        return (NWAM_FLAG_NCU_TYPE_ALL);
    default:
        return (0);
    }
}

/*
 * Convert class to flag
 */
uint64_t
nwam_ncu_class_to_flag(nwam_ncu_class_t class)
{
    switch (class) {
    case NWAM_NCU_CLASS_PHYS:
        return (NWAM_FLAG_NCU_CLASS_PHYS);
    case NWAM_NCU_CLASS_IP:
        return (NWAM_FLAG_NCU_CLASS_IP);
    case NWAM_NCU_CLASS_ANY:
        return (NWAM_FLAG_NCU_CLASS_ALL);
    default:
        return (0);
    }
}

/*
 * Infer NCU type from NCU class
 */
nwam_ncu_type_t
nwam_ncu_class_to_type(nwam_ncu_class_t class)
{
    switch (class) {
    case NWAM_NCU_CLASS_PHYS:
        return (NWAM_NCU_TYPE_LINK);
    case NWAM_NCU_CLASS_IP:
        return (NWAM_NCU_TYPE_INTERFACE);
    case NWAM_NCU_CLASS_ANY:
        return (NWAM_NCU_TYPE_ANY);
    default:
        return (NWAM_NCU_TYPE_UNKNOWN);
    }
}

/*
 * Make ncp active, deactivating any other active ncp.
 */
nwam_error_t
nwam_ncp_enable(nwam_ncp_handle_t ncph)
{
    nwam_error_t err;
    char *name;

    assert(ncph != NULL);

    err = nwam_enable(NULL, ncph);

    if (err == NWAM_ERROR_BIND) {
        /*
         * nwamd is not running, set active_ncp property so when
         * nwamd is next started, this NCP will be used.
         */
        if ((err = nwam_ncp_get_name(ncph, &name)) != NWAM_SUCCESS)
            return (err);

        err = nwam_set_smf_string_property(NWAM_FMRI, NWAM_PG,
            NWAM_PROP_ACTIVE_NCP, name);
        free(name);
    }

    return (err);
}

/* Compare NCP names c1 and c2 using strcasecmp() */
static int
ncpname_cmp(const void *c1, const void *c2)
{
    return (strcasecmp(*(const char **)c1, *(const char **)c2));
}

/* ARGSUSED1 */
nwam_error_t
nwam_walk_ncps(int (*cb)(nwam_ncp_handle_t, void *), void *data,
    uint64_t flags, int *retp)
{
    char *ncpname, **ncpfiles;
    nwam_ncp_handle_t ncph;
    nwam_error_t err;
    nwam_value_t value;
    void *objlist;
    uint_t i, num_ncpfiles;
    int ret = 0;

    assert(cb != NULL);

    if ((err = nwam_valid_flags(flags, NWAM_FLAG_BLOCKING)) != NWAM_SUCCESS)
        return (err);
    /*
     * To get list of NCP files, call nwam_read_object_from_backend()
     * with "parent" argument set to NULL. We get back an object list
     * consisting of string arrays for each object type - NCP, ENM
     * and location. We retrieve the NCP list, which corresponds to
     * the set of NCP backend parent objects (these are files at present).
     */
    if ((err = nwam_read_object_from_backend(NULL, NULL, flags,
        &objlist)) != NWAM_SUCCESS)
        return (err);

    if ((err = nwam_get_prop_value(objlist, NWAM_NCP_OBJECT_STRING, &value))
        != NWAM_SUCCESS) {
        nwam_free_object_list(objlist);
        return (err);
    }
    if ((err = nwam_value_get_string_array(value, &ncpfiles,
        &num_ncpfiles)) != NWAM_SUCCESS) {
        nwam_value_free(value);
        nwam_free_object_list(objlist);
        return (err);
    }

    /* sort the NCP names alphabetically */
    qsort(ncpfiles, num_ncpfiles, sizeof (char *), ncpname_cmp);

    for (i = 0; i < num_ncpfiles; i++) {
        if (nwam_ncp_file_to_name(ncpfiles[i], &ncpname)
            != NWAM_SUCCESS)
            continue;
        if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCP, ncpname,
            &ncph)) != NWAM_SUCCESS) {
            free(ncpname);
            break;
        }
        ret = cb(ncph, data);
        free(ncph);
        free(ncpname);
        if (ret != 0) {
            err = NWAM_WALK_HALTED;
            break;
        }
    }
    nwam_value_free(value);
    nwam_free_object_list(objlist);

    if (retp != NULL)
        *retp = ret;
    return (err);
}

/*
 * Checks if NCP is read-only.  Only NWAM_NCP_NAME_AUTOMATIC is read-only
 * for all but the netadm user (which nwamd runs as).
 */
nwam_error_t
nwam_ncp_get_read_only(nwam_ncp_handle_t ncph, boolean_t *readp)
{
    nwam_error_t err;
    char *name;

    assert(ncph != NULL && readp != NULL);

    if ((err = nwam_ncp_get_name(ncph, &name)) != NWAM_SUCCESS)
        return (err);

    if (NWAM_NCP_AUTOMATIC(name))
        *readp = !nwam_uid_is_special();
    else
        *readp = B_FALSE;

    free(name);
    return (NWAM_SUCCESS);
}

/* Checks if NCU is writable depending on its parent */
nwam_error_t
nwam_ncu_get_read_only(nwam_ncu_handle_t ncuh, boolean_t *readp)
{
    nwam_error_t err;
    nwam_ncp_handle_t ncph;

    assert(ncuh != NULL && readp != NULL);

    if ((err = nwam_ncu_get_ncp(ncuh, &ncph)) != NWAM_SUCCESS)
        return (err);

    err = nwam_ncp_get_read_only(ncph, readp);
    nwam_ncp_free(ncph);
    return (err);
}

/* Returns true if the NCP is active */
static boolean_t
nwam_ncp_is_active(nwam_ncp_handle_t ncph)
{
    char *active_ncp, *name;
    boolean_t ret;

    assert(ncph != NULL);

    /*
     * Determine which NCP is active via the nwamd/active_ncp property
     * value.  This allows us to determine which NCP is active even
     * if nwamd is not running.
     */
    if (nwam_ncp_get_name(ncph, &name) != NWAM_SUCCESS ||
        nwam_get_smf_string_property(NWAM_FMRI, NWAM_PG,
        NWAM_PROP_ACTIVE_NCP, &active_ncp) != NWAM_SUCCESS)
        return (B_FALSE);

    ret = (strcmp(name, active_ncp) == 0);

    free(active_ncp);
    free(name);

    return (ret);
}

nwam_error_t
nwam_ncp_destroy(nwam_ncp_handle_t ncph, uint64_t flags)
{
    char *filename;
    nwam_error_t err;
    boolean_t read_only;

    assert(ncph != NULL);

    if ((err = nwam_ncp_get_read_only(ncph, &read_only)) != NWAM_SUCCESS)
        return (err);
    if (read_only)
        return (NWAM_ENTITY_NOT_DESTROYABLE);

    if (nwam_ncp_is_active(ncph))
        return (NWAM_ENTITY_IN_USE);

    if ((err = nwam_ncp_name_to_file(ncph->nwh_name, &filename))
        != NWAM_SUCCESS)
        return (err);

    err = nwam_destroy(filename, ncph, flags);
    free(filename);

    return (NWAM_SUCCESS);
}

static nwam_error_t
nwam_ncu_internal_name_to_name(const char *internalname,
    nwam_ncu_type_t *typep, char **namep)
{
    char *prefixstr;

    assert(internalname != NULL && namep != NULL);

    if (strncasecmp(internalname, NWAM_NCU_LINK_NAME_PRE,
        strlen(NWAM_NCU_LINK_NAME_PRE)) == 0) {
        prefixstr = NWAM_NCU_LINK_NAME_PRE;
        *typep = NWAM_NCU_TYPE_LINK;
    } else if (strncasecmp(internalname, NWAM_NCU_INTERFACE_NAME_PRE,
        strlen(NWAM_NCU_INTERFACE_NAME_PRE)) == 0) {
        prefixstr = NWAM_NCU_INTERFACE_NAME_PRE;
        *typep = NWAM_NCU_TYPE_INTERFACE;
    } else {
        return (NWAM_INVALID_ARG);
    }

    *namep = strdup(internalname + strlen(prefixstr));
    if (*namep == NULL)
        return (NWAM_NO_MEMORY);
    return (NWAM_SUCCESS);
}

/* ARGSUSED2 */
static int
ncu_selectcb(struct nwam_handle *hp, uint64_t flags, void *data)
{
    nwam_ncu_handle_t ncuh = hp;
    nwam_value_t typeval = NULL, classval = NULL;
    uint64_t type, class, matchflags, walkfilter;

    if (nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_TYPE, &typeval)
        != NWAM_SUCCESS ||
        nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_CLASS, &classval)
        != NWAM_SUCCESS) {
        if (typeval != NULL)
            nwam_value_free(typeval);
        return (NWAM_INVALID_ARG);
    }
    if (nwam_value_get_uint64(typeval, &type) != NWAM_SUCCESS ||
        nwam_value_get_uint64(classval, &class) != NWAM_SUCCESS) {
        nwam_value_free(typeval);
        nwam_value_free(classval);
        return (NWAM_INVALID_ARG);
    }

    matchflags = nwam_ncu_type_to_flag(type) |
        nwam_ncu_class_to_flag(class);
    nwam_value_free(typeval);
    nwam_value_free(classval);

    if ((walkfilter = (flags & NWAM_WALK_FILTER_MASK)) == 0)
        walkfilter = NWAM_FLAG_NCU_TYPE_CLASS_ALL;

    if (matchflags & walkfilter)
        return (NWAM_SUCCESS);
    return (NWAM_INVALID_ARG);
}

nwam_error_t
nwam_ncp_walk_ncus(nwam_ncp_handle_t ncph,
    int(*cb)(nwam_ncu_handle_t, void *), void *data, uint64_t flags, int *retp)
{
    char *ncpfile;
    nwam_error_t err;

    assert(ncph != NULL && cb != NULL);

    if ((err = nwam_valid_flags(flags,
        NWAM_FLAG_NCU_TYPE_CLASS_ALL | NWAM_FLAG_BLOCKING)) != NWAM_SUCCESS)
        return (err);

    if ((err = nwam_ncp_name_to_file(ncph->nwh_name, &ncpfile))
        != NWAM_SUCCESS)
        return (err);

    err = nwam_walk(NWAM_OBJECT_TYPE_NCU, ncpfile, cb, data, flags,
        retp, ncu_selectcb);
    free(ncpfile);

    return (err);
}

void
nwam_ncp_free(nwam_ncp_handle_t ncph)
{
    nwam_free(ncph);
}

/*
 * Are ncu type and class compatible?
 */
static boolean_t
nwam_ncu_type_class_compatible(nwam_ncu_type_t type, nwam_ncu_class_t class)
{
    switch (type) {
    case NWAM_NCU_TYPE_LINK:
        return (class == NWAM_NCU_CLASS_PHYS);
    case NWAM_NCU_TYPE_INTERFACE:
        return (class == NWAM_NCU_CLASS_IP);
    default:
        return (B_FALSE);
    }
}

/* Name to validate may be internal name. If so, convert it before validating */
static boolean_t
valid_ncu_name(const char *name)
{
    char *n;
    boolean_t ret;
    nwam_ncu_type_t type;

    if (nwam_ncu_internal_name_to_name(name, &type, &n) == NWAM_SUCCESS) {

        ret = dladm_valid_linkname(n);
        free(n);
    } else {
        ret = dladm_valid_linkname(name);
    }

    return (ret);
}

nwam_error_t
nwam_ncu_create(nwam_ncp_handle_t ncph, const char *name,
    nwam_ncu_type_t type, nwam_ncu_class_t class, nwam_ncu_handle_t *ncuhp)
{
    nwam_ncu_handle_t ncuh;
    nwam_value_t typeval = NULL, classval = NULL, parentval = NULL;
    nwam_value_t enabledval = NULL;
    nwam_error_t err;
    boolean_t read_only;
    char *typedname;

    assert(ncph != NULL && name != NULL && ncuhp != NULL);

    if (!valid_ncu_name(name))
        return (NWAM_INVALID_ARG);

    if ((err = nwam_ncp_get_read_only(ncph, &read_only)) != NWAM_SUCCESS)
        return (err);
    if (read_only)
        return (NWAM_ENTITY_READ_ONLY);

    if (nwam_ncu_read(ncph, name, type, 0, &ncuh) == NWAM_SUCCESS) {
        nwam_ncu_free(ncuh);
        return (NWAM_ENTITY_EXISTS);
    }

    if (!valid_ncu_name(name) ||
        !nwam_ncu_type_class_compatible(type, class))
        return (NWAM_INVALID_ARG);

    if ((err = nwam_ncu_name_to_typed_name(name, type, &typedname))
        != NWAM_SUCCESS)
        return (err);

    /* Create handle */
    if ((err = nwam_handle_create(NWAM_OBJECT_TYPE_NCU, typedname, ncuhp))
        != NWAM_SUCCESS)
        return (err);
    free(typedname);

    /*
     * Create new object list for NCU.  The new NCU is initialized with
     * the appropriate type and class.
     */
    if ((err = nwam_alloc_object_list(&(*ncuhp)->nwh_data)) != NWAM_SUCCESS)
        goto finish;

    if ((err = nwam_value_create_uint64(type, &typeval))
        != NWAM_SUCCESS ||
        (err = nwam_value_create_uint64(class, &classval))
        != NWAM_SUCCESS ||
        (err = nwam_value_create_string(ncph->nwh_name, &parentval))
        != NWAM_SUCCESS ||
        (err = nwam_value_create_boolean(B_TRUE, &enabledval))
        != NWAM_SUCCESS) {
        goto finish;
    }
    if ((err = nwam_set_prop_value((*ncuhp)->nwh_data, NWAM_NCU_PROP_TYPE,
        typeval)) != NWAM_SUCCESS ||
        (err = nwam_set_prop_value((*ncuhp)->nwh_data, NWAM_NCU_PROP_CLASS,
        classval)) != NWAM_SUCCESS ||
        (err = nwam_set_prop_value((*ncuhp)->nwh_data,
        NWAM_NCU_PROP_PARENT_NCP, parentval)) != NWAM_SUCCESS ||
        (err = nwam_set_prop_value((*ncuhp)->nwh_data,
        NWAM_NCU_PROP_ENABLED, enabledval)) != NWAM_SUCCESS) {
        goto finish;
    }

    /* Set default IP, datalink properties */
    if (type == NWAM_NCU_TYPE_INTERFACE && class == NWAM_NCU_CLASS_IP) {

        uint64_t ver[] = { IPV4_VERSION, IPV6_VERSION };
        uint64_t v6src[] = { NWAM_ADDRSRC_DHCP, NWAM_ADDRSRC_AUTOCONF };
        uint_t vercnt = 2, v6srccnt = 2;
        nwam_value_t ipver = NULL, v4addrsrc = NULL, v6addrsrc = NULL;

        if ((err = nwam_value_create_uint64_array(ver, vercnt, &ipver))
            != NWAM_SUCCESS ||
            (err = nwam_value_create_uint64(NWAM_ADDRSRC_DHCP,
            &v4addrsrc)) != NWAM_SUCCESS ||
            (err = nwam_value_create_uint64_array(v6src, v6srccnt,
            &v6addrsrc)) != NWAM_SUCCESS) {
            nwam_value_free(ipver);
            nwam_value_free(v4addrsrc);
            goto finish;
        }
        if ((err = nwam_set_prop_value((*ncuhp)->nwh_data,
            NWAM_NCU_PROP_IP_VERSION, ipver)) == NWAM_SUCCESS &&
            (err = nwam_set_prop_value((*ncuhp)->nwh_data,
            NWAM_NCU_PROP_IPV4_ADDRSRC, v4addrsrc)) == NWAM_SUCCESS) {
            err = nwam_set_prop_value((*ncuhp)->nwh_data,
                NWAM_NCU_PROP_IPV6_ADDRSRC, v6addrsrc);
        }
        nwam_value_free(ipver);
        nwam_value_free(v4addrsrc);
        nwam_value_free(v6addrsrc);
    } else {
        nwam_value_t actval = NULL;
        if ((err = nwam_value_create_uint64(NWAM_ACTIVATION_MODE_MANUAL,
            &actval)) != NWAM_SUCCESS)
            goto finish;
        err = nwam_set_prop_value((*ncuhp)->nwh_data,
            NWAM_NCU_PROP_ACTIVATION_MODE, actval);
        nwam_value_free(actval);
    }

finish:
    nwam_value_free(typeval);
    nwam_value_free(classval);
    nwam_value_free(parentval);
    nwam_value_free(enabledval);
    if (err != NWAM_SUCCESS) {
        nwam_ncu_free(*ncuhp);
        *ncuhp = NULL;
    }
    return (err);
}

nwam_error_t
nwam_ncu_read(nwam_ncp_handle_t ncph, const char *name,
    nwam_ncu_type_t type, uint64_t flags, nwam_ncu_handle_t *ncuhp)
{
    char *ncpfile, *typedname;
    nwam_error_t err, err_ip, err_link;
    nwam_ncu_handle_t ncuh_ip, ncuh_link;

    assert(ncph != NULL && name != NULL && ncuhp != NULL);

    if ((err = nwam_ncp_name_to_file(ncph->nwh_name, &ncpfile))
        != NWAM_SUCCESS)
        return (err);

    if (type == NWAM_NCU_TYPE_ANY) {

        free(ncpfile);

        /*
         * If we get to this point, we have discovered that no
         * NCU type is discernable from name or type arguments.
         * Either exactly one NCU called name must exist of either
         * type, or the operation should fail.
         */
        err_ip = nwam_ncu_read(ncph, name, NWAM_NCU_TYPE_INTERFACE,
            flags, &ncuh_ip);
        err_link = nwam_ncu_read(ncph, name, NWAM_NCU_TYPE_LINK,
            flags, &ncuh_link);

        *ncuhp = NULL;

        if (err_ip == NWAM_SUCCESS && err_link == NWAM_SUCCESS) {
            nwam_ncu_free(ncuh_ip);
            nwam_ncu_free(ncuh_link);
            err = NWAM_ENTITY_MULTIPLE_VALUES;
        } else if (err_ip != NWAM_SUCCESS && err_link != NWAM_SUCCESS) {
            err = NWAM_ENTITY_NOT_FOUND;
        } else {
            if (err_ip == NWAM_SUCCESS) {
                *ncuhp = ncuh_ip;
            } else {
                *ncuhp = ncuh_link;
            }
            err = NWAM_SUCCESS;
        }

        return (err);
    }
    if ((err = nwam_ncu_name_to_typed_name(name, type, &typedname)) !=
        NWAM_SUCCESS) {
        free(ncpfile);
        return (err);
    }
    err = nwam_read(NWAM_OBJECT_TYPE_NCU, ncpfile, typedname, flags, ncuhp);

    free(typedname);
    free(ncpfile);

    return (err);
}

nwam_error_t
nwam_ncu_get_name(nwam_ncu_handle_t ncuh, char **namep)
{
    nwam_ncu_type_t type;

    assert(ncuh != NULL && namep != NULL);

    return (nwam_ncu_internal_name_to_name(ncuh->nwh_name, &type, namep));
}

nwam_error_t
nwam_ncu_name_to_typed_name(const char *name, nwam_ncu_type_t type,
    char **typednamep)
{
    char *prefixstr;
    size_t typednamesz;

    assert(name != NULL && typednamep != NULL);

    switch (type) {
    case NWAM_NCU_TYPE_INTERFACE:
        prefixstr = NWAM_NCU_INTERFACE_NAME_PRE;
        break;
    case NWAM_NCU_TYPE_LINK:
        prefixstr = NWAM_NCU_LINK_NAME_PRE;
        break;
    default:
        return (NWAM_INVALID_ARG);
    }
    typednamesz = strlen(name) + strlen(prefixstr) + 1;
    if ((*typednamep = malloc(typednamesz)) == NULL)
        return (NWAM_NO_MEMORY);

    /* Name may be already qualified by type */
    if (strncasecmp(prefixstr, name, strlen(prefixstr)) == 0) {
        (void) snprintf(*typednamep, typednamesz, "%s", name);
    } else {
        (void) snprintf(*typednamep, typednamesz, "%s%s",
            prefixstr, name);
    }

    return (NWAM_SUCCESS);
}

nwam_error_t
nwam_ncu_typed_name_to_name(const char *typed_name, nwam_ncu_type_t *typep,
    char **name)
{
    return (nwam_ncu_internal_name_to_name(typed_name, typep, name));
}

void
nwam_ncu_free(nwam_ncu_handle_t ncuh)
{
    nwam_free(ncuh);
}

nwam_error_t
nwam_ncu_copy(nwam_ncu_handle_t oldncuh, const char *newname,
    nwam_ncu_handle_t *newncuhp)
{
    nwam_ncp_handle_t ncph;
    nwam_ncu_handle_t ncuh;
    nwam_error_t err;
    nwam_value_t typeval;
    uint64_t type;
    char *typednewname;

    assert(oldncuh != NULL && newname != NULL && newncuhp != NULL);

    if (nwam_ncu_get_prop_value(oldncuh, NWAM_NCU_PROP_TYPE,
        &typeval) != NWAM_SUCCESS) {
        return (NWAM_INVALID_ARG);
    }
    if (nwam_value_get_uint64(typeval, &type) != NWAM_SUCCESS) {
        nwam_value_free(typeval);
        return (NWAM_INVALID_ARG);
    }
    nwam_value_free(typeval);

    /* check if newname NCU already exists */
    if ((err = nwam_ncu_get_ncp(oldncuh, &ncph)) != NWAM_SUCCESS)
        return (err);
    if (nwam_ncu_read(ncph, newname, type, 0, &ncuh) == NWAM_SUCCESS) {
        nwam_ncu_free(ncuh);
        nwam_ncp_free(ncph);
        return (NWAM_ENTITY_EXISTS);
    }
    nwam_ncp_free(ncph);

    if ((err = nwam_ncu_name_to_typed_name(newname, type, &typednewname))
        != NWAM_SUCCESS)
        return (err);

    err = nwam_handle_create(NWAM_OBJECT_TYPE_NCU, typednewname, newncuhp);
    free(typednewname);
    if (err != NWAM_SUCCESS)
        return (err);
    if ((err = nwam_dup_object_list(oldncuh->nwh_data,
        &((*newncuhp)->nwh_data))) != NWAM_SUCCESS) {
        free(*newncuhp);
        *newncuhp = NULL;
        return (err);
    }

    return (NWAM_SUCCESS);
}

nwam_error_t
nwam_ncu_delete_prop(nwam_ncu_handle_t ncuh, const char *propname)
{
    boolean_t ro_ncu, ro_prop;
    nwam_error_t err;
    void *olddata;

    assert(ncuh != NULL && propname != NULL);

    if ((err = nwam_ncu_get_read_only(ncuh, &ro_ncu)) != NWAM_SUCCESS ||
        (err = nwam_ncu_prop_read_only(propname, &ro_prop)) != NWAM_SUCCESS)
        return (err);
    if (ro_ncu || ro_prop)
        return (NWAM_ENTITY_READ_ONLY);

    /*
     * Duplicate data, remove property and validate. If validation
     * fails, revert to data duplicated prior to remove.
     */
    if ((err = nwam_dup_object_list(ncuh->nwh_data, &olddata))
        != NWAM_SUCCESS)
        return (err);
    if ((err = nwam_delete_prop(ncuh->nwh_data, propname))
        != NWAM_SUCCESS) {
        nwam_free_object_list(ncuh->nwh_data);
        ncuh->nwh_data = olddata;
        return (err);
    }
    if ((err = nwam_ncu_validate(ncuh, NULL)) != NWAM_SUCCESS) {
        nwam_free_object_list(ncuh->nwh_data);
        ncuh->nwh_data = olddata;
        return (err);
    }
    nwam_free_object_list(olddata);

    return (NWAM_SUCCESS);
}

nwam_error_t
nwam_ncu_set_prop_value(nwam_ncu_handle_t ncuh, const char *propname,
    nwam_value_t value)
{
    boolean_t ro_ncu, ro_prop;
    nwam_error_t err;
    nwam_ncp_handle_t ncph;

    assert(ncuh != NULL && propname != NULL && value != NULL);

    if ((err = nwam_ncu_get_read_only(ncuh, &ro_ncu)) != NWAM_SUCCESS ||
        (err = nwam_ncu_prop_read_only(propname, &ro_prop)) != NWAM_SUCCESS)
        return (err);
    if (ro_ncu || ro_prop)
        return (NWAM_ENTITY_READ_ONLY);

    err = nwam_ncu_get_ncp(ncuh, &ncph);
    if (err != NWAM_SUCCESS && err != NWAM_INVALID_ARG) {
        /*
         * If "parent" property doesn't exist, NWAM_INVALID_ARG
         * is returned.  Allow the setting to continue.
         */
        return (err);
    }
    nwam_ncp_free(ncph);

    /* Need to ensure property, type and value are valid */
    if ((err = nwam_ncu_validate_prop(ncuh, propname, value))
        != NWAM_SUCCESS)
        return (err);

    return (nwam_set_prop_value(ncuh->nwh_data, propname, value));
}

nwam_error_t
nwam_ncu_get_prop_value(nwam_ncu_handle_t ncuh, const char *propname,
    nwam_value_t *valuep)
{
    assert(ncuh != NULL && propname != NULL && valuep != NULL);

    return (nwam_get_prop_value(ncuh->nwh_data, propname, valuep));
}

nwam_error_t
nwam_ncu_walk_props(nwam_ncu_handle_t ncuh,
    int (*cb)(const char *, nwam_value_t, void *),
    void *data, uint64_t flags, int *retp)
{
    return (nwam_walk_props(ncuh, cb, data, flags, retp));
}

nwam_error_t
nwam_ncu_get_ncp(nwam_ncu_handle_t ncuh, nwam_ncp_handle_t *ncphp)
{
    nwam_error_t err;
    char *parentname = NULL;

    if ((err = nwam_ncu_get_parent_ncp_name(ncuh, &parentname))
        != NWAM_SUCCESS ||
        (err = nwam_handle_create(NWAM_OBJECT_TYPE_NCP, parentname, ncphp))
        != NWAM_SUCCESS) {
        if (parentname != NULL)
            free(parentname);
        return (err);
    }
    free(parentname);

    return (NWAM_SUCCESS);
}

nwam_error_t
nwam_ncu_commit(nwam_ncu_handle_t ncuh, uint64_t flags)
{
    nwam_error_t err;
    boolean_t read_only;
    char *ncpfile, *ncpname;

    assert(ncuh != NULL && ncuh->nwh_data != NULL);

    if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
        return (err);
    if (read_only)
        return (NWAM_ENTITY_READ_ONLY);

    if ((err = nwam_ncu_validate(ncuh, NULL)) != NWAM_SUCCESS ||
        (err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
        != NWAM_SUCCESS)
        return (err);

    if ((err = nwam_ncp_name_to_file(ncpname, &ncpfile)) != NWAM_SUCCESS) {
        free(ncpname);
        return (err);
    }

    err = nwam_commit(ncpfile, ncuh, flags);

    free(ncpname);
    free(ncpfile);

    return (err);
}
/* Get the NCU type */
nwam_error_t
nwam_ncu_get_ncu_type(nwam_ncu_handle_t ncuh, nwam_ncu_type_t *typep)
{
    nwam_error_t err;
    nwam_value_t typeval;
    uint64_t type;

    if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_TYPE, &typeval))
        != NWAM_SUCCESS)
        return (err);
    err = nwam_value_get_uint64(typeval, &type);
    nwam_value_free(typeval);
    if (err != NWAM_SUCCESS)
        return (err);

    *typep = type;
    return (NWAM_SUCCESS);
}

/* Get the NCU class */
nwam_error_t
nwam_ncu_get_ncu_class(nwam_ncu_handle_t ncuh, nwam_ncu_class_t *classp)
{
    nwam_error_t err;
    nwam_value_t classval;
    uint64_t class;

    if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_CLASS,
        &classval)) != NWAM_SUCCESS)
        return (err);
    err = nwam_value_get_uint64(classval, &class);
    nwam_value_free(classval);
    if (err != NWAM_SUCCESS)
        return (err);

    *classp = class;
    return (NWAM_SUCCESS);
}

/*
 * Determine if the NCU has manual activation-mode or not.
 */
nwam_error_t
nwam_ncu_is_manual(nwam_ncu_handle_t ncuh, boolean_t *manualp)
{
    nwam_error_t err;
    nwam_value_t actval;
    uint64_t activation;

    assert(ncuh != NULL);

    if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_ACTIVATION_MODE,
        &actval)) != NWAM_SUCCESS)
        return (err);
    err = nwam_value_get_uint64(actval, &activation);
    nwam_value_free(actval);
    if (err != NWAM_SUCCESS)
        return (err);

    if (activation == NWAM_ACTIVATION_MODE_MANUAL)
        *manualp = B_TRUE;
    else
        *manualp = B_FALSE;
    return (NWAM_SUCCESS);
}

/* Determine if NCU is enabled or not */
static nwam_error_t
nwam_ncu_is_enabled(nwam_ncu_handle_t ncuh, boolean_t *enabledp)
{
    nwam_error_t err;
    nwam_value_t enabledval;

    assert(ncuh != NULL);

    if ((err = nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_ENABLED,
        &enabledval)) != NWAM_SUCCESS)
        return (err);
    err = nwam_value_get_boolean(enabledval, enabledp);
    nwam_value_free(enabledval);
    return (err);
}

/* Update the enabled property */
static nwam_error_t
nwam_ncu_update_enabled(nwam_ncu_handle_t ncuh, boolean_t enabled)
{
    nwam_error_t err;
    nwam_value_t enabledval;

    if ((err = nwam_value_create_boolean(enabled, &enabledval))
        != NWAM_SUCCESS)
        return (err);
    err = nwam_set_prop_value(ncuh->nwh_data, NWAM_NCU_PROP_ENABLED,
        enabledval);
    nwam_value_free(enabledval);
    if (err != NWAM_SUCCESS)
        return (err);
    return (nwam_ncu_commit(ncuh, NWAM_FLAG_ENTITY_ENABLE));
}

/*
 * Make ncu active; fails if the NCU's parent NCP is not active.
 */
nwam_error_t
nwam_ncu_enable(nwam_ncu_handle_t ncuh)
{
    char *ncpname = NULL;
    nwam_error_t err;
    nwam_ncu_type_t type;
    boolean_t read_only, enabled, manual;

    assert(ncuh != NULL);

    /* Don't allow NCUs of Automatic NCP to be enabled */
    if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
        return (err);
    if (read_only)
        return (NWAM_ENTITY_NOT_MANUAL);

    /* Link NCUs with manual activation-mode or IP NCUs can be enabled */
    if ((err = nwam_ncu_get_ncu_type(ncuh, &type)) != NWAM_SUCCESS)
        return (err);

    if (type == NWAM_NCU_TYPE_LINK) {
        if ((err = nwam_ncu_is_manual(ncuh, &manual)) != NWAM_SUCCESS)
            return (err);
        if (!manual)
            return (NWAM_ENTITY_NOT_MANUAL);
    }

    /* Make sure NCU is not enabled */
    if ((err = nwam_ncu_is_enabled(ncuh, &enabled)) != NWAM_SUCCESS ||
        (err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
        != NWAM_SUCCESS)
        return (err);

    if (enabled) {
        free(ncpname);
        return (NWAM_SUCCESS);
    }

    if ((err = nwam_ncu_update_enabled(ncuh, B_TRUE)) != NWAM_SUCCESS) {
        free(ncpname);
        return (err);
    }

    err = nwam_enable(ncpname, ncuh);
    free(ncpname);

    /* nwamd may not be running, that's okay. */
    if (err == NWAM_ERROR_BIND)
        return (NWAM_SUCCESS);
    else
        return (err);
}

/*
 * Disable ncu; fails if the NCU's parent NCP is not active, or if the
 * NCU is not currently active.
 */
nwam_error_t
nwam_ncu_disable(nwam_ncu_handle_t ncuh)
{
    char *ncpname = NULL;
    nwam_error_t err;
    nwam_ncu_type_t type;
    boolean_t read_only, enabled, manual;

    assert(ncuh != NULL);

    /* Don't allow NCUs of Automatic NCP to be disabled */
    if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
        return (err);
    if (read_only)
        return (NWAM_ENTITY_NOT_MANUAL);

    /* Link NCUs with manual activation-mode or IP NCUs can be disabled */
    if ((err = nwam_ncu_get_ncu_type(ncuh, &type)) != NWAM_SUCCESS)
        return (err);

    if (type == NWAM_NCU_TYPE_LINK) {
        if ((err = nwam_ncu_is_manual(ncuh, &manual)) != NWAM_SUCCESS)
            return (err);
        if (!manual)
            return (NWAM_ENTITY_NOT_MANUAL);
    }

    /* Make sure NCU is enabled */
    if ((err = nwam_ncu_is_enabled(ncuh, &enabled)) != NWAM_SUCCESS ||
        (err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
        != NWAM_SUCCESS)
        return (err);

    if (!enabled) {
        free(ncpname);
        return (NWAM_SUCCESS);
    }

    if ((err = nwam_ncu_update_enabled(ncuh, B_FALSE)) != NWAM_SUCCESS) {
        free(ncpname);
        return (err);
    }

    err = nwam_disable(ncpname, ncuh);
    free(ncpname);

    /* nwamd may not be running, that's okay. */
    if (err == NWAM_ERROR_BIND)
        return (NWAM_SUCCESS);
    else
        return (err);
}

nwam_error_t
nwam_ncu_destroy(nwam_ncu_handle_t ncuh, uint64_t flags)
{
    char *ncpname, *ncpfile;
    boolean_t read_only;
    nwam_error_t err;

    assert(ncuh != NULL);

    if ((err = nwam_ncu_get_read_only(ncuh, &read_only)) != NWAM_SUCCESS)
        return (err);
    if (read_only)
        return (NWAM_ENTITY_NOT_DESTROYABLE);

    if ((err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
        != NWAM_SUCCESS)
        return (err);
    if ((err = nwam_ncp_name_to_file(ncpname, &ncpfile))
        != NWAM_SUCCESS) {
        free(ncpname);
        return (err);
    }

    err = nwam_destroy(ncpfile, ncuh, flags);

    free(ncpname);
    free(ncpfile);

    return (err);
}

nwam_error_t
nwam_ncu_get_prop_description(const char *propname, const char **descriptionp)
{
    return (nwam_get_prop_description(ncu_prop_table, propname,
        descriptionp));
}

/* Get expected property data type */
nwam_error_t
nwam_ncu_get_prop_type(const char *propname, nwam_value_type_t *typep)
{
    return (nwam_get_prop_type(ncu_prop_table, propname, typep));
}

nwam_error_t
nwam_ncu_prop_read_only(const char *propname, boolean_t *readp)
{
    if ((*readp = NWAM_NCU_PROP_SETONCE(propname)) == B_TRUE)
        return (NWAM_SUCCESS);

    return (nwam_prop_read_only(ncu_prop_table, propname, readp));
}

nwam_error_t
nwam_ncu_prop_multivalued(const char *propname, boolean_t *multip)
{
    return (nwam_prop_multivalued(ncu_prop_table, propname, multip));
}

/*
 * Ensure that the properties in the ncu, determined by that ncu's
 * type and class, belong there.
 */
static nwam_error_t
nwam_ncu_validate_prop_membership(nwam_ncu_handle_t ncuh, const char *propname)
{
    struct nwam_prop_table_entry *pte;
    nwam_value_t typeval, classval;
    uint64_t type, class;
    uint64_t typeflags = 0, classflags = 0;

    /* Get type/class from ncu */
    if (nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_TYPE, &typeval)
        != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID);
    if (nwam_value_get_uint64(typeval, &type) != NWAM_SUCCESS) {
        nwam_value_free(typeval);
        return (NWAM_ENTITY_INVALID);
    }
    typeflags = nwam_ncu_type_to_flag((nwam_ncu_type_t)type);
    nwam_value_free(typeval);

    if (nwam_ncu_get_prop_value(ncuh, NWAM_NCU_PROP_CLASS, &classval)
        != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID);
    if (nwam_value_get_uint64(classval, &class) != NWAM_SUCCESS) {
        nwam_value_free(classval);
        return (NWAM_ENTITY_INVALID);
    }
    classflags = nwam_ncu_class_to_flag((nwam_ncu_class_t)class);
    nwam_value_free(classval);

    if ((pte = nwam_get_prop_table_entry(ncu_prop_table, propname)) == NULL)
        return (NWAM_INVALID_ARG);

    if (typeflags & pte->prop_type_membership &&
        classflags & pte->prop_class_membership) {
        return (NWAM_SUCCESS);
    } else {
        return (NWAM_ENTITY_INVALID_MEMBER);
    }
}

/* Validate property's ncu membership and type, number and range of values */
nwam_error_t
nwam_ncu_validate_prop(nwam_ncu_handle_t ncuh, const char *propname,
    nwam_value_t value)
{
    nwam_error_t err;

    assert(ncuh != NULL && propname != NULL);

    /* First, determine if this property is valid for this ncu */
    if ((err = nwam_ncu_validate_prop_membership(ncuh, propname))
        != NWAM_SUCCESS)
        return (err);

    return (nwam_validate_prop(ncu_prop_table, ncuh, propname, value));
}

/* Property-specific value validation functions follow */

static nwam_error_t
valid_type(nwam_value_t value)
{
    uint64_t type;

    if (nwam_value_get_uint64(value, &type) != NWAM_SUCCESS ||
        type > NWAM_NCU_TYPE_INTERFACE)
        return (NWAM_ENTITY_INVALID_VALUE);
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_class(nwam_value_t value)
{
    uint64_t class;

    if (nwam_value_get_uint64(value, &class) != NWAM_SUCCESS ||
        class > NWAM_NCU_CLASS_IP)
        return (NWAM_ENTITY_INVALID_VALUE);
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_ncp(nwam_value_t value)
{
    char *ncp;

    if (nwam_value_get_string(value, &ncp) != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID_VALUE);
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_priority_mode(nwam_value_t value)
{
    uint64_t priority_mode;

    if (nwam_value_get_uint64(value, &priority_mode) != NWAM_SUCCESS ||
        priority_mode > NWAM_PRIORITY_MODE_ALL)
        return (NWAM_ENTITY_INVALID_VALUE);
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_ncu_activation_mode(nwam_value_t value)
{
    uint64_t activation_mode;

    if (nwam_value_get_uint64(value, &activation_mode) != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID_VALUE);

    switch (activation_mode) {
    case NWAM_ACTIVATION_MODE_MANUAL:
    case NWAM_ACTIVATION_MODE_PRIORITIZED:
        return (NWAM_SUCCESS);
    }
    return (NWAM_ENTITY_INVALID_VALUE);
}

/* ARGSUSED0 */
static nwam_error_t
valid_link_autopush(nwam_value_t value)
{
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_ip_version(nwam_value_t value)
{
    uint64_t *versions;
    uint_t i, numvalues;

    if (nwam_value_get_uint64_array(value, &versions, &numvalues)
        != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID_VALUE);

    for (i = 0; i < numvalues; i++) {
        if (versions[i] != IPV4_VERSION &&
            versions[i] != IPV6_VERSION)
        return (NWAM_ENTITY_INVALID_VALUE);
    }
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_addrsrc_v4(nwam_value_t value)
{
    uint64_t *addrsrc;
    uint_t i, numvalues;

    if (nwam_value_get_uint64_array(value, &addrsrc, &numvalues)
        != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID_VALUE);

    for (i = 0; i < numvalues; i++) {
        if (addrsrc[i] != NWAM_ADDRSRC_DHCP &&
            addrsrc[i] != NWAM_ADDRSRC_STATIC)
            return (NWAM_ENTITY_INVALID_VALUE);
    }
    return (NWAM_SUCCESS);
}

static nwam_error_t
valid_addrsrc_v6(nwam_value_t value)
{
    uint64_t *addrsrc;
    uint_t i, numvalues;
    boolean_t dhcp_found = B_FALSE, autoconf_found = B_FALSE;

    if (nwam_value_get_uint64_array(value, &addrsrc, &numvalues)
        != NWAM_SUCCESS)
        return (NWAM_ENTITY_INVALID_VALUE);

    for (i = 0; i < numvalues; i++) {
        if (addrsrc[i] != NWAM_ADDRSRC_DHCP &&
            addrsrc[i] != NWAM_ADDRSRC_STATIC &&
            addrsrc[i] != NWAM_ADDRSRC_AUTOCONF)
            return (NWAM_ENTITY_INVALID_VALUE);
        if (addrsrc[i] == NWAM_ADDRSRC_DHCP)
            dhcp_found = B_TRUE;
        if (addrsrc[i] == NWAM_ADDRSRC_AUTOCONF)
            autoconf_found = B_TRUE;
    }
    /*
     * DHCP and AUTOCONF need to be specified as v6 address sources
     * since there is no way to switch them off in NWAM at present.
     */
    if (dhcp_found && autoconf_found)
        return (NWAM_SUCCESS);
    else
        return (NWAM_ENTITY_INVALID_VALUE);
}

/* ARGSUSED0 */
static nwam_error_t
valid_link_mtu(nwam_value_t value)
{
    return (NWAM_SUCCESS);
}

nwam_error_t
nwam_ncu_validate(nwam_ncu_handle_t ncuh, const char **errpropp)
{
    return (nwam_validate(ncu_prop_table, ncuh, errpropp));
}

/*
 * Given the ncu type and ncu class, return the list of properties that needs
 * to be set. Note this list is a complete property list that includes both
 * the required ones and the optional ones. Caller needs to free prop_list.
 */
nwam_error_t
nwam_ncu_get_default_proplist(nwam_ncu_type_t type, nwam_ncu_class_t class,
    const char ***prop_list, uint_t *numvalues)
{
    uint64_t typeflags = nwam_ncu_type_to_flag(type);
    uint64_t classflags = nwam_ncu_class_to_flag(class);

    return (nwam_get_default_proplist(ncu_prop_table, typeflags,
        classflags, prop_list, numvalues));
}

nwam_error_t
nwam_ncp_get_state(nwam_ncp_handle_t ncph, nwam_state_t *statep,
    nwam_aux_state_t *auxp)
{
    return (nwam_get_state(ncph->nwh_name, ncph, statep, auxp));
}

nwam_error_t
nwam_ncu_get_state(nwam_ncu_handle_t ncuh, nwam_state_t *statep,
    nwam_aux_state_t *auxp)
{
    nwam_ncp_handle_t ncph;
    char *ncpname;
    nwam_error_t err;

    assert(ncuh != NULL);

    if ((err = nwam_ncu_get_ncp(ncuh, &ncph)) != NWAM_SUCCESS)
        return (err);
    if (!nwam_ncp_is_active(ncph)) {
        nwam_ncp_free(ncph);
        return (NWAM_ENTITY_INVALID);
    }
    nwam_ncp_free(ncph);

    if ((err = nwam_ncu_get_parent_ncp_name(ncuh, &ncpname))
        != NWAM_SUCCESS)
        return (err);

    err = nwam_request_state(NWAM_OBJECT_TYPE_NCU, ncuh->nwh_name, ncpname,
        statep, auxp);
    free(ncpname);
    return (err);
}

nwam_error_t
nwam_ncp_get_active_priority_group(int64_t *priorityp)
{
    return (nwam_request_active_priority_group(priorityp));
}