OpenSolaris_b135/lib/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_netadm();
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));
}