/*
* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* WLAN Qt Utilities WLAN IAP settings handling.
*/
// System includes
#include <QScopedPointer>
#include <QSharedPointer>
#include <QVariant>
#include <cmmanager_shim.h>
#include <cmdestination_shim.h>
#include <cmconnectionmethod_shim.h>
// User includes
#include "wlanqtutils.h"
#include "wlanqtutilsap.h"
#include "wlanqtutilsiap.h"
#include "wlanqtutilsiapsettings.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "wlanqtutilsiapsettingsTraces.h"
#endif
/*!
\class WlanQtUtilsIapSettings
\brief WLAN IAP related settings handler.
Provides functionality to manipulate WLAN IAPs via the CM Manager Shim
interface.
NOTE: Shim functions may throw exceptions that need to be catched in
this class.
*/
// External function prototypes
// Local constants
// WEP key lengths used to determine key format
static const int WepHex64BitMaxLength = 10;
static const int WepHex128BitMaxLength = 26;
static const int WepAscii64BitMaxLength = 5;
static const int WepAscii128BitMaxLength = 13;
// ======== LOCAL FUNCTIONS ========
// ======== MEMBER FUNCTIONS ========
/*!
Constructor.
@param [in] parent Parent object.
*/
WlanQtUtilsIapSettings::WlanQtUtilsIapSettings(QObject *parent) :
QObject(parent),
mCmManager(new CmManagerShim())
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_WLANQTUTILSIAPSETTINGS_ENTRY);
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_WLANQTUTILSIAPSETTINGS_EXIT);
}
/*!
Destructor.
*/
WlanQtUtilsIapSettings::~WlanQtUtilsIapSettings()
{
OstTraceFunctionEntry0(DUP1_WLANQTUTILSIAPSETTINGS_WLANQTUTILSIAPSETTINGS_ENTRY);
delete mCmManager;
OstTraceFunctionExit0(DUP1_WLANQTUTILSIAPSETTINGS_WLANQTUTILSIAPSETTINGS_EXIT);
}
/*!
Fetch all WLAN IAPs.
@param [out] iapList List of WLAN IAPs.
*/
void WlanQtUtilsIapSettings::fetchIaps(
QList< QSharedPointer<WlanQtUtilsIap> > &iapList) const
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_FETCHIAPS_ENTRY);
// Clear the list content first for safety
iapList.clear();
QList<uint> iapIds;
try {
mCmManager->connectionMethod(iapIds, false);
} catch (const std::exception &ex) {
int error = qt_symbian_exception2Error(ex);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_FETCHIAPS_EXCEPTION,
"WlanQtUtilsIapSettings::fetchIaps exception;error=%d",
error);
}
foreach (int iapId, iapIds) {
QSharedPointer<WlanQtUtilsIap> wlanIap = fetchIap(iapId);
if (wlanIap) {
iapList.append(wlanIap);
}
}
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_FETCHIAPS_EXIT);
}
/*!
Fetch WLAN IAP with the given ID
@param [in] iapId ID of IAP to fetch.
@return Found IAP, NULL if not found.
*/
QSharedPointer<WlanQtUtilsIap> WlanQtUtilsIapSettings::fetchIap(int iapId) const
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_FETCHIAP_ENTRY);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_FETCHIAP,
"WlanQtUtilsIapSettings::fetchIap;iapId=%d",
iapId);
QSharedPointer<WlanQtUtilsIap> wlanIap;
try {
QScopedPointer<CmConnectionMethodShim> iap(
mCmManager->connectionMethod(iapId));
if (iap && iap->getIntAttribute(CMManagerShim::CmBearerType) ==
KUidWlanBearerType) {
// Get WLAN IAP parameters
int netId = iap->getIntAttribute(CMManagerShim::CmNetworkId);
QString name = iap->getStringAttribute(CMManagerShim::CmName);
QString ssid = iap->getStringAttribute(CMManagerShim::WlanSSID);
int secMode = iap->getIntAttribute(
CMManagerShim::WlanSecurityMode);
bool wpaPskUse = iap->getBoolAttribute(
CMManagerShim::WlanEnableWpaPsk);
// Create a WLAN Qt Utils IAP
wlanIap = QSharedPointer<WlanQtUtilsIap>(new WlanQtUtilsIap());
wlanIap->setValue(WlanQtUtilsIap::ConfIdIapId, iapId);
wlanIap->setValue(WlanQtUtilsIap::ConfIdNetworkId, netId);
wlanIap->setValue(WlanQtUtilsIap::ConfIdName, name);
wlanIap->setValue(WlanQtUtilsAp::ConfIdSsid, ssid);
wlanIap->setValue(WlanQtUtilsAp::ConfIdSecurityMode, secMode);
wlanIap->setValue(WlanQtUtilsAp::ConfIdWpaPskUse, wpaPskUse);
}
} catch (const std::exception &ex) {
int error = qt_symbian_exception2Error(ex);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_FETCHIAP_EXCEPTION,
"WlanQtUtilsIapSettings::fetchIap exception;error=%d",
error);
}
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_FETCHIAP_EXIT);
return wlanIap;
}
/*!
Create a new WLAN IAP as an uncategorized IAP.
@param [in] wlanAp Information about the WLAN AP.
@return ID of the created IAP, IapIdNone in error cases.
*/
int WlanQtUtilsIapSettings::createIap(const WlanQtUtilsAp *wlanAp)
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_CREATEIAP_ENTRY);
int iapId = WlanQtUtils::IapIdNone;
try {
// Create the new IAP
QScopedPointer<CmConnectionMethodShim> iap(
mCmManager->createConnectionMethod(KUidWlanBearerType));
storeSettings(wlanAp, iap.data());
iapId = iap->getIntAttribute(CMManagerShim::CmIapId);
} catch (const std::exception &ex) {
// Trace error cause and return failure (default value) to caller.
int error = qt_symbian_exception2Error(ex);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_CREATEIAP_EXCEPTION,
"WlanQtUtilsIapSettings::createIap exception;error=%d",
error);
}
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_CREATEIAP_EXIT);
return iapId;
}
/*!
Update the WLAN IAP given as parameter. All settings are stored to
database (again) without checking whether they have actually changed
or not.
@param [in] iapId ID of IAP to update.
@param [in] wlanAp Information about the WLAN AP.
@return Was update succesful or not?
*/
bool WlanQtUtilsIapSettings::updateIap(
int iapId,
const WlanQtUtilsAp *wlanAp)
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_UPDATEIAP_ENTRY);
bool success = false;
try {
QScopedPointer<CmConnectionMethodShim> iap(
mCmManager->connectionMethod(iapId));
storeSettings(wlanAp, iap.data());
success = true;
} catch (const std::exception &ex) {
// Trace error cause and return failure (default value) to caller.
int error = qt_symbian_exception2Error(ex);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_UPDATEIAP_EXCEPTION,
"WlanQtUtilsIapSettings::updateIap exception;error=%d",
error);
}
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_UPDATEIAP_EXIT);
return success;
}
/*!
Delete the WLAN IAP given as parameter.
@param [in] iapId ID of IAP to delete.
*/
void WlanQtUtilsIapSettings::deleteIap(int iapId)
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_DELETEIAP_ENTRY);
try {
QScopedPointer<CmConnectionMethodShim> iap(
mCmManager->connectionMethod(iapId));
iap->deleteConnectionMethod();
} catch (const std::exception &ex) {
// Just trace error cause. It is not fatal, if we are not able to
// delete the IAP. No need to retry, since errors should be very
// rare and user can delete the IAP later from Control Panel, if
// needed.
int error = qt_symbian_exception2Error(ex);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_DELETEIAP_EXCEPTION,
"WlanQtUtilsIapSettings::deleteIap exception;error=%d",
error);
}
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_DELETEIAP_EXIT);
}
/*!
Move IAP to the Internet SNAP.
@param [in] iapId ID of the IAP to move.
*/
void WlanQtUtilsIapSettings::moveIapToInternetSnap(int iapId)
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_MOVEIAPTOINTERNETSNAP_ENTRY);
// Read all destination (SNAP) IDs
QList<uint> destinations;
try {
mCmManager->allDestinations(destinations);
foreach (int destId, destinations) {
QScopedPointer<CmDestinationShim> destination(
mCmManager->destination(destId));
// Internet destination will always exist in the system. It has
// SnapPurposeInternet set in its metadata.
if (destination->metadata(CMManagerShim::SnapMetadataPurpose)
== CMManagerShim::SnapPurposeInternet) {
QScopedPointer<CmConnectionMethodShim> iap(
mCmManager->connectionMethod(iapId));
destination->addConnectionMethod(iap.data());
destination->update();
break;
}
}
} catch (const std::exception &ex) {
int error = qt_symbian_exception2Error(ex);
OstTrace1(
TRACE_NORMAL,
WLANQTUTILSIAPSETTINGS_MOVEIAPTOINTERNETSNAP_EXCEPTION,
"WlanQtUtilsIapSettings::moveIapToInternetSnap exception;error=%d",
error);
}
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_MOVEIAPTOINTERNETSNAP_EXIT);
}
/*!
Stores the given Wlan AP settings to database using CM Manager Shim.
@param [in] wlanAp WLAN AP settings to store.
@param [in] iap WLAN IAP to store to.
*/
void WlanQtUtilsIapSettings::storeSettings(
const WlanQtUtilsAp *wlanAp,
CmConnectionMethodShim *iap)
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_STORESETTINGS_ENTRY);
int secMode = wlanAp->value(WlanQtUtilsAp::ConfIdSecurityMode).toInt();
QString ssid = wlanAp->value(WlanQtUtilsAp::ConfIdSsid).toString();
// Store general values
iap->setStringAttribute(CMManagerShim::CmName, ssid);
iap->setStringAttribute(CMManagerShim::WlanSSID, ssid);
iap->setIntAttribute(CMManagerShim::WlanSecurityMode, secMode);
iap->setIntAttribute(
CMManagerShim::WlanConnectionMode,
wlanAp->value(WlanQtUtilsAp::ConfIdConnectionMode).toInt());
switch (secMode) {
case CMManagerShim::WlanSecModeWep:
// Store the 4 WEP keys (function does nothing, if a key is not set)
storeWepKey(
wlanAp->value(WlanQtUtilsAp::ConfIdWepKey1).toString(),
1,
iap);
storeWepKey(
wlanAp->value(WlanQtUtilsAp::ConfIdWepKey2).toString(),
2,
iap);
storeWepKey(
wlanAp->value(WlanQtUtilsAp::ConfIdWepKey3).toString(),
3,
iap);
storeWepKey(
wlanAp->value(WlanQtUtilsAp::ConfIdWepKey4).toString(),
4,
iap);
iap->setIntAttribute(
CMManagerShim::WlanWepKeyIndex,
wlanAp->value(WlanQtUtilsAp::ConfIdWepDefaultIndex).toInt());
break;
case CMManagerShim::WlanSecModeWpa:
case CMManagerShim::WlanSecModeWpa2:
// Store WPA PSK values
bool usePsk = wlanAp->value(WlanQtUtilsAp::ConfIdWpaPskUse).toBool();
iap->setBoolAttribute(CMManagerShim::WlanEnableWpaPsk, usePsk);
if (usePsk) {
QString wpaKey(wlanAp->value(WlanQtUtilsAp::ConfIdWpaPsk ).toString());
iap->setString8Attribute(CMManagerShim::WlanWpaPreSharedKey, wpaKey);
}
break;
}
iap->update();
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_STORESETTINGS_EXIT);
}
/*!
Stores the given valid WEP key to database using CM Manager Shim. Ignores
keys with zero length.
@note This method MUST not be called for invalid WEP Keys. Wlanwizard
validates keys, before accepting user input.
@param [in] key Key to write.
@param [in] index Key index. Valid range is [0,4].
@param [in] iap WLAN IAP to store the key into.
*/
void WlanQtUtilsIapSettings::storeWepKey(
const QString &key,
int index,
CmConnectionMethodShim *iap)
{
OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_STOREWEPKEY_ENTRY);
// Default value is set just to silence compiler, Q_ASSERTs take care
// that valid attribute is set below
CMManagerShim::ConnectionMethodAttribute attribute =
CMManagerShim::WlanWepKey1InHex;
int length = key.length();
if (length == WepHex64BitMaxLength || length == WepHex128BitMaxLength) {
// HEX
switch (index) {
case 1:
attribute = CMManagerShim::WlanWepKey1InHex;
break;
case 2:
attribute = CMManagerShim::WlanWepKey2InHex;
break;
case 3:
attribute = CMManagerShim::WlanWepKey3InHex;
break;
case 4:
attribute = CMManagerShim::WlanWepKey4InHex;
break;
#ifndef QT_NO_DEBUG
default:
// Invalid key index detected
Q_ASSERT(0);
break;
#endif
}
} else if (length == WepAscii64BitMaxLength || length == WepAscii128BitMaxLength) {
// ASCII
switch (index) {
case 1:
attribute = CMManagerShim::WlanWepKey1InAscii;
break;
case 2:
attribute = CMManagerShim::WlanWepKey2InAscii;
break;
case 3:
attribute = CMManagerShim::WlanWepKey3InAscii;
break;
case 4:
attribute = CMManagerShim::WlanWepKey4InAscii;
break;
#ifndef QT_NO_DEBUG
default:
// Invalid key index detected
Q_ASSERT(0);
break;
#endif
}
}
if (length > 0) {
iap->setString8Attribute(attribute, key);
} // else: key is not set, ignore
OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_STOREWEPKEY_EXIT);
}