/*
 * 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 <arpa/inet.h>
#include <assert.h>
#include <atomic.h>
#include <ctype.h>
#include <errno.h>
#include <inet/ip.h>
#include <libintl.h>
#include <libproc.h>
#include <libscf.h>
#include <net/if_dl.h>
#include <netinet/in.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/mman.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

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

/*
 * Utility functions for door access, common validation functions etc.
 */

pthread_mutex_t door_mutex = PTHREAD_MUTEX_INITIALIZER;
int nwam_door_fd = -1;

static int
open_door(const char *door_name, int *door_fdp)
{
	struct door_info dinfo;
	int err = 0;

	(void) pthread_mutex_lock(&door_mutex);

	if (*door_fdp != -1) {
		/* Check door fd is not old (from previous nwamd). */
		if (door_info(*door_fdp, &dinfo) != 0 ||
		    (dinfo.di_attributes & DOOR_REVOKED) != 0) {
			(void) close(*door_fdp);
			*door_fdp = -1;
		}
	}
	if (*door_fdp == -1) {
		*door_fdp = open(door_name, 0);
		if (*door_fdp == -1)
			err = errno;
	}

	(void) pthread_mutex_unlock(&door_mutex);

	return (err);
}

int
nwam_make_door_call(const char *door_name, int *door_fdp,
    void *request, size_t request_size)
{
	int err;
	door_arg_t door_args;

	door_args.data_ptr = (void *)request;
	door_args.data_size = request_size;
	door_args.desc_ptr = NULL;
	door_args.desc_num = 0;
	door_args.rbuf = (void *)request;
	door_args.rsize = request_size;

	if ((err = open_door(door_name, door_fdp)) != 0)
		return (err);

	if (door_call(*door_fdp, &door_args) == -1)
		return (errno);

	return (0);
}

static nwam_error_t
send_msg_to_nwam(nwamd_door_arg_t *request)
{
	int err;

	if ((err = nwam_make_door_call(NWAM_DOOR, &nwam_door_fd,
	    request, sizeof (nwamd_door_arg_t))) != 0) {
		if (err == ENOENT)
			return (NWAM_ERROR_BIND);
		return (nwam_errno_to_nwam_error(err));
	}

	switch (request->nwda_status) {
	case NWAM_REQUEST_STATUS_OK:
		return (NWAM_SUCCESS);
	case NWAM_REQUEST_STATUS_UNKNOWN:
		return (NWAM_INVALID_ARG);
	case NWAM_REQUEST_STATUS_ALREADY:
		return (NWAM_ENTITY_IN_USE);
	case NWAM_REQUEST_STATUS_FAILED:
		return (request->nwda_error);
	default:
		return (NWAM_ERROR_INTERNAL);
	}
}

nwam_error_t
nwam_request_register_unregister(nwam_request_type_t type,
    const char *event_msg_file)
{
	nwamd_door_arg_t req;

	req.nwda_type = type;

	(void) strlcpy(req.nwda_data.nwdad_register_info.nwdad_name,
	    event_msg_file,
	    sizeof (req.nwda_data.nwdad_register_info.nwdad_name));

	return (send_msg_to_nwam(&req));
}

nwam_error_t
nwam_request_action(nwam_object_type_t object_type,
    const char *name, const char *parent, nwam_action_t action)
{
	nwamd_door_arg_t req;

	assert(name != NULL);

	req.nwda_type = NWAM_REQUEST_TYPE_ACTION;
	req.nwda_data.nwdad_object_action.nwdad_object_type = object_type;
	req.nwda_data.nwdad_object_action.nwdad_action = action;
	(void) strlcpy(req.nwda_data.nwdad_object_action.nwdad_name, name,
	    sizeof (req.nwda_data.nwdad_object_action.nwdad_name));
	if (parent != NULL) {
		(void) strlcpy(req.nwda_data.nwdad_object_action.nwdad_parent,
		    parent,
		    sizeof (req.nwda_data.nwdad_object_action.nwdad_parent));
	} else {
		req.nwda_data.nwdad_object_action.nwdad_parent[0] = '\0';
	}

	return (send_msg_to_nwam(&req));
}

nwam_error_t
nwam_request_state(nwam_object_type_t object_type, const char *name,
    const char *parent, nwam_state_t *statep, nwam_aux_state_t *auxp)
{
	nwamd_door_arg_t req;
	nwam_error_t err;

	assert(name != NULL && statep != NULL && auxp != NULL);

	req.nwda_type = NWAM_REQUEST_TYPE_STATE;

	req.nwda_data.nwdad_object_state.nwdad_object_type = object_type;

	(void) strlcpy(req.nwda_data.nwdad_object_state.nwdad_name, name,
	    sizeof (req.nwda_data.nwdad_object_state.nwdad_name));
	if (parent != NULL) {
		(void) strlcpy(req.nwda_data.nwdad_object_state.nwdad_parent,
		    parent,
		    sizeof (req.nwda_data.nwdad_object_state.nwdad_parent));
	}

	err = send_msg_to_nwam(&req);

	if (err == NWAM_SUCCESS) {
		*statep = req.nwda_data.nwdad_object_state.nwdad_state;
		*auxp = req.nwda_data.nwdad_object_state.nwdad_aux_state;
	}

	return (err);
}

nwam_error_t
nwam_request_wlan(nwam_request_type_t type, const char *name,
    const char *essid, const char *bssid, uint32_t security_mode,
    uint_t keyslot, const char *key, boolean_t add_to_known_wlans)
{
	nwamd_door_arg_t req;

	assert(name != NULL);

	req.nwda_type = type;

	(void) strlcpy(req.nwda_data.nwdad_wlan_info.nwdad_name, name,
	    sizeof (req.nwda_data.nwdad_wlan_info));
	if (essid != NULL) {
		(void) strlcpy(req.nwda_data.nwdad_wlan_info.nwdad_essid, essid,
		    sizeof (req.nwda_data.nwdad_wlan_info.nwdad_essid));
	} else {
		req.nwda_data.nwdad_wlan_info.nwdad_essid[0] = '\0';
	}
	if (bssid != NULL) {
		(void) strlcpy(req.nwda_data.nwdad_wlan_info.nwdad_bssid, bssid,
		    sizeof (req.nwda_data.nwdad_wlan_info.nwdad_bssid));
	} else {
		req.nwda_data.nwdad_wlan_info.nwdad_bssid[0] = '\0';
	}
	if (key != NULL) {
		(void) strlcpy(req.nwda_data.nwdad_wlan_info.nwdad_key, key,
		    sizeof (req.nwda_data.nwdad_wlan_info.nwdad_key));
		req.nwda_data.nwdad_wlan_info.nwdad_keyslot = keyslot;
	} else {
		req.nwda_data.nwdad_wlan_info.nwdad_key[0] = '\0';
	}

	req.nwda_data.nwdad_wlan_info.nwdad_security_mode = security_mode;
	req.nwda_data.nwdad_wlan_info.nwdad_add_to_known_wlans =
	    add_to_known_wlans;

	return (send_msg_to_nwam(&req));
}

nwam_error_t
nwam_request_wlan_scan_results(const char *name, uint_t *num_wlansp,
    nwam_wlan_t **wlansp)
{
	nwamd_door_arg_t req;
	nwam_error_t err;

	assert(name != NULL && num_wlansp != NULL && wlansp != NULL);

	req.nwda_type = NWAM_REQUEST_TYPE_WLAN_SCAN_RESULTS;

	(void) strlcpy(req.nwda_data.nwdad_wlan_info.nwdad_name, name,
	    sizeof (req.nwda_data.nwdad_wlan_info.nwdad_name));

	if ((err = send_msg_to_nwam(&req)) != NWAM_SUCCESS)
		return (err);

	*num_wlansp = req.nwda_data.nwdad_wlan_info.nwdad_num_wlans;

	*wlansp = calloc(*num_wlansp, sizeof (nwam_wlan_t));
	if (*wlansp == NULL)
		return (NWAM_NO_MEMORY);

	(void) memcpy(*wlansp, req.nwda_data.nwdad_wlan_info.nwdad_wlans,
	    *num_wlansp * sizeof (nwam_wlan_t));

	return (NWAM_SUCCESS);
}

nwam_error_t
nwam_request_active_priority_group(int64_t *priorityp)
{
	nwamd_door_arg_t req;
	nwam_error_t err;

	assert(priorityp != NULL);

	req.nwda_type = NWAM_REQUEST_TYPE_PRIORITY_GROUP;
	err = send_msg_to_nwam(&req);

	if (err == NWAM_SUCCESS)
		*priorityp =
		    req.nwda_data.nwdad_priority_group_info.nwdad_priority;

	return (err);
}

/* String conversion functions */

const char *
nwam_value_type_to_string(nwam_value_type_t type)
{
	switch (type) {
	case NWAM_VALUE_TYPE_BOOLEAN:
		return ("boolean");
	case NWAM_VALUE_TYPE_INT64:
		return ("int64");
	case NWAM_VALUE_TYPE_UINT64:
		return ("uint64");
	case NWAM_VALUE_TYPE_STRING:
		return ("string");
	default:
		return ("unknown");
	}
}

nwam_value_type_t
nwam_string_to_value_type(const char *typestr)
{
	if (strncmp(typestr, nwam_value_type_to_string(NWAM_VALUE_TYPE_BOOLEAN),
	    strlen(typestr)) == 0)
		return (NWAM_VALUE_TYPE_BOOLEAN);
	if (strncmp(typestr, nwam_value_type_to_string(NWAM_VALUE_TYPE_INT64),
	    strlen(typestr)) == 0)
		return (NWAM_VALUE_TYPE_INT64);
	if (strncmp(typestr, nwam_value_type_to_string(NWAM_VALUE_TYPE_UINT64),
	    strlen(typestr)) == 0)
		return (NWAM_VALUE_TYPE_UINT64);
	if (strncmp(typestr, nwam_value_type_to_string(NWAM_VALUE_TYPE_STRING),
	    strlen(typestr)) == 0)
		return (NWAM_VALUE_TYPE_STRING);
	return (NWAM_VALUE_TYPE_UNKNOWN);
}

const char *
nwam_action_to_string(nwam_action_t action)
{
	switch (action) {
	case NWAM_ACTION_ADD:
		return ("add");
	case NWAM_ACTION_REMOVE:
		return ("remove");
	case NWAM_ACTION_REFRESH:
		return ("refresh");
	case NWAM_ACTION_ENABLE:
		return ("enable");
	case NWAM_ACTION_DISABLE:
		return ("disable");
	case NWAM_ACTION_DESTROY:
		return ("destroy");
	default:
		return ("unknown");
	}
}

const char *
nwam_event_type_to_string(int event_type)
{
	switch (event_type) {
	case NWAM_EVENT_TYPE_NOOP:
		return ("NOOP");
	case NWAM_EVENT_TYPE_INIT:
		return ("INIT");
	case NWAM_EVENT_TYPE_SHUTDOWN:
		return ("SHUTDOWN");
	case NWAM_EVENT_TYPE_OBJECT_ACTION:
		return ("OBJECT_ACTION");
	case NWAM_EVENT_TYPE_OBJECT_STATE:
		return ("OBJECT_STATE");
	case NWAM_EVENT_TYPE_PRIORITY_GROUP:
		return ("PRIORITY_GROUP");
	case NWAM_EVENT_TYPE_INFO:
		return ("INFO");
	case NWAM_EVENT_TYPE_WLAN_SCAN_REPORT:
		return ("WLAN_SCAN_REPORT");
	case NWAM_EVENT_TYPE_WLAN_NEED_CHOICE:
		return ("WLAN_NEED_CHOICE");
	case NWAM_EVENT_TYPE_WLAN_NEED_KEY:
		return ("WLAN_NEED_KEY");
	case NWAM_EVENT_TYPE_WLAN_CONNECTION_REPORT:
		return ("WLAN_CONNECTION_REPORT");
	case NWAM_EVENT_TYPE_IF_ACTION:
		return ("IF_ACTION");
	case NWAM_EVENT_TYPE_IF_STATE:
		return ("IF_STATE");
	case NWAM_EVENT_TYPE_LINK_ACTION:
		return ("LINK_ACTION");
	case NWAM_EVENT_TYPE_LINK_STATE:
		return ("LINK_STATE");
	default:
		return ("UNKNOWN");
	}
}

const char *
nwam_state_to_string(nwam_state_t state)
{
	switch (state) {
	case NWAM_STATE_UNINITIALIZED:
		return ("uninitialized");
	case NWAM_STATE_INITIALIZED:
		return ("initialized");
	case NWAM_STATE_OFFLINE:
		return ("offline");
	case NWAM_STATE_OFFLINE_TO_ONLINE:
		return ("offline*");
	case NWAM_STATE_ONLINE_TO_OFFLINE:
		return ("online*");
	case NWAM_STATE_ONLINE:
		return ("online");
	case NWAM_STATE_MAINTENANCE:
		return ("maintenance");
	case NWAM_STATE_DEGRADED:
		return ("degraded");
	case NWAM_STATE_DISABLED:
		return ("disabled");
	default:
		return ("unknown");
	}
}

const char *
nwam_aux_state_to_string(nwam_aux_state_t aux_state)
{
	switch (aux_state) {
	case NWAM_AUX_STATE_UNINITIALIZED:
		return ("uninitialized");
	case NWAM_AUX_STATE_INITIALIZED:
		return ("(re)initialized but not configured");
	case NWAM_AUX_STATE_CONDITIONS_NOT_MET:
		return ("conditions for activation are unmet");
	case NWAM_AUX_STATE_MANUAL_DISABLE:
		return ("disabled by administrator");
	case NWAM_AUX_STATE_METHOD_FAILED:
		return ("method/service failed");
	case NWAM_AUX_STATE_METHOD_MISSING:
		return ("method or FMRI not specified");
	case NWAM_AUX_STATE_INVALID_CONFIG:
		return ("invalid configuration values");
	case NWAM_AUX_STATE_METHOD_RUNNING:
		return ("method/service executing");
	case NWAM_AUX_STATE_ACTIVE:
		return ("active");
	case NWAM_AUX_STATE_LINK_WIFI_SCANNING:
		return ("scanning for WiFi networks");
	case NWAM_AUX_STATE_LINK_WIFI_NEED_SELECTION:
		return ("need WiFi network selection");
	case NWAM_AUX_STATE_LINK_WIFI_NEED_KEY:
		return ("need WiFi security key");
	case NWAM_AUX_STATE_LINK_WIFI_CONNECTING:
		return ("connecting to WiFi network");
	case NWAM_AUX_STATE_IF_WAITING_FOR_ADDR:
		return ("waiting for IP address to be set");
	case NWAM_AUX_STATE_IF_DHCP_TIMED_OUT:
		return ("DHCP wait timeout, still trying...");
	case NWAM_AUX_STATE_IF_DUPLICATE_ADDR:
		return ("duplicate address detected");
	case NWAM_AUX_STATE_UP:
		return ("interface/link is up");
	case NWAM_AUX_STATE_DOWN:
		return ("interface/link is down");
	case NWAM_AUX_STATE_NOT_FOUND:
		return ("interface/link not found");
	default:
		return ("unknown");
	}
}

const char *
nwam_object_type_to_string(nwam_object_type_t type)
{
	switch (type) {
	case NWAM_OBJECT_TYPE_NCP:
		return ("ncp");
	case NWAM_OBJECT_TYPE_NCU:
		return ("ncu");
	case NWAM_OBJECT_TYPE_LOC:
		return ("loc");
	case NWAM_OBJECT_TYPE_ENM:
		return ("enm");
	case NWAM_OBJECT_TYPE_KNOWN_WLAN:
		return ("known wlan");
	default:
		return ("unknown");
	}
}

nwam_object_type_t
nwam_string_to_object_type(const char *typestr)
{
	if (strcasecmp(typestr,
	    nwam_object_type_to_string(NWAM_OBJECT_TYPE_NCP)) == 0)
		return (NWAM_OBJECT_TYPE_NCP);
	if (strcasecmp(typestr,
	    nwam_object_type_to_string(NWAM_OBJECT_TYPE_NCU)) == 0)
		return (NWAM_OBJECT_TYPE_NCU);
	if (strcasecmp(typestr,
	    nwam_object_type_to_string(NWAM_OBJECT_TYPE_LOC)) == 0)
		return (NWAM_OBJECT_TYPE_LOC);
	if (strcasecmp(typestr,
	    nwam_object_type_to_string(NWAM_OBJECT_TYPE_ENM)) == 0)
		return (NWAM_OBJECT_TYPE_ENM);
	if (strcasecmp(typestr,
	    nwam_object_type_to_string(NWAM_OBJECT_TYPE_KNOWN_WLAN)) == 0)
		return (NWAM_OBJECT_TYPE_KNOWN_WLAN);
	return (NWAM_OBJECT_TYPE_UNKNOWN);
}

nwam_error_t
nwam_errno_to_nwam_error(int errnum)
{
	switch (errnum) {
	case 0:
		return (NWAM_SUCCESS);
	case EBADF:
		return (NWAM_ERROR_BIND);
	case EPERM:
	case EACCES:
		return (NWAM_PERMISSION_DENIED);
	case ENOENT:
		return (NWAM_ENTITY_NOT_FOUND);
	case EIDRM:
		return (NWAM_ENTITY_INVALID);
	case EEXIST:
		return (NWAM_ENTITY_EXISTS);
	case EAGAIN:
	case EBUSY:
		return (NWAM_ENTITY_IN_USE);
	case ENOMEM:
	case ENOSPC:
		return (NWAM_NO_MEMORY);
	case EINVAL:
	case E2BIG:
		return (NWAM_INVALID_ARG);
	default:
		return (NWAM_ERROR_INTERNAL);
	}
}

/* Common validation functions */

/*
 * Do the flags represent a subset of valid_flags?
 */
nwam_error_t
nwam_valid_flags(uint64_t flags, uint64_t valid_flags)
{

	if ((flags | valid_flags) != valid_flags)
		return (NWAM_INVALID_ARG);
	return (NWAM_SUCCESS);
}

nwam_error_t
nwam_valid_condition(nwam_value_t value)
{
	char **conditions;
	uint_t i, numvalues;
	nwam_condition_object_type_t object_type;
	nwam_condition_t condition;

	if (nwam_value_get_string_array(value, &conditions, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		char *object_name = NULL;

		if (nwam_condition_string_to_condition(conditions[i],
		    &object_type, &condition, &object_name) != NWAM_SUCCESS)
			return (NWAM_ENTITY_INVALID_VALUE);
		if (object_name != NULL)
			free(object_name);
	}
	return (NWAM_SUCCESS);
}

/* check if boolean values are correct, generalize for array of booleans */
nwam_error_t
nwam_valid_boolean(nwam_value_t value)
{
	boolean_t *val;
	uint_t i, numvalues;

	if (nwam_value_get_boolean_array(value, &val, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		if (val[i] != B_TRUE && val[i] != B_FALSE)
			return (NWAM_ENTITY_INVALID_VALUE);
	}
	return (NWAM_SUCCESS);
}

/* check if uint64 values are correct, generalize for array of ints */
nwam_error_t
nwam_valid_uint64(nwam_value_t value)
{
	int64_t *val;
	uint_t i, numvalues;

	if (nwam_value_get_int64_array(value, &val, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		if (val[i] < 0)
			return (NWAM_ENTITY_INVALID_VALUE);
	}
	return (NWAM_SUCCESS);
}

/* check if domain names are correct, generalize for array of domains */
nwam_error_t
nwam_valid_domain(nwam_value_t value)
{
	char **domainvalues, *domain;
	uint_t i, numvalues;
	int len, j;

	if (nwam_value_get_string_array(value, &domainvalues, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		/*
		 * First and last character must be alphanumeric.
		 * Only '.' and '-' are allowed.
		 */
		domain = domainvalues[i];
		len = strlen(domain);
		if (!isalnum(domain[0]) || !isalnum(domain[len-1]))
			return (NWAM_ENTITY_INVALID_VALUE);
		for (j = 0; j < len; j++) {
			if (!isalnum(domain[j]) &&
			    domain[j] != '.' && domain[j] != '-')
				return (NWAM_ENTITY_INVALID_VALUE);
		}
	}
	return (NWAM_SUCCESS);
}

/* check if address prefix is valid */
static nwam_error_t
nwam_valid_prefix(char *addr, int max_plen)
{
	char *prefix, *end;
	int prefixlen;

	if ((prefix = strchr(addr, '/')) != NULL) {
		prefix++;
		prefixlen = strtol(prefix, &end, 10);
		if (prefix == end || prefixlen < 0 || prefixlen > max_plen)
			return (NWAM_ENTITY_INVALID_VALUE);
	}
	return (NWAM_SUCCESS);
}

/* check if IPv4 addresses are correct, generalize for array of addresses */
nwam_error_t
nwam_valid_host_v4(nwam_value_t value)
{
	char **addrvalues, *addr;
	uint_t i, numvalues;
	struct sockaddr_in sa;

	if (nwam_value_get_string_array(value, &addrvalues, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		addr = strdup(addrvalues[i]);
		if (nwam_valid_prefix(addr, IP_ABITS) != NWAM_SUCCESS) {
			free(addr);
			return (NWAM_ENTITY_INVALID_VALUE);
		}
		/* replace '/' with '\0' */
		addr = strsep(&addr, "/");
		if (inet_pton(AF_INET, addr, &(sa.sin_addr)) != 1) {
			free(addr);
			return (NWAM_ENTITY_INVALID_VALUE);
		}
		free(addr);
	}
	return (NWAM_SUCCESS);
}

/* Check if IPv4 address for default route is valid */
nwam_error_t
nwam_valid_route_v4(nwam_value_t value)
{
	char *addrvalue;
	struct sockaddr_in sa;

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

	if (inet_pton(AF_INET, addrvalue, &(sa.sin_addr)) != 1)
		return (NWAM_ENTITY_INVALID_VALUE);

	return (NWAM_SUCCESS);
}

/* check if IPv6 addresses are correct, generalize for array of addresses */
nwam_error_t
nwam_valid_host_v6(nwam_value_t value)
{
	char **addrvalues, *addr;
	uint_t i, numvalues;
	struct sockaddr_in6 sa;

	if (nwam_value_get_string_array(value, &addrvalues, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		addr = strdup(addrvalues[i]);
		if (nwam_valid_prefix(addr, IPV6_ABITS) != NWAM_SUCCESS) {
			free(addr);
			return (NWAM_ENTITY_INVALID_VALUE);
		}
		/* replace '/' with '\0' */
		addr = strsep(&addr, "/");
		if (inet_pton(AF_INET6, addr, &(sa.sin6_addr)) != 1) {
			free(addr);
			return (NWAM_ENTITY_INVALID_VALUE);
		}
		free(addr);
	}
	return (NWAM_SUCCESS);
}

/* Check if IPv4 address for default route is valid */
nwam_error_t
nwam_valid_route_v6(nwam_value_t value)
{
	char *addrvalue;
	struct sockaddr_in6 sa;

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

	if (inet_pton(AF_INET6, addrvalue, &(sa.sin6_addr)) != 1)
		return (NWAM_ENTITY_INVALID_VALUE);

	return (NWAM_SUCCESS);
}

nwam_error_t
nwam_valid_host_any(nwam_value_t value)
{
	if (nwam_valid_host_v4(value) != NWAM_SUCCESS &&
	    nwam_valid_host_v6(value) != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);
	return (NWAM_SUCCESS);
}

nwam_error_t
nwam_valid_host_or_domain(nwam_value_t value)
{
	if (nwam_valid_host_any(value) != NWAM_SUCCESS &&
	    nwam_valid_domain(value) != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);
	return (NWAM_SUCCESS);
}

/* We do not validate file existence, merely that it is an absolute path. */
nwam_error_t
nwam_valid_file(nwam_value_t value)
{
	char **files;
	uint_t i, numvalues;

	if (nwam_value_get_string_array(value, &files, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		int j = 0;
		while (isspace(files[i][j]))
			j++;
		if (files[i][j] != '/')
			return (NWAM_ENTITY_INVALID_VALUE);
	}
	return (NWAM_SUCCESS);
}

/*
 * We do not validate existence of the object pointed to by the FMRI
 * but merely ensure that it is a valid FMRI.  We do this by
 * using scf_handle_decode_fmri(), but ignore all errors bar
 * SCF_ERROR_INVALID_ARGUMENT (which indicates the FMRI is invalid).
 */
nwam_error_t
nwam_valid_fmri(nwam_value_t value)
{
	char **valstr;
	scf_handle_t *h = NULL;
	scf_service_t *svc = NULL;
	uint_t i, numvalues;
	nwam_error_t err = NWAM_SUCCESS;

	if ((err = nwam_value_get_string_array(value, &valstr, &numvalues))
	    != NWAM_SUCCESS)
		return (err);

	h = scf_handle_create(SCF_VERSION);
	if (h == NULL)
		return (NWAM_ERROR_INTERNAL);

	if (scf_handle_bind(h) != 0) {
		err = NWAM_ERROR_INTERNAL;
		goto out;
	}

	if ((svc = scf_service_create(h)) == NULL) {
		err = NWAM_ERROR_INTERNAL;
		goto out;
	}


	for (i = 0; i < numvalues; i++) {
		if (scf_handle_decode_fmri(h, valstr[i], NULL, svc,
		    NULL, NULL, NULL, SCF_DECODE_FMRI_TRUNCATE) == 0 ||
		    scf_error() != SCF_ERROR_INVALID_ARGUMENT) {
			err = NWAM_SUCCESS;
			continue;
		}
		err = NWAM_ENTITY_INVALID_VALUE;
		break;
	}
out:
	scf_service_destroy(svc);
	scf_handle_destroy(h);
	return (err);
}

/* verifies mac-address and bssids */
nwam_error_t
nwam_valid_mac_addr(nwam_value_t value)
{
	char **mac_addrs, *addr;
	uchar_t	*hwaddr;
	int hwaddrlen, j;
	uint_t i, numvalues;

	if (nwam_value_get_string_array(value, &mac_addrs, &numvalues)
	    != NWAM_SUCCESS)
		return (NWAM_ENTITY_INVALID_VALUE);

	for (i = 0; i < numvalues; i++) {
		addr = mac_addrs[i];
		j = 0;

		/* validate that a-fA-F0-9 and ':' only */
		while (addr[j] != 0) {
			if (!isxdigit(addr[j]) && addr[j] != ':')
				return (NWAM_ENTITY_INVALID_VALUE);
			j++;
		}

		if ((hwaddr = _link_aton(addr, &hwaddrlen)) == NULL)
			return (NWAM_ENTITY_INVALID_VALUE);
		free(hwaddr);
	}

	return (NWAM_SUCCESS);
}

boolean_t
nwam_uid_is_special(void)
{
	uid_t uid = getuid();
	return (uid == UID_NETADM || uid == 0);
}

nwam_error_t
nwam_get_smf_string_property(const char *fmri, const char *pgname,
    const char *propname, char **valuep)
{
	scf_handle_t *h = NULL;
	scf_snapshot_t *snap = NULL;
	scf_instance_t *inst = NULL;
	scf_propertygroup_t *pg = NULL;
	scf_property_t *prop = NULL;
	scf_value_t *val = NULL;
	nwam_error_t err = NWAM_SUCCESS;

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

	if ((h = scf_handle_create(SCF_VERSION)) == NULL ||
	    scf_handle_bind(h) != 0 ||
	    (inst = scf_instance_create(h)) == NULL ||
	    (snap = scf_snapshot_create(h)) == NULL ||
	    (pg = scf_pg_create(h)) == NULL ||
	    (prop = scf_property_create(h)) == NULL ||
	    (val = scf_value_create(h)) == NULL) {
		err = NWAM_ERROR_INTERNAL;
		goto out;
	}
	if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst,
	    NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0) {
		err = NWAM_ENTITY_NOT_FOUND;
		goto out;
	}
	/* Retrieve value from running snapshot (if present) */
	if (scf_instance_get_snapshot(inst, "running", snap) != 0) {
		scf_snapshot_destroy(snap);
		snap = NULL;
	}
	if (scf_instance_get_pg_composed(inst, snap, pgname, pg) != 0 ||
	    scf_pg_get_property(pg, propname, prop) != 0 ||
	    scf_property_get_value(prop, val) != 0 ||
	    scf_value_get_astring(val, *valuep, NWAM_MAX_NAME_LEN) == -1) {
		err = NWAM_ENTITY_NOT_FOUND;
	}
out:
	if (err != NWAM_SUCCESS)
		free(*valuep);

	scf_value_destroy(val);
	scf_property_destroy(prop);
	scf_pg_destroy(pg);
	if (snap != NULL)
		scf_snapshot_destroy(snap);
	scf_instance_destroy(inst);
	scf_handle_destroy(h);

	return (err);
}

nwam_error_t
nwam_set_smf_string_property(const char *fmri, const char *pgname,
    const char *propname, const char *propval)
{
	scf_handle_t *h = NULL;
	scf_instance_t *inst = NULL;
	scf_propertygroup_t *pg = NULL;
	scf_property_t *prop = NULL;
	scf_value_t *val = NULL;
	scf_transaction_t *tx = NULL;
	scf_transaction_entry_t *ent = NULL;
	nwam_error_t err = NWAM_SUCCESS;
	int result;

	if ((h = scf_handle_create(SCF_VERSION)) == NULL ||
	    scf_handle_bind(h) != 0 ||
	    (inst = scf_instance_create(h)) == NULL ||
	    (pg = scf_pg_create(h)) == NULL ||
	    (prop = scf_property_create(h)) == NULL ||
	    (val = scf_value_create(h)) == NULL ||
	    scf_value_set_astring(val, propval) != 0 ||
	    (tx = scf_transaction_create(h)) == NULL ||
	    (ent = scf_entry_create(h)) == NULL) {
		err = NWAM_ERROR_INTERNAL;
		goto out;
	}
	if (scf_handle_decode_fmri(h, fmri, NULL, NULL, inst,
	    NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0 ||
	    scf_instance_get_pg_composed(inst, NULL, pgname, pg) != 0) {
		err = NWAM_ENTITY_NOT_FOUND;
		goto out;
	}

retry:
	if (scf_transaction_start(tx, pg) == -1 ||
	    scf_transaction_property_change(tx, ent, propname, SCF_TYPE_ASTRING)
	    == -1 || scf_entry_add_value(ent, val) != 0) {
		err = NWAM_ERROR_INTERNAL;
		goto out;
	}

	result = scf_transaction_commit(tx);
	switch (result) {
	case 1:
		(void) smf_refresh_instance(fmri);
		break;
	case 0:
		scf_transaction_reset(tx);
		if (scf_pg_update(pg) == -1) {
			err = NWAM_ERROR_INTERNAL;
			goto out;
		}
		goto retry;
	default:
		err = NWAM_ERROR_INTERNAL;
		break;
	}
out:
	scf_value_destroy(val);
	scf_property_destroy(prop);
	scf_pg_destroy(pg);
	scf_instance_destroy(inst);
	scf_handle_destroy(h);

	return (err);
}