/*

* 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);

    }

        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.

*/

{

    OstTraceFunctionEntry0(WLANQTUTILSIAPSETTINGS_FETCHIAP_ENTRY);

    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();

    iap->setStringAttribute(CMManagerShim::CmName, ssid);

    iap->setStringAttribute(CMManagerShim::WlanSSID, ssid);

    iap->setIntAttribute(CMManagerShim::WlanSecurityMode, secMode);

    iap->setIntAttribute(

        CMManagerShim::WlanConnectionMode, 

        wlanAp->value(WlanQtUtilsAp::ConfIdConnectionMode).toInt());

    iap->update();

    OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_STORESETTINGS_EXIT);

}

/*!

    @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);

    int length = key.length();

    if (length == WepHex64BitMaxLength || length == WepHex128BitMaxLength) {

        // HEX

    } else if (length == WepAscii64BitMaxLength || length == WepAscii128BitMaxLength) {

        // ASCII

    }

    OstTraceFunctionExit0(WLANQTUTILSIAPSETTINGS_STOREWEPKEY_EXIT);

}