/*
 * 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 <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <libdllink.h>
#include <libdlwlan.h>

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

/*
 * Functions to support creating, modifying and destroying
 * known WLAN objects. These represent the WiFi connection history,
 * and are used by nwamd to identify and connect to known WLANs in
 * scan results.
 */

static nwam_error_t valid_keyname(nwam_value_t);
static nwam_error_t valid_keyslot(nwam_value_t);
static nwam_error_t valid_secmode(nwam_value_t);

struct nwam_prop_table_entry known_wlan_prop_table_entries[] = {
	{NWAM_KNOWN_WLAN_PROP_PRIORITY, NWAM_VALUE_TYPE_UINT64, B_FALSE,
	    1, 1, nwam_valid_uint64,
	    "specifies priority of known WLAN - lower values are prioritized",
	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
	{NWAM_KNOWN_WLAN_PROP_BSSIDS, NWAM_VALUE_TYPE_STRING, B_FALSE,
	    0, NWAM_MAX_NUM_VALUES, nwam_valid_mac_addr,
	    "specifies BSSID(s) (of the form aa:bb:cc:dd:ee:ff) associated "
	    "with known WLAN",
	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
	{NWAM_KNOWN_WLAN_PROP_KEYNAME, NWAM_VALUE_TYPE_STRING, B_FALSE,
	    0, 1, valid_keyname,
	    "specifies security key name used with known WLAN",
	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
	{NWAM_KNOWN_WLAN_PROP_KEYSLOT, NWAM_VALUE_TYPE_UINT64, B_FALSE,
	    0, 1, valid_keyslot,
	    "specifies key slot [1-4] for security key used with known WLAN",
	    NWAM_TYPE_ANY, NWAM_CLASS_ANY},
	{NWAM_KNOWN_WLAN_PROP_SECURITY_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE,
	    0, 1, valid_secmode,
	    "specifies security mode used for known WLAN",
	    NWAM_TYPE_ANY, NWAM_CLASS_ANY}
};

#define	NWAM_NUM_KNOWN_WLAN_PROPS	\
		(sizeof (known_wlan_prop_table_entries) / \
		sizeof (*known_wlan_prop_table_entries))

struct nwam_prop_table known_wlan_prop_table =
	{ NWAM_NUM_KNOWN_WLAN_PROPS, known_wlan_prop_table_entries };

nwam_error_t
nwam_known_wlan_read(const char *name, uint64_t flags,
    nwam_known_wlan_handle_t *kwhp)
{
	return (nwam_read(NWAM_OBJECT_TYPE_KNOWN_WLAN,
	    NWAM_KNOWN_WLAN_CONF_FILE, name, flags, kwhp));
}

nwam_error_t
nwam_known_wlan_create(const char *name, nwam_known_wlan_handle_t *kwhp)
{
	nwam_error_t err;
	nwam_value_t priorityval = NULL;

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

	if ((err = nwam_create(NWAM_OBJECT_TYPE_KNOWN_WLAN,
	    NWAM_KNOWN_WLAN_CONF_FILE, name, kwhp)) != NWAM_SUCCESS)
		return (err);

	/*
	 * Create new object list for known WLAN.  The initial priority is
	 * also set.
	 */
	if ((err = nwam_alloc_object_list(&((*kwhp)->nwh_data)))
	    != NWAM_SUCCESS)
		goto finish;
	if ((err = nwam_value_create_uint64(0, &priorityval)) != NWAM_SUCCESS)
		goto finish;
	err = nwam_set_prop_value((*kwhp)->nwh_data,
	    NWAM_KNOWN_WLAN_PROP_PRIORITY, priorityval);

finish:
	nwam_value_free(priorityval);
	if (err != NWAM_SUCCESS) {
		nwam_known_wlan_free(*kwhp);
		*kwhp = NULL;
	}
	return (err);
}

nwam_error_t
nwam_known_wlan_get_name(nwam_known_wlan_handle_t kwh, char **namep)
{
	return (nwam_get_name(kwh, namep));
}

nwam_error_t
nwam_known_wlan_set_name(nwam_known_wlan_handle_t kwh, const char *name)
{
	return (nwam_set_name(kwh, name));
}

boolean_t
nwam_known_wlan_can_set_name(nwam_known_wlan_handle_t kwh)
{
	return (!kwh->nwh_committed);
}

/*
 * Used to store wlan names/priorities for prioritized walk.
 */
struct nwam_wlan_info {
	char *wlan_name;
	uint64_t wlan_priority;
	boolean_t wlan_walked;
};

struct nwam_wlan_info_list {
	struct nwam_wlan_info **list;
	uint_t num_wlans;
};

/*
 * Used to read in each known WLAN name/priority.
 */
static int
get_wlans_cb(nwam_known_wlan_handle_t kwh, void *data)
{
	struct nwam_wlan_info_list *wil = data;
	struct nwam_wlan_info **list = wil->list;
	struct nwam_wlan_info **newlist = NULL;
	nwam_error_t err;
	nwam_value_t priorityval = NULL;
	uint_t num_wlans = wil->num_wlans;

	/* Reallocate WLAN list and allocate new info list element. */
	if ((newlist = realloc(list,
	    sizeof (struct nwam_wlan_info *) * ++num_wlans)) == NULL ||
	    (newlist[num_wlans - 1] = calloc(1,
	    sizeof (struct nwam_wlan_info))) == NULL) {
		if (newlist != NULL)
			free(newlist);
		return (NWAM_NO_MEMORY);
	}

	/* Update list since realloc() may have relocated it */
	wil->list = newlist;

	/* Retrieve name/priority */
	if ((err = nwam_known_wlan_get_name(kwh,
	    &((newlist[num_wlans - 1])->wlan_name))) != NWAM_SUCCESS ||
	    (err = nwam_known_wlan_get_prop_value(kwh,
	    NWAM_KNOWN_WLAN_PROP_PRIORITY, &priorityval)) != NWAM_SUCCESS ||
	    (err = nwam_value_get_uint64(priorityval,
	    &((newlist[num_wlans - 1])->wlan_priority))) != NWAM_SUCCESS) {
		free(newlist[num_wlans - 1]->wlan_name);
		nwam_value_free(priorityval);
		free(newlist[num_wlans - 1]);
		return (err);
	}
	nwam_value_free(priorityval);

	(newlist[num_wlans - 1])->wlan_walked = B_FALSE;

	wil->num_wlans = num_wlans;

	return (NWAM_SUCCESS);
}

/*
 * Some recursion is required here, since if _WALK_PRIORITY_ORDER is specified,
 * we need to first walk the list of known WLANs to retrieve names
 * and priorities, then utilize that list to carry out an in-order walk.
 */
nwam_error_t
nwam_walk_known_wlans(int(*cb)(nwam_known_wlan_handle_t, void *), void *data,
    uint64_t flags, int *retp)
{
	nwam_known_wlan_handle_t kwh;
	nwam_error_t err;
	int ret = 0;

	assert(cb != NULL);

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

	if ((flags & NWAM_FLAG_KNOWN_WLAN_WALK_PRIORITY_ORDER) != 0) {
		struct nwam_wlan_info_list wil = { NULL, 0};
		uint64_t iflags = flags &~
		    NWAM_FLAG_KNOWN_WLAN_WALK_PRIORITY_ORDER;
		uint64_t minpriority;
		int errval, i, j, minindex;

		if (nwam_walk_known_wlans(get_wlans_cb, &wil, iflags, &errval)
		    != NWAM_SUCCESS) {
			err = (nwam_error_t)errval;
			goto done;
		}

		err = NWAM_SUCCESS;

		for (i = 0; i < wil.num_wlans; i++) {
			/* Find lowest priority value not walked so far. */
			minpriority = (uint64_t)-1;
			for (j = 0; j < wil.num_wlans; j++) {
				if (wil.list[j]->wlan_priority < minpriority &&
				    !(wil.list[j]->wlan_walked)) {
					minpriority =
					    wil.list[j]->wlan_priority;
					minindex = j;
				}
			}
			wil.list[minindex]->wlan_walked = B_TRUE;
			if ((err = nwam_known_wlan_read
			    (wil.list[minindex]->wlan_name,
			    iflags, &kwh)) != NWAM_SUCCESS) {
				goto done;
			}
			ret = cb(kwh, data);
			if (ret != 0) {
				nwam_known_wlan_free(kwh);
				err = NWAM_WALK_HALTED;
				goto done;
			}
			nwam_known_wlan_free(kwh);
		}
done:
		if (wil.list != NULL) {
			for (j = 0; j < wil.num_wlans; j++) {
				free(wil.list[j]->wlan_name);
				free(wil.list[j]);
			}
			free(wil.list);
		}
		if (retp != NULL)
			*retp = ret;
		return (err);
	}

	return (nwam_walk(NWAM_OBJECT_TYPE_KNOWN_WLAN,
	    NWAM_KNOWN_WLAN_CONF_FILE, cb, data, flags, retp, NULL));
}

void
nwam_known_wlan_free(nwam_known_wlan_handle_t kwh)
{
	nwam_free(kwh);
}

nwam_error_t
nwam_known_wlan_copy(nwam_known_wlan_handle_t oldkwh, const char *newname,
    nwam_known_wlan_handle_t *newkwhp)
{
	return (nwam_copy(NWAM_KNOWN_WLAN_CONF_FILE, oldkwh, newname, newkwhp));
}

nwam_error_t
nwam_known_wlan_delete_prop(nwam_known_wlan_handle_t kwh, const char *propname)
{
	nwam_error_t err;
	void *olddata;

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

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

	return (NWAM_SUCCESS);
}

nwam_error_t
nwam_known_wlan_set_prop_value(nwam_known_wlan_handle_t kwh,
    const char *propname, nwam_value_t value)
{
	nwam_error_t err;

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

	if ((err = nwam_known_wlan_validate_prop(kwh, propname, value))
	    != NWAM_SUCCESS)
		return (err);

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

nwam_error_t
nwam_known_wlan_get_prop_value(nwam_known_wlan_handle_t kwh,
    const char *propname, nwam_value_t *valuep)
{
	return (nwam_get_prop_value(kwh->nwh_data, propname, valuep));
}

nwam_error_t
nwam_known_wlan_walk_props(nwam_known_wlan_handle_t kwh,
    int (*cb)(const char *, nwam_value_t, void *),
    void *data, uint64_t flags, int *retp)
{
	return (nwam_walk_props(kwh, cb, data, flags, retp));
}

struct priority_collision_data {
	char *wlan_name;
	uint64_t priority;
};

static int
avoid_priority_collisions_cb(nwam_known_wlan_handle_t kwh, void *data)
{
	nwam_value_t priorityval;
	nwam_error_t err;
	struct priority_collision_data *pcd = data;
	char *name;
	uint64_t priority;

	err = nwam_known_wlan_get_name(kwh, &name);
	if (err != NWAM_SUCCESS)
		return (err);
	if (strcmp(name, pcd->wlan_name) == 0) {
		/* skip to-be-updated wlan */
		free(name);
		return (NWAM_SUCCESS);
	}
	free(name);

	err = nwam_known_wlan_get_prop_value(kwh, NWAM_KNOWN_WLAN_PROP_PRIORITY,
	    &priorityval);
	if (err != NWAM_SUCCESS)
		return (err);
	err = nwam_value_get_uint64(priorityval, &priority);
	if (err != NWAM_SUCCESS)
		return (err);
	nwam_value_free(priorityval);

	if (priority < pcd->priority)
		return (NWAM_SUCCESS);

	if (priority == pcd->priority) {
		/* Two priority values collide.  Move this one up. */
		err = nwam_value_create_uint64(priority + 1, &priorityval);
		if (err != NWAM_SUCCESS)
			return (err);
		err = nwam_known_wlan_set_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_PRIORITY, priorityval);
		nwam_value_free(priorityval);
		if (err != NWAM_SUCCESS) {
			return (err);
		}
		/*
		 * We are doing a walk, and will continue shifting until
		 * we find a gap in the priority numbers; thus no need to
		 * do collision checking here.
		 */
		err = nwam_known_wlan_commit(kwh,
		    NWAM_FLAG_KNOWN_WLAN_NO_COLLISION_CHECK);
		if (err != NWAM_SUCCESS)
			return (err);

		(pcd->priority)++;
		return (NWAM_SUCCESS);
	}

	/*
	 * Only possiblity left at this point is that we're looking
	 * at a priority greater than the last one we wrote, so we've
	 * found a gap.  We can halt the walk now.
	 */
	return (NWAM_WALK_HALTED);
}

nwam_error_t
nwam_known_wlan_commit(nwam_known_wlan_handle_t kwh, uint64_t flags)
{
	nwam_error_t err;
	nwam_value_t priorityval;
	int ret = 0;
	struct priority_collision_data pcd;

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

	if ((err = nwam_known_wlan_validate(kwh, NULL)) != NWAM_SUCCESS)
		return (err);

	/*
	 * If the NO_COLLISION_CHECK flag is set, no need to check for
	 * collision.
	 */
	if (flags & NWAM_FLAG_KNOWN_WLAN_NO_COLLISION_CHECK)
		return (nwam_commit(NWAM_KNOWN_WLAN_CONF_FILE, kwh,
		    (flags & NWAM_FLAG_GLOBAL_MASK) |
		    NWAM_FLAG_ENTITY_KNOWN_WLAN));

	/*
	 * We need to do priority checking.  Walk the list, looking
	 * for the first entry with priority greater than or equal
	 * to the entry we're adding.  Commit the new one (without
	 * doing additional checking), and then increment other
	 * entries as needed.
	 */
	err = nwam_known_wlan_get_prop_value(kwh,
	    NWAM_KNOWN_WLAN_PROP_PRIORITY, &priorityval);
	if (err != NWAM_SUCCESS)
		return (err);
	err = nwam_value_get_uint64(priorityval, &(pcd.priority));
	nwam_value_free(priorityval);
	if (err != NWAM_SUCCESS)
		return (err);
	err = nwam_known_wlan_get_name(kwh, &(pcd.wlan_name));
	if (err != NWAM_SUCCESS)
		return (err);
	err = nwam_walk_known_wlans(avoid_priority_collisions_cb, &pcd,
	    NWAM_FLAG_KNOWN_WLAN_WALK_PRIORITY_ORDER, &ret);
	free(pcd.wlan_name);
	/*
	 * a halted walk is okay, it just means we didn't have
	 * to walk the entire list to resolve priorities
	 */
	if (ret != NWAM_SUCCESS && ret != NWAM_WALK_HALTED)
		return (ret);

	return (nwam_known_wlan_commit(kwh,
	    flags | NWAM_FLAG_KNOWN_WLAN_NO_COLLISION_CHECK));
}

nwam_error_t
nwam_known_wlan_destroy(nwam_known_wlan_handle_t kwh, uint64_t flags)
{
	return (nwam_destroy(NWAM_KNOWN_WLAN_CONF_FILE, kwh,
	    flags | NWAM_FLAG_ENTITY_KNOWN_WLAN));
}

nwam_error_t
nwam_known_wlan_get_prop_description(const char *propname,
    const char **descriptionp)
{
	return (nwam_get_prop_description(known_wlan_prop_table, propname,
	    descriptionp));
}

/* Property-specific value validation functions should go here. */

static nwam_error_t
valid_keyname(nwam_value_t value)
{
	char *keyname;

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

	if (!dladm_valid_secobj_name(keyname))
		return (NWAM_ENTITY_INVALID_VALUE);

	return (NWAM_SUCCESS);
}

static nwam_error_t
valid_keyslot(nwam_value_t value)
{
	uint64_t keyslot;

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

	if (keyslot < 1 || keyslot > 4)
		return (NWAM_ENTITY_INVALID_VALUE);

	return (NWAM_SUCCESS);
}

static nwam_error_t
valid_secmode(nwam_value_t value)
{
	uint64_t secmode;

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

	if (secmode != DLADM_WLAN_SECMODE_NONE &&
	    secmode != DLADM_WLAN_SECMODE_WEP &&
	    secmode != DLADM_WLAN_SECMODE_WPA)
		return (NWAM_ENTITY_INVALID_VALUE);

	return (NWAM_SUCCESS);
}

nwam_error_t
nwam_known_wlan_validate(nwam_known_wlan_handle_t kwh, const char **errpropp)
{
	return (nwam_validate(known_wlan_prop_table, kwh, errpropp));
}

nwam_error_t
nwam_known_wlan_validate_prop(nwam_known_wlan_handle_t kwh,
    const char *propname, nwam_value_t value)
{
	return (nwam_validate_prop(known_wlan_prop_table, kwh, propname,
	    value));
}

/*
 * Given a property, return expected property data type
 */
nwam_error_t
nwam_known_wlan_get_prop_type(const char *propname, nwam_value_type_t *typep)
{
	return (nwam_get_prop_type(known_wlan_prop_table, propname, typep));
}

nwam_error_t
nwam_known_wlan_prop_multivalued(const char *propname, boolean_t *multip)
{
	return (nwam_prop_multivalued(known_wlan_prop_table, propname, multip));
}

nwam_error_t
nwam_known_wlan_get_default_proplist(const char ***prop_list,
    uint_t *numvaluesp)
{
	return (nwam_get_default_proplist(known_wlan_prop_table,
	    NWAM_TYPE_ANY, NWAM_CLASS_ANY, prop_list, numvaluesp));
}

/*
 * Add the given ESSID, BSSID, secmode, keyslot and key name to known WLANs.
 * BSSID and keyname can be NULL.
 */
nwam_error_t
nwam_known_wlan_add_to_known_wlans(const char *essid, const char *bssid,
    uint32_t secmode, uint_t keyslot, const char *keyname)
{
	nwam_known_wlan_handle_t kwh;
	nwam_value_t keynameval = NULL, keyslotval = NULL, bssidsval = NULL;
	nwam_value_t secmodeval = NULL, priorityval = NULL;
	char **old_bssids = NULL, **new_bssids;
	uint_t nelem = 0;
	nwam_error_t err;
	int i, j;

	/*
	 * Check if the given ESSID already exists as known WLAN.  If so,
	 * add the BSSID to the bssids property.  If not, create one with
	 * the given ESSID and add BSSID if given.
	 */
	err = nwam_known_wlan_read(essid, 0, &kwh);

	switch (err) {
	case NWAM_ENTITY_NOT_FOUND:
		if ((err = nwam_known_wlan_create(essid, &kwh)) != NWAM_SUCCESS)
			return (err);
		/* New known WLAN - set priority to 0 */
		if ((err = nwam_value_create_uint64(0, &priorityval))
		    != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		err = nwam_known_wlan_set_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_PRIORITY, priorityval);
		nwam_value_free(priorityval);
		if (err != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		/* If BSSID is NULL, nothing more to do here. */
		if (bssid == NULL)
			break;
		if ((err = nwam_value_create_string((char *)bssid, &bssidsval))
		    != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		/* Set the bssids property */
		err = nwam_known_wlan_set_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_BSSIDS, bssidsval);
		nwam_value_free(bssidsval);
		if (err != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		break;
	case NWAM_SUCCESS:
		/* If no bssid is specified, nothing to do */
		if (bssid == NULL)
			break;

		/* known WLAN exists, retrieve the existing bssids property */
		err = nwam_known_wlan_get_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_BSSIDS, &bssidsval);
		if (err != NWAM_SUCCESS && err != NWAM_ENTITY_NOT_FOUND) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		if (err == NWAM_SUCCESS) {
			if ((err = nwam_value_get_string_array(bssidsval,
			    &old_bssids, &nelem)) != NWAM_SUCCESS) {
				nwam_value_free(bssidsval);
				nwam_known_wlan_free(kwh);
				return (err);
			}
		}
		/* Create a new array to append given BSSID */
		new_bssids = calloc(nelem + 1, sizeof (char *));
		if (new_bssids == NULL) {
			nwam_value_free(bssidsval);
			nwam_known_wlan_free(kwh);
			return (NWAM_NO_MEMORY);
		}

		/*
		 * Copy over existing BSSIDs to the new array.  Also, check
		 * to make sure that the given BSSID doesn't already exist
		 * in the known WLAN.  If so, do abort copying and return
		 * NWAM_SUCCESS.
		 */
		for (i = 0; i < nelem; i++) {
			if (strcmp(old_bssids[i], bssid) == 0) {
				/* nothing to do, so free up everything */
				for (j = 0; j < i; j++)
					free(new_bssids[j]);
				free(new_bssids);
				nwam_value_free(bssidsval);
				goto set_key_info;
			}
			new_bssids[i] = strdup(old_bssids[i]);
		}
		new_bssids[nelem] = strdup(bssid);
		nwam_value_free(bssidsval);

		err = nwam_value_create_string_array(new_bssids, nelem + 1,
		    &bssidsval);
		for (i = 0; i < nelem + 1; i++)
			free(new_bssids[i]);
		free(new_bssids);
		if (err != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		/* Set the bssids property */
		err = nwam_known_wlan_set_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_BSSIDS, bssidsval);
		nwam_value_free(bssidsval);
		if (err != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		break;
	default:
		return (err);
	}

set_key_info:
	/* Set the security mode property */
	if ((err = nwam_value_create_uint64(secmode, &secmodeval))
	    != NWAM_SUCCESS) {
		nwam_known_wlan_free(kwh);
		return (err);
	}
	err = nwam_known_wlan_set_prop_value(kwh,
	    NWAM_KNOWN_WLAN_PROP_SECURITY_MODE, secmodeval);
	nwam_value_free(secmodeval);

	if (err != NWAM_SUCCESS) {
		nwam_known_wlan_free(kwh);
		return (err);
	}

	if (keyname != NULL) {
		if ((err = nwam_value_create_string((char *)keyname,
		    &keynameval)) != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		err = nwam_known_wlan_set_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_KEYNAME, keynameval);
		nwam_value_free(keynameval);
		if (err != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		if ((err = nwam_value_create_uint64(keyslot,
		    &keyslotval)) != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		err = nwam_known_wlan_set_prop_value(kwh,
		    NWAM_KNOWN_WLAN_PROP_KEYSLOT, keyslotval);
		nwam_value_free(keyslotval);
	}

	err = nwam_known_wlan_commit(kwh, 0);
	nwam_known_wlan_free(kwh);

	return (err);
}

/*
 * Remove the given BSSID/keyname from the bssids/keyname property for the
 * given ESSID.
 */
nwam_error_t
nwam_known_wlan_remove_from_known_wlans(const char *essid, const char *bssid,
    const char *keyname)
{
	nwam_known_wlan_handle_t kwh;
	nwam_value_t bssidsval;
	char **old_bssids, **new_bssids;
	uint_t nelem;
	nwam_error_t err;
	int i, found = -1;

	/* Retrieve the existing bssids */
	if ((err = nwam_known_wlan_read(essid, 0, &kwh)) != NWAM_SUCCESS)
		return (err);
	if ((err = nwam_known_wlan_get_prop_value(kwh,
	    NWAM_KNOWN_WLAN_PROP_BSSIDS, &bssidsval)) != NWAM_SUCCESS) {
		nwam_known_wlan_free(kwh);
		return (err);
	}
	if ((err = nwam_value_get_string_array(bssidsval, &old_bssids, &nelem))
	    != NWAM_SUCCESS) {
		nwam_value_free(bssidsval);
		nwam_known_wlan_free(kwh);
		return (err);
	}

	/* Cycle through the BSSIDs array to find the BSSID to remove */
	for (i = 0; i < nelem; i++) {
		if (strcmp(old_bssids[i], bssid)  == 0) {
			found = i;
			break;
		}
	}

	/* Given BSSID was not found in the array */
	if (found == -1) {
		nwam_value_free(bssidsval);
		nwam_known_wlan_free(kwh);
		return (NWAM_INVALID_ARG);
	}

	/* If removing the only BSSID entry, remove the bssids property */
	if (nelem == 1) {
		nwam_value_free(bssidsval);
		if ((err = nwam_known_wlan_delete_prop(kwh,
		    NWAM_KNOWN_WLAN_PROP_BSSIDS)) != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		err = nwam_known_wlan_commit(kwh, 0);
		nwam_known_wlan_free(kwh);
		return (err);
	}

	new_bssids = calloc(nelem - 1, sizeof (char *));
	if (new_bssids == NULL) {
		nwam_value_free(bssidsval);
		nwam_known_wlan_free(kwh);
		return (NWAM_NO_MEMORY);
	}

	/* Copy over other BSSIDs */
	for (i = 0; i < found; i++)
		new_bssids[i] = strdup(old_bssids[i]);
	for (i = found + 1; i < nelem; i++)
		new_bssids[i-1] = strdup(old_bssids[i]);
	nwam_value_free(bssidsval);

	err = nwam_value_create_string_array(new_bssids, nelem - 1, &bssidsval);
	for (i = 0; i < nelem - 1; i++)
		free(new_bssids[i]);
	free(new_bssids);
	if (err != NWAM_SUCCESS) {
		nwam_known_wlan_free(kwh);
		return (err);
	}

	/* Set the bssids property */
	err = nwam_known_wlan_set_prop_value(kwh, NWAM_KNOWN_WLAN_PROP_BSSIDS,
	    bssidsval);
	nwam_value_free(bssidsval);
	if (err != NWAM_SUCCESS) {
		nwam_known_wlan_free(kwh);
		return (err);
	}

	if (keyname != NULL) {
		if ((err = nwam_known_wlan_delete_prop(kwh,
		    NWAM_KNOWN_WLAN_PROP_KEYNAME)) != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
		if ((err = nwam_known_wlan_delete_prop(kwh,
		    NWAM_KNOWN_WLAN_PROP_KEYSLOT)) != NWAM_SUCCESS) {
			nwam_known_wlan_free(kwh);
			return (err);
		}
	}

	err = nwam_known_wlan_commit(kwh, 0);
	nwam_known_wlan_free(kwh);

	return (err);
}