OpenSolaris_b135/lib/libnwam/common/libnwam_known_wlan.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 <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);
}