971 lines
29 KiB
C++
971 lines
29 KiB
C++
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
|
|
#define LOG_TAG "WifiNetwork"
|
|
#include <cutils/log.h>
|
|
|
|
#include "NetworkManager.h"
|
|
#include "WifiNetwork.h"
|
|
#include "Supplicant.h"
|
|
#include "WifiController.h"
|
|
|
|
WifiNetwork::WifiNetwork() {
|
|
// This is private to restrict copy constructors
|
|
}
|
|
|
|
WifiNetwork::WifiNetwork(WifiController *c, Supplicant *suppl, const char *data) {
|
|
mController = c;
|
|
mSuppl = suppl;
|
|
|
|
char *tmp = strdup(data);
|
|
char *next = tmp;
|
|
char *id;
|
|
char *ssid;
|
|
char *bssid;
|
|
char *flags;
|
|
|
|
if (!(id = strsep(&next, "\t")))
|
|
LOGE("Failed to extract network id");
|
|
if (!(ssid = strsep(&next, "\t")))
|
|
LOGE("Failed to extract ssid");
|
|
if (!(bssid = strsep(&next, "\t")))
|
|
LOGE("Failed to extract bssid");
|
|
if (!(flags = strsep(&next, "\t")))
|
|
LOGE("Failed to extract flags");
|
|
|
|
// LOGD("id '%s', ssid '%s', bssid '%s', flags '%s'", id, ssid, bssid,
|
|
// flags ? flags :"null");
|
|
|
|
if (id)
|
|
mNetid = atoi(id);
|
|
if (ssid)
|
|
mSsid = strdup(ssid);
|
|
if (bssid)
|
|
mBssid = strdup(bssid);
|
|
|
|
mPsk = NULL;
|
|
memset(mWepKeys, 0, sizeof(mWepKeys));
|
|
mDefaultKeyIndex = -1;
|
|
mPriority = -1;
|
|
mHiddenSsid = NULL;
|
|
mKeyManagement = KeyManagementMask::UNKNOWN;
|
|
mProtocols = 0;
|
|
mAuthAlgorithms = 0;
|
|
mPairwiseCiphers = 0;
|
|
mGroupCiphers = 0;
|
|
mEnabled = true;
|
|
|
|
if (flags && flags[0] != '\0') {
|
|
if (!strcmp(flags, "[DISABLED]"))
|
|
mEnabled = false;
|
|
else
|
|
LOGW("Unsupported flags '%s'", flags);
|
|
}
|
|
|
|
free(tmp);
|
|
createProperties();
|
|
}
|
|
|
|
WifiNetwork::WifiNetwork(WifiController *c, Supplicant *suppl, int networkId) {
|
|
mController = c;
|
|
mSuppl = suppl;
|
|
mNetid = networkId;
|
|
mSsid = NULL;
|
|
mBssid = NULL;
|
|
mPsk = NULL;
|
|
memset(mWepKeys, 0, sizeof(mWepKeys));
|
|
mDefaultKeyIndex = -1;
|
|
mPriority = -1;
|
|
mHiddenSsid = NULL;
|
|
mKeyManagement = 0;
|
|
mProtocols = 0;
|
|
mAuthAlgorithms = 0;
|
|
mPairwiseCiphers = 0;
|
|
mGroupCiphers = 0;
|
|
mEnabled = false;
|
|
createProperties();
|
|
}
|
|
|
|
WifiNetwork *WifiNetwork::clone() {
|
|
WifiNetwork *r = new WifiNetwork();
|
|
|
|
r->mSuppl = mSuppl;
|
|
r->mNetid = mNetid;
|
|
|
|
if (mSsid)
|
|
r->mSsid = strdup(mSsid);
|
|
if (mBssid)
|
|
r->mBssid = strdup(mBssid);
|
|
if (mPsk)
|
|
r->mPsk = strdup(mPsk);
|
|
|
|
r->mController = mController;
|
|
memcpy(r->mWepKeys, mWepKeys, sizeof(mWepKeys));
|
|
r->mDefaultKeyIndex = mDefaultKeyIndex;
|
|
r->mPriority = mPriority;
|
|
if (mHiddenSsid)
|
|
r->mHiddenSsid = strdup(mHiddenSsid);
|
|
r->mKeyManagement = mKeyManagement;
|
|
r->mProtocols = mProtocols;
|
|
r->mAuthAlgorithms = mAuthAlgorithms;
|
|
r->mPairwiseCiphers = mPairwiseCiphers;
|
|
r->mGroupCiphers = mGroupCiphers;
|
|
return r;
|
|
}
|
|
|
|
void WifiNetwork::createProperties() {
|
|
asprintf(&mPropNamespace, "wifi.net.%d", mNetid);
|
|
|
|
mStaticProperties.propEnabled = new WifiNetworkEnabledProperty(this);
|
|
mStaticProperties.propSsid = new WifiNetworkSsidProperty(this);
|
|
mStaticProperties.propBssid = new WifiNetworkBssidProperty(this);
|
|
mStaticProperties.propPsk = new WifiNetworkPskProperty(this);
|
|
mStaticProperties.propWepKey = new WifiNetworkWepKeyProperty(this);
|
|
mStaticProperties.propDefKeyIdx = new WifiNetworkDefaultKeyIndexProperty(this);
|
|
mStaticProperties.propPriority = new WifiNetworkPriorityProperty(this);
|
|
mStaticProperties.propKeyManagement = new WifiNetworkKeyManagementProperty(this);
|
|
mStaticProperties.propProtocols = new WifiNetworkProtocolsProperty(this);
|
|
mStaticProperties.propAuthAlgorithms = new WifiNetworkAuthAlgorithmsProperty(this);
|
|
mStaticProperties.propPairwiseCiphers = new WifiNetworkPairwiseCiphersProperty(this);
|
|
mStaticProperties.propGroupCiphers = new WifiNetworkGroupCiphersProperty(this);
|
|
mStaticProperties.propHiddenSsid = new WifiNetworkHiddenSsidProperty(this);
|
|
}
|
|
|
|
WifiNetwork::~WifiNetwork() {
|
|
if (mPropNamespace)
|
|
free(mPropNamespace);
|
|
if (mSsid)
|
|
free(mSsid);
|
|
if (mBssid)
|
|
free(mBssid);
|
|
if (mPsk)
|
|
free(mPsk);
|
|
for (int i = 0; i < 4; i++) {
|
|
if (mWepKeys[i])
|
|
free(mWepKeys[i]);
|
|
}
|
|
|
|
if (mHiddenSsid)
|
|
free(mHiddenSsid);
|
|
|
|
delete mStaticProperties.propEnabled;
|
|
delete mStaticProperties.propSsid;
|
|
delete mStaticProperties.propBssid;
|
|
delete mStaticProperties.propPsk;
|
|
delete mStaticProperties.propWepKey;
|
|
delete mStaticProperties.propDefKeyIdx;
|
|
delete mStaticProperties.propPriority;
|
|
delete mStaticProperties.propKeyManagement;
|
|
delete mStaticProperties.propProtocols;
|
|
delete mStaticProperties.propAuthAlgorithms;
|
|
delete mStaticProperties.propPairwiseCiphers;
|
|
delete mStaticProperties.propGroupCiphers;
|
|
delete mStaticProperties.propHiddenSsid;
|
|
}
|
|
|
|
int WifiNetwork::refresh() {
|
|
char buffer[255];
|
|
size_t len;
|
|
uint32_t mask;
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "psk", buffer, len))
|
|
mPsk = strdup(buffer);
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
char *name;
|
|
|
|
asprintf(&name, "wep_key%d", i);
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, name, buffer, len))
|
|
mWepKeys[i] = strdup(buffer);
|
|
free(name);
|
|
}
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "wep_tx_keyidx", buffer, len))
|
|
mDefaultKeyIndex = atoi(buffer);
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "priority", buffer, len))
|
|
mPriority = atoi(buffer);
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "scan_ssid", buffer, len))
|
|
mHiddenSsid = strdup(buffer);
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "key_mgmt", buffer, len)) {
|
|
if (WifiNetwork::parseKeyManagementMask(buffer, &mask)) {
|
|
LOGE("Error parsing key_mgmt (%s)", strerror(errno));
|
|
} else {
|
|
mKeyManagement = mask;
|
|
}
|
|
}
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "proto", buffer, len)) {
|
|
if (WifiNetwork::parseProtocolsMask(buffer, &mask)) {
|
|
LOGE("Error parsing proto (%s)", strerror(errno));
|
|
} else {
|
|
mProtocols = mask;
|
|
}
|
|
}
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "auth_alg", buffer, len)) {
|
|
if (WifiNetwork::parseAuthAlgorithmsMask(buffer, &mask)) {
|
|
LOGE("Error parsing auth_alg (%s)", strerror(errno));
|
|
} else {
|
|
mAuthAlgorithms = mask;
|
|
}
|
|
}
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "pairwise", buffer, len)) {
|
|
if (WifiNetwork::parsePairwiseCiphersMask(buffer, &mask)) {
|
|
LOGE("Error parsing pairwise (%s)", strerror(errno));
|
|
} else {
|
|
mPairwiseCiphers = mask;
|
|
}
|
|
}
|
|
|
|
len = sizeof(buffer);
|
|
if (mSuppl->getNetworkVar(mNetid, "group", buffer, len)) {
|
|
if (WifiNetwork::parseGroupCiphersMask(buffer, &mask)) {
|
|
LOGE("Error parsing group (%s)", strerror(errno));
|
|
} else {
|
|
mGroupCiphers = mask;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
out_err:
|
|
LOGE("Refresh failed (%s)",strerror(errno));
|
|
return -1;
|
|
}
|
|
|
|
int WifiNetwork::setSsid(const char *ssid) {
|
|
char tmp[255];
|
|
snprintf(tmp, sizeof(tmp), "\"%s\"", ssid);
|
|
if (mSuppl->setNetworkVar(mNetid, "ssid", tmp))
|
|
return -1;
|
|
if (mSsid)
|
|
free(mSsid);
|
|
mSsid = strdup(ssid);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setBssid(const char *bssid) {
|
|
if (mSuppl->setNetworkVar(mNetid, "bssid", bssid))
|
|
return -1;
|
|
if (mBssid)
|
|
free(mBssid);
|
|
mBssid = strdup(bssid);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setPsk(const char *psk) {
|
|
char tmp[255];
|
|
snprintf(tmp, sizeof(tmp), "\"%s\"", psk);
|
|
if (mSuppl->setNetworkVar(mNetid, "psk", tmp))
|
|
return -1;
|
|
|
|
if (mPsk)
|
|
free(mPsk);
|
|
mPsk = strdup(psk);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setWepKey(int idx, const char *key) {
|
|
char *name;
|
|
|
|
asprintf(&name, "wep_key%d", idx);
|
|
int rc = mSuppl->setNetworkVar(mNetid, name, key);
|
|
free(name);
|
|
|
|
if (rc)
|
|
return -1;
|
|
|
|
if (mWepKeys[idx])
|
|
free(mWepKeys[idx]);
|
|
mWepKeys[idx] = strdup(key);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setDefaultKeyIndex(int idx) {
|
|
char val[16];
|
|
sprintf(val, "%d", idx);
|
|
if (mSuppl->setNetworkVar(mNetid, "wep_tx_keyidx", val))
|
|
return -1;
|
|
|
|
mDefaultKeyIndex = idx;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setPriority(int priority) {
|
|
char val[16];
|
|
sprintf(val, "%d", priority);
|
|
if (mSuppl->setNetworkVar(mNetid, "priority", val))
|
|
return -1;
|
|
|
|
mPriority = priority;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setHiddenSsid(const char *ssid) {
|
|
if (mSuppl->setNetworkVar(mNetid, "scan_ssid", ssid))
|
|
return -1;
|
|
|
|
if (mHiddenSsid)
|
|
free(mHiddenSsid);
|
|
mHiddenSsid = strdup(ssid);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setKeyManagement(uint32_t mask) {
|
|
char accum[64] = {'\0'};
|
|
|
|
if (mask == KeyManagementMask::NONE)
|
|
strcpy(accum, "NONE");
|
|
else {
|
|
if (mask & KeyManagementMask::WPA_PSK)
|
|
strcat(accum, "WPA-PSK");
|
|
if (mask & KeyManagementMask::WPA_EAP) {
|
|
if (accum[0] != '\0')
|
|
strcat(accum, " ");
|
|
strcat(accum, "WPA-EAP");
|
|
}
|
|
if (mask & KeyManagementMask::IEEE8021X) {
|
|
if (accum[0] != '\0')
|
|
strcat(accum, " ");
|
|
strcat(accum, "IEEE8021X");
|
|
}
|
|
}
|
|
|
|
if (mSuppl->setNetworkVar(mNetid, "key_mgmt", accum))
|
|
return -1;
|
|
mKeyManagement = mask;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setProtocols(uint32_t mask) {
|
|
char accum[64];
|
|
|
|
accum[0] = '\0';
|
|
|
|
if (mask & SecurityProtocolMask::WPA)
|
|
strcpy(accum, "WPA ");
|
|
|
|
if (mask & SecurityProtocolMask::RSN)
|
|
strcat(accum, "RSN");
|
|
|
|
if (mSuppl->setNetworkVar(mNetid, "proto", accum))
|
|
return -1;
|
|
mProtocols = mask;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setAuthAlgorithms(uint32_t mask) {
|
|
char accum[64];
|
|
|
|
accum[0] = '\0';
|
|
|
|
if (mask == 0)
|
|
strcpy(accum, "");
|
|
|
|
if (mask & AuthenticationAlgorithmMask::OPEN)
|
|
strcpy(accum, "OPEN ");
|
|
|
|
if (mask & AuthenticationAlgorithmMask::SHARED)
|
|
strcat(accum, "SHARED ");
|
|
|
|
if (mask & AuthenticationAlgorithmMask::LEAP)
|
|
strcat(accum, "LEAP ");
|
|
|
|
if (mSuppl->setNetworkVar(mNetid, "auth_alg", accum))
|
|
return -1;
|
|
|
|
mAuthAlgorithms = mask;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setPairwiseCiphers(uint32_t mask) {
|
|
char accum[64];
|
|
|
|
accum[0] = '\0';
|
|
|
|
if (mask == PairwiseCiphersMask::NONE)
|
|
strcpy(accum, "NONE");
|
|
else {
|
|
if (mask & PairwiseCiphersMask::TKIP)
|
|
strcat(accum, "TKIP ");
|
|
if (mask & PairwiseCiphersMask::CCMP)
|
|
strcat(accum, "CCMP ");
|
|
}
|
|
|
|
if (mSuppl->setNetworkVar(mNetid, "pairwise", accum))
|
|
return -1;
|
|
|
|
mPairwiseCiphers = mask;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setGroupCiphers(uint32_t mask) {
|
|
char accum[64];
|
|
|
|
accum[0] = '\0';
|
|
|
|
if (mask & GroupCiphersMask::WEP40)
|
|
strcat(accum, "WEP40 ");
|
|
if (mask & GroupCiphersMask::WEP104)
|
|
strcat(accum, "WEP104 ");
|
|
if (mask & GroupCiphersMask::TKIP)
|
|
strcat(accum, "TKIP ");
|
|
if (mask & GroupCiphersMask::CCMP)
|
|
strcat(accum, "CCMP ");
|
|
|
|
if (mSuppl->setNetworkVar(mNetid, "group", accum))
|
|
return -1;
|
|
mGroupCiphers = mask;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::setEnabled(bool enabled) {
|
|
|
|
if (enabled) {
|
|
if (getPriority() == -1) {
|
|
LOGE("Cannot enable network when priority is not set");
|
|
errno = EAGAIN;
|
|
return -1;
|
|
}
|
|
if (getKeyManagement() == KeyManagementMask::UNKNOWN) {
|
|
LOGE("Cannot enable network when KeyManagement is not set");
|
|
errno = EAGAIN;
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (mSuppl->enableNetwork(mNetid, enabled))
|
|
return -1;
|
|
|
|
mEnabled = enabled;
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::attachProperties(PropertyManager *pm, const char *nsName) {
|
|
pm->attachProperty(nsName, mStaticProperties.propSsid);
|
|
pm->attachProperty(nsName, mStaticProperties.propBssid);
|
|
pm->attachProperty(nsName, mStaticProperties.propPsk);
|
|
pm->attachProperty(nsName, mStaticProperties.propWepKey);
|
|
pm->attachProperty(nsName, mStaticProperties.propDefKeyIdx);
|
|
pm->attachProperty(nsName, mStaticProperties.propPriority);
|
|
pm->attachProperty(nsName, mStaticProperties.propKeyManagement);
|
|
pm->attachProperty(nsName, mStaticProperties.propProtocols);
|
|
pm->attachProperty(nsName, mStaticProperties.propAuthAlgorithms);
|
|
pm->attachProperty(nsName, mStaticProperties.propPairwiseCiphers);
|
|
pm->attachProperty(nsName, mStaticProperties.propGroupCiphers);
|
|
pm->attachProperty(nsName, mStaticProperties.propHiddenSsid);
|
|
pm->attachProperty(nsName, mStaticProperties.propEnabled);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::detachProperties(PropertyManager *pm, const char *nsName) {
|
|
pm->detachProperty(nsName, mStaticProperties.propEnabled);
|
|
pm->detachProperty(nsName, mStaticProperties.propSsid);
|
|
pm->detachProperty(nsName, mStaticProperties.propBssid);
|
|
pm->detachProperty(nsName, mStaticProperties.propPsk);
|
|
pm->detachProperty(nsName, mStaticProperties.propWepKey);
|
|
pm->detachProperty(nsName, mStaticProperties.propDefKeyIdx);
|
|
pm->detachProperty(nsName, mStaticProperties.propPriority);
|
|
pm->detachProperty(nsName, mStaticProperties.propKeyManagement);
|
|
pm->detachProperty(nsName, mStaticProperties.propProtocols);
|
|
pm->detachProperty(nsName, mStaticProperties.propAuthAlgorithms);
|
|
pm->detachProperty(nsName, mStaticProperties.propPairwiseCiphers);
|
|
pm->detachProperty(nsName, mStaticProperties.propGroupCiphers);
|
|
pm->detachProperty(nsName, mStaticProperties.propHiddenSsid);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::parseKeyManagementMask(const char *buffer, uint32_t *mask) {
|
|
bool none = false;
|
|
char *v_tmp = strdup(buffer);
|
|
char *v_next = v_tmp;
|
|
char *v_token;
|
|
|
|
// LOGD("parseKeyManagementMask(%s)", buffer);
|
|
*mask = 0;
|
|
|
|
while((v_token = strsep(&v_next, " "))) {
|
|
if (!strcasecmp(v_token, "NONE")) {
|
|
*mask = KeyManagementMask::NONE;
|
|
none = true;
|
|
} else if (!none) {
|
|
if (!strcasecmp(v_token, "WPA-PSK"))
|
|
*mask |= KeyManagementMask::WPA_PSK;
|
|
else if (!strcasecmp(v_token, "WPA-EAP"))
|
|
*mask |= KeyManagementMask::WPA_EAP;
|
|
else if (!strcasecmp(v_token, "IEEE8021X"))
|
|
*mask |= KeyManagementMask::IEEE8021X;
|
|
else {
|
|
LOGW("Invalid KeyManagementMask value '%s'", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
} else {
|
|
LOGW("KeyManagementMask value '%s' when NONE", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
}
|
|
free(v_tmp);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::parseProtocolsMask(const char *buffer, uint32_t *mask) {
|
|
bool none = false;
|
|
char *v_tmp = strdup(buffer);
|
|
char *v_next = v_tmp;
|
|
char *v_token;
|
|
|
|
// LOGD("parseProtocolsMask(%s)", buffer);
|
|
*mask = 0;
|
|
while((v_token = strsep(&v_next, " "))) {
|
|
if (!strcasecmp(v_token, "WPA"))
|
|
*mask |= SecurityProtocolMask::WPA;
|
|
else if (!strcasecmp(v_token, "RSN"))
|
|
*mask |= SecurityProtocolMask::RSN;
|
|
else {
|
|
LOGW("Invalid ProtocolsMask value '%s'", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
free(v_tmp);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::parseAuthAlgorithmsMask(const char *buffer, uint32_t *mask) {
|
|
bool none = false;
|
|
char *v_tmp = strdup(buffer);
|
|
char *v_next = v_tmp;
|
|
char *v_token;
|
|
|
|
// LOGD("parseAuthAlgorithmsMask(%s)", buffer);
|
|
|
|
*mask = 0;
|
|
if (buffer[0] == '\0')
|
|
return 0;
|
|
|
|
while((v_token = strsep(&v_next, " "))) {
|
|
if (!strcasecmp(v_token, "OPEN"))
|
|
*mask |= AuthenticationAlgorithmMask::OPEN;
|
|
else if (!strcasecmp(v_token, "SHARED"))
|
|
*mask |= AuthenticationAlgorithmMask::SHARED;
|
|
else if (!strcasecmp(v_token, "LEAP"))
|
|
*mask |= AuthenticationAlgorithmMask::LEAP;
|
|
else {
|
|
LOGW("Invalid AuthAlgorithmsMask value '%s'", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
}
|
|
free(v_tmp);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::parsePairwiseCiphersMask(const char *buffer, uint32_t *mask) {
|
|
bool none = false;
|
|
char *v_tmp = strdup(buffer);
|
|
char *v_next = v_tmp;
|
|
char *v_token;
|
|
|
|
// LOGD("parsePairwiseCiphersMask(%s)", buffer);
|
|
|
|
*mask = 0;
|
|
while((v_token = strsep(&v_next, " "))) {
|
|
if (!strcasecmp(v_token, "NONE")) {
|
|
*mask = PairwiseCiphersMask::NONE;
|
|
none = true;
|
|
} else if (!none) {
|
|
if (!strcasecmp(v_token, "TKIP"))
|
|
*mask |= PairwiseCiphersMask::TKIP;
|
|
else if (!strcasecmp(v_token, "CCMP"))
|
|
*mask |= PairwiseCiphersMask::CCMP;
|
|
else {
|
|
LOGW("PairwiseCiphersMask value '%s' when NONE", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
} else {
|
|
LOGW("Invalid PairwiseCiphersMask value '%s'", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
}
|
|
free(v_tmp);
|
|
return 0;
|
|
}
|
|
|
|
int WifiNetwork::parseGroupCiphersMask(const char *buffer, uint32_t *mask) {
|
|
bool none = false;
|
|
char *v_tmp = strdup(buffer);
|
|
char *v_next = v_tmp;
|
|
char *v_token;
|
|
|
|
// LOGD("parseGroupCiphersMask(%s)", buffer);
|
|
|
|
*mask = 0;
|
|
while((v_token = strsep(&v_next, " "))) {
|
|
if (!strcasecmp(v_token, "WEP40"))
|
|
*mask |= GroupCiphersMask::WEP40;
|
|
else if (!strcasecmp(v_token, "WEP104"))
|
|
*mask |= GroupCiphersMask::WEP104;
|
|
else if (!strcasecmp(v_token, "TKIP"))
|
|
*mask |= GroupCiphersMask::TKIP;
|
|
else if (!strcasecmp(v_token, "CCMP"))
|
|
*mask |= GroupCiphersMask::CCMP;
|
|
else {
|
|
LOGW("Invalid GroupCiphersMask value '%s'", v_token);
|
|
errno = EINVAL;
|
|
free(v_tmp);
|
|
return -1;
|
|
}
|
|
}
|
|
free(v_tmp);
|
|
return 0;
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkIntegerProperty::WifiNetworkIntegerProperty(WifiNetwork *wn,
|
|
const char *name,
|
|
bool ro,
|
|
int elements) :
|
|
IntegerProperty(name, ro, elements) {
|
|
mWn = wn;
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkStringProperty::WifiNetworkStringProperty(WifiNetwork *wn,
|
|
const char *name,
|
|
bool ro, int elements) :
|
|
StringProperty(name, ro, elements) {
|
|
mWn = wn;
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkEnabledProperty::WifiNetworkEnabledProperty(WifiNetwork *wn) :
|
|
WifiNetworkIntegerProperty(wn, "Enabled", false, 1) {
|
|
}
|
|
|
|
int WifiNetwork::WifiNetworkEnabledProperty::get(int idx, int *buffer) {
|
|
*buffer = mWn->mEnabled;
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkEnabledProperty::set(int idx, int value) {
|
|
return mWn->setEnabled(value == 1);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkSsidProperty::WifiNetworkSsidProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "Ssid", false, 1) {
|
|
}
|
|
|
|
int WifiNetwork::WifiNetworkSsidProperty::get(int idx, char *buffer, size_t max) {
|
|
strncpy(buffer,
|
|
mWn->getSsid() ? mWn->getSsid() : "none",
|
|
max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkSsidProperty::set(int idx, const char *value) {
|
|
return mWn->setSsid(value);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkBssidProperty::WifiNetworkBssidProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "Bssid", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkBssidProperty::get(int idx, char *buffer, size_t max) {
|
|
strncpy(buffer,
|
|
mWn->getBssid() ? mWn->getBssid() : "none",
|
|
max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkBssidProperty::set(int idx, const char *value) {
|
|
return mWn->setBssid(value);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkPskProperty::WifiNetworkPskProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "Psk", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkPskProperty::get(int idx, char *buffer, size_t max) {
|
|
strncpy(buffer,
|
|
mWn->getPsk() ? mWn->getPsk() : "none",
|
|
max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkPskProperty::set(int idx, const char *value) {
|
|
return mWn->setPsk(value);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkWepKeyProperty::WifiNetworkWepKeyProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "WepKey", false, 4) {
|
|
}
|
|
|
|
int WifiNetwork::WifiNetworkWepKeyProperty::get(int idx, char *buffer, size_t max) {
|
|
const char *key = mWn->getWepKey(idx);
|
|
|
|
strncpy(buffer, (key ? key : "none"), max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkWepKeyProperty::set(int idx, const char *value) {
|
|
return mWn->setWepKey(idx, value);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkDefaultKeyIndexProperty::WifiNetworkDefaultKeyIndexProperty(WifiNetwork *wn) :
|
|
WifiNetworkIntegerProperty(wn, "DefaultKeyIndex", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkDefaultKeyIndexProperty::get(int idx, int *buffer) {
|
|
*buffer = mWn->getDefaultKeyIndex();
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkDefaultKeyIndexProperty::set(int idx, int value) {
|
|
return mWn->setDefaultKeyIndex(value);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkPriorityProperty::WifiNetworkPriorityProperty(WifiNetwork *wn) :
|
|
WifiNetworkIntegerProperty(wn, "Priority", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkPriorityProperty::get(int idx, int *buffer) {
|
|
*buffer = mWn->getPriority();
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkPriorityProperty::set(int idx, int value) {
|
|
return mWn->setPriority(value);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkKeyManagementProperty::WifiNetworkKeyManagementProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "KeyManagement", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkKeyManagementProperty::get(int idx, char *buffer, size_t max) {
|
|
|
|
if (mWn->getKeyManagement() == KeyManagementMask::NONE)
|
|
strncpy(buffer, "NONE", max);
|
|
else {
|
|
char tmp[80] = { '\0' };
|
|
|
|
if (mWn->getKeyManagement() & KeyManagementMask::WPA_PSK)
|
|
strcat(tmp, "WPA-PSK");
|
|
if (mWn->getKeyManagement() & KeyManagementMask::WPA_EAP) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "WPA-EAP");
|
|
}
|
|
if (mWn->getKeyManagement() & KeyManagementMask::IEEE8021X) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "IEEE8021X");
|
|
}
|
|
if (tmp[0] == '\0') {
|
|
strncpy(buffer, "(internal error)", max);
|
|
errno = ENOENT;
|
|
return -1;
|
|
}
|
|
if (tmp[strlen(tmp)] == ' ')
|
|
tmp[strlen(tmp)] = '\0';
|
|
|
|
strncpy(buffer, tmp, max);
|
|
}
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkKeyManagementProperty::set(int idx, const char *value) {
|
|
uint32_t mask;
|
|
if (mWn->parseKeyManagementMask(value, &mask))
|
|
return -1;
|
|
return mWn->setKeyManagement(mask);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkProtocolsProperty::WifiNetworkProtocolsProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "Protocols", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkProtocolsProperty::get(int idx, char *buffer, size_t max) {
|
|
char tmp[80] = { '\0' };
|
|
|
|
if (mWn->getProtocols() & SecurityProtocolMask::WPA)
|
|
strcat(tmp, "WPA");
|
|
if (mWn->getProtocols() & SecurityProtocolMask::RSN) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "RSN");
|
|
}
|
|
|
|
if (tmp[0] == '\0') {
|
|
strncpy(buffer, "(internal error)", max);
|
|
errno = ENOENT;
|
|
return NULL;
|
|
}
|
|
if (tmp[strlen(tmp)] == ' ')
|
|
tmp[strlen(tmp)] = '\0';
|
|
|
|
strncpy(buffer, tmp, max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkProtocolsProperty::set(int idx, const char *value) {
|
|
uint32_t mask;
|
|
if (mWn->parseProtocolsMask(value, &mask))
|
|
return -1;
|
|
return mWn->setProtocols(mask);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkAuthAlgorithmsProperty::WifiNetworkAuthAlgorithmsProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "AuthAlgorithms", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkAuthAlgorithmsProperty::get(int idx, char *buffer, size_t max) {
|
|
char tmp[80] = { '\0' };
|
|
|
|
if (mWn->getAuthAlgorithms() == 0) {
|
|
strncpy(buffer, "NONE", max);
|
|
return 0;
|
|
}
|
|
|
|
if (mWn->getAuthAlgorithms() & AuthenticationAlgorithmMask::OPEN)
|
|
strcat(tmp, "OPEN");
|
|
if (mWn->getAuthAlgorithms() & AuthenticationAlgorithmMask::SHARED) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "SHARED");
|
|
}
|
|
if (mWn->getAuthAlgorithms() & AuthenticationAlgorithmMask::LEAP) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "LEAP");
|
|
}
|
|
|
|
if (tmp[0] == '\0') {
|
|
strncpy(buffer, "(internal error)", max);
|
|
errno = ENOENT;
|
|
return NULL;
|
|
}
|
|
if (tmp[strlen(tmp)] == ' ')
|
|
tmp[strlen(tmp)] = '\0';
|
|
|
|
strncpy(buffer, tmp, max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkAuthAlgorithmsProperty::set(int idx, const char *value) {
|
|
uint32_t mask;
|
|
if (mWn->parseAuthAlgorithmsMask(value, &mask))
|
|
return -1;
|
|
return mWn->setAuthAlgorithms(mask);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkPairwiseCiphersProperty::WifiNetworkPairwiseCiphersProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "PairwiseCiphers", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkPairwiseCiphersProperty::get(int idx, char *buffer, size_t max) {
|
|
if (mWn->getPairwiseCiphers() == PairwiseCiphersMask::NONE)
|
|
strncpy(buffer, "NONE", max);
|
|
else {
|
|
char tmp[80] = { '\0' };
|
|
|
|
if (mWn->getPairwiseCiphers() & PairwiseCiphersMask::TKIP)
|
|
strcat(tmp, "TKIP");
|
|
if (mWn->getPairwiseCiphers() & PairwiseCiphersMask::CCMP) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "CCMP");
|
|
}
|
|
if (tmp[0] == '\0') {
|
|
strncpy(buffer, "(internal error)", max);
|
|
errno = ENOENT;
|
|
return NULL;
|
|
}
|
|
if (tmp[strlen(tmp)] == ' ')
|
|
tmp[strlen(tmp)] = '\0';
|
|
|
|
strncpy(buffer, tmp, max);
|
|
}
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkPairwiseCiphersProperty::set(int idx, const char *value) {
|
|
uint32_t mask;
|
|
if (mWn->parsePairwiseCiphersMask(value, &mask))
|
|
return -1;
|
|
return mWn->setPairwiseCiphers(mask);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkGroupCiphersProperty::WifiNetworkGroupCiphersProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "GroupCiphers", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkGroupCiphersProperty::get(int idx, char *buffer, size_t max) {
|
|
char tmp[80] = { '\0' };
|
|
|
|
if (mWn->getGroupCiphers() & GroupCiphersMask::WEP40)
|
|
strcat(tmp, "WEP40");
|
|
if (mWn->getGroupCiphers() & GroupCiphersMask::WEP104) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "WEP104");
|
|
}
|
|
if (mWn->getGroupCiphers() & GroupCiphersMask::TKIP) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "TKIP");
|
|
}
|
|
if (mWn->getGroupCiphers() & GroupCiphersMask::CCMP) {
|
|
if (tmp[0] != '\0')
|
|
strcat(tmp, " ");
|
|
strcat(tmp, "CCMP");
|
|
}
|
|
|
|
if (tmp[0] == '\0') {
|
|
strncpy(buffer, "(internal error)", max);
|
|
errno = ENOENT;
|
|
return -1;
|
|
}
|
|
if (tmp[strlen(tmp)] == ' ')
|
|
tmp[strlen(tmp)] = '\0';
|
|
|
|
strncpy(buffer, tmp, max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkGroupCiphersProperty::set(int idx, const char *value) {
|
|
uint32_t mask;
|
|
if (mWn->parseGroupCiphersMask(value, &mask))
|
|
return -1;
|
|
return mWn->setGroupCiphers(mask);
|
|
}
|
|
|
|
WifiNetwork::WifiNetworkHiddenSsidProperty::WifiNetworkHiddenSsidProperty(WifiNetwork *wn) :
|
|
WifiNetworkStringProperty(wn, "HiddenSsid", false, 1) {
|
|
}
|
|
int WifiNetwork::WifiNetworkHiddenSsidProperty::get(int idx, char *buffer, size_t max) {
|
|
const char *scan_ssid = mWn->getHiddenSsid();
|
|
|
|
strncpy(buffer, (scan_ssid ? scan_ssid : "none"), max);
|
|
return 0;
|
|
}
|
|
int WifiNetwork::WifiNetworkHiddenSsidProperty::set(int idx, const char *value) {
|
|
return mWn->setHiddenSsid(value);
|
|
}
|