/*

 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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: 

 *   EAP method configuration QT interface

 *

 */

/*

 * %version: 41 %

 */

#include <QDir>

#include <QList>

#include <QVariant>

#include <QPluginLoader>

#include <HbTranslator>

#include <QLocale>

#include <QCoreApplication>

#include <QDebug>

#include <cmmanager.h>

#include <cmpluginwlandef.h>

#include <EapGeneralSettings.h>

#include <eapqtplugininfo.h>

#include <eapqtcertificateinfo.h>

#include "cpeapplugininterface.h"

#include "eapqtconfiginterface_p.h"

// validators

#include "eapqtvalidatorpassword.h"

#include "eapqtvalidatorusername.h"

#include "eapqtvalidatorrealm.h"

static const QString eapPluginDir("\\resource\\qt\\plugins\\controlpanel\\eapsecurity");

static const QString eapTranslationFile("cpeapuiplugins");

EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate() :

  mValidatorInstance(true),

  mLastOuterHandle(EapQtPluginHandle::PluginUndefined),

  mTranslator(NULL),

  mEapGsIf(NULL), 

  mEapTypeIf(NULL),

  mIapId(0),

  mEapBearer(ELan),

  mEapDbIndex(EapQtConfigInterface::IapIdUndefined),

  mEapDbIndexValid(false)

{

    qDebug("EapQtConfigInterfacePrivate() - created validator instance, this = 0x%08x", this);

}

EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate(/* EapQtConfigInterface *configIf, */

    const EapQtConfigInterface::EapBearerType bearerType, const int iapId) :  

  mValidatorInstance(false),

  mLastOuterHandle(EapQtPluginHandle::PluginUndefined),

  mTranslator(NULL), 

  mEapGsIf(NULL), 

  mEapTypeIf(NULL),

  mIapId(iapId),

  mEapBearer(ELan),

  mEapDbIndex(EapQtConfigInterface::IapIdUndefined),

  mEapDbIndexValid(false)

{

    qDebug("EapQtConfigInterfacePrivate() - creating non-validator instance, this = 0x%08x", this);

    switch (bearerType) {

    case EapQtConfigInterface::EapBearerTypeVpn:

        mEapBearer = EVpn;

        break;

    default:

        // All others default to EapQtConfigInterface::EapBearerTypeWlan i.e. ELan

        mEapBearer = ELan;

    }

    if (!setEapDbIndex(iapId)) {

        qDebug("ERROR: EapQtConfigInterfacePrivate() - setIapId failed, bearer = %d, index = %d",

            mEapBearer, iapId);

        shutdown();

        // throw an exception

        qt_symbian_throwIfError(KErrNotFound);

    }

    // load plugins after everything else is ok

    qDebug("EapQtConfigInterfacePrivate() - load plugins");

    loadPlugins();

    qDebug("EapQtConfigInterfacePrivate() - ends");

}

EapQtConfigInterfacePrivate::~EapQtConfigInterfacePrivate()

{

    qDebug("EapQtConfigInterfacePrivate::~EapQtConfigInterfacePrivate(), this = 0x%08x", this);

    shutdown();

}

void EapQtConfigInterfacePrivate::shutdown()

{

    qDebug("EapQtConfigInterfacePrivate::shutdown(), this = 0x%08x", this);

    mOuterEapsOn.Close();

    mOuterEapsOff.Close();

    // cleanup Ecom

    REComSession::FinalClose();

    // mTranslator gets deleted automatically (QScopedPointer)

    // mEapTypeIf gets deleted automatically (QScopedPointer)

    // mEapGsIf gets deleted automatically (QScopedPointer)

}

bool EapQtConfigInterfacePrivate::setConfigurationReference(const int iapId)

{

    qDebug("EapQtConfigInterfacePrivate::setConfigurationReference - requested id: %d, this = 0x%08x", iapId, this);

    checkInstanceThrowing();

    return setEapDbIndex(iapId);

}

bool EapQtConfigInterfacePrivate::setEapDbIndex(const int iapId)

{

    qDebug("EapQtConfigInterfacePrivate::setIapId - requested id: %d, this = 0x%08x", iapId, this);

    // optimization: do not re-create the interface if the reference does

    // not change and mEapGsIf exists already

    // WLAN reference is checked after setEapWlanDbIndex below since iapId may be

    // different than WLAN service ID

    // case for EapQtConfigInterface::IapIdUndefined i.e. setIapId was called

    // with a negative id last time and now again

    if (!mEapDbIndexValid && !mEapGsIf.isNull() && iapId < 0) {

        qDebug(

            "EapQtConfigInterfacePrivate::setIapId - interface created for IapIdUndefined already");

        return true;

    }

    // case for VPN (or any other bearer) in which iap id equals EAP db index

    if (mEapBearer != ELan && mEapDbIndexValid && !mEapGsIf.isNull() && iapId == mEapDbIndex) {

        qDebug(

            "EapQtConfigInterfacePrivate::setIapId - interface created for requested IAP ID for VPN already");

        return true;

    }

    // save the current id for checking if WLAN reference changes or not

    TInt previousEapDbIndex = mEapDbIndex;

    bool wlanIndexOk = true;

    // allow accessing certain methods with negative iapId

    if (iapId < 0) {

        // set to zero to be able to create EAP server instances

        mEapDbIndex = 0;

        mEapDbIndexValid = false;

    }

    // for real usage iapId must not be negative

    else {

        // for VPN

        mIapId = iapId;

        mEapDbIndex = iapId;

        mEapDbIndexValid = true;

        // for WLAN

        if (mEapBearer == ELan) {

            // get WLAN service ID as the reference

            mEapDbIndexValid = setEapWlanDbIndex(iapId);

            wlanIndexOk = mEapDbIndexValid;

            // do not re-create if the interface is ok for the new (i.e. same) index already

            if (!mEapGsIf.isNull() && mEapDbIndex == previousEapDbIndex) {

                qDebug() << "EapQtConfigInterfacePrivate::setIapId - interface"

                    << "created for requested IAP ID for WLAN already";

                return true;

            }

        }

    }

    // delete possibly existing instances

    mEapGsIf.reset(NULL);

    mEapTypeIf.reset(NULL);

    mCurrentServerEapType = *EapExpandedTypeNone.GetType();

    mLastOuterHandle = EapQtPluginHandle::PluginUndefined;

    if (!wlanIndexOk && mEapBearer == ELan) {

        // setEapWlanDbIndex was called and failed

        qDebug("ERROR: EapQtConfigInterfacePrivate::setIapId() - setEapWlanDbIndex failed");

        return false;

    }

    qDebug(

        "EapQtConfigInterfacePrivate::setIapId() - calls CEapGeneralSettings::NewL(), bearer = %d, index = %d",

        mEapBearer, mEapDbIndex);

    // load EAP general settings interface

    CEapGeneralSettings* tmp = NULL;

    TRAPD(err, tmp = CEapGeneralSettings::NewL(mEapBearer, mEapDbIndex));

    if (err != KErrNone) {

        qDebug("ERROR: EapQtConfigInterfacePrivate::setIapId - CEapGeneralSettings::NewL() failed");

        mEapDbIndexValid = false;

        return false;

    }

    // set to the created instance

    mEapGsIf.reset(tmp);

    return true;

}

bool EapQtConfigInterfacePrivate::setEapWlanDbIndex(const int iapId)

{

    qDebug("EapQtConfigInterfacePrivate::setEapWlanDbIndex - requested id: %d, this = 0x%08x", iapId, this);

    RCmManager cmm;

    TRAPD(err, cmm.OpenL());

    if (err != KErrNone) {

        qDebug("ERROR: EapQtConfigInterfacePrivate::setEapWlanDbIndex - cmm.OpenL() failed",

            mEapBearer, iapId);

        mEapDbIndex = EapQtConfigInterface::IapIdUndefined;

        mIapId = 0;

        return false;

    }

    TRAP(err, mEapDbIndex = cmm.GetConnectionMethodInfoIntL(iapId, CMManager::EWlanServiceId));

    if (err != KErrNone) {

        qDebug(

            "ERROR: EapQtConfigInterfacePrivate::setEapWlanDbIndex - cmm.GetConnectionMethodInfoIntL() failed",

            mEapBearer, iapId);

        cmm.Close();

        mEapDbIndex = EapQtConfigInterface::IapIdUndefined;

        mIapId = 0;

        return false;

    }

    cmm.Close();

    qDebug("EapQtConfigInterfacePrivate::setEapWlanDbIndex - obtained WLAN service id: %d",

        mEapDbIndex);

    return true;

}

void EapQtConfigInterfacePrivate::checkInstanceThrowing() const

{

    qDebug() << "EapQtConfigInterfacePrivate::checkInstanceThrowing() - mValidatorInstance:"

        << mValidatorInstance;

    if (mValidatorInstance) {

        qDebug(

            "ERROR: EapQtConfigInterfacePrivate::checkInstanceThrowing - method not supported by this instance");

        qt_symbian_throwIfError(KErrNotSupported);

    }

}

void EapQtConfigInterfacePrivate::appendEapTypes(const RArray<TEapExpandedType>* const eapTypes,

    QList<QByteArray>* const eapList)

{

    qDebug("EapQtConfigInterfacePrivate::appendEapTypes(), this = 0x%08x", this);

    Q_ASSERT(eapTypes);

    Q_ASSERT(eapList);

    qDebug("EapQtConfigInterfacePrivate - appendEapTypes, EAP count = %d", eapTypes->Count());

    QByteArray tmpEap;

    for (int ind = 0; ind < eapTypes->Count(); ind++) {

        tmpEap.append(reinterpret_cast<const char*> ((*eapTypes)[ind].GetValue().Ptr()),

            (*eapTypes)[ind].GetValue().Length());

        eapList->append(tmpEap);

        qDebug() << "EapQtConfigInterfacePrivate - appendEapTypes added EAP: " << tmpEap.toHex();

        tmpEap.clear();

    }

}

QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedOuterTypes()

{

    qDebug("EapQtConfigInterfacePrivate::supportedOuterTypes(), this = 0x%08x", this);

    checkInstanceThrowing();

    if (mEapGsIf.isNull()) {

        qDebug("ERROR: EapQtConfigInterfacePrivate::supportedOuterTypes() - mEapGsIf is NULL");

        mOuterEapsOn.Reset();

        mOuterEapsOff.Reset();

        // return empty list

        mSupportedOuterTypes.clear();

        return mSupportedOuterTypes;

    }

    // get outer EAPs from EAP server,

    // returned in two lists: enabled and disabled outer EAPs

    // do this always as the list might have changed and mOuterEapsOn/Off are needed in

    // other methods

    mOuterEapsOn.Reset();

    mOuterEapsOff.Reset();

    qDebug("EapQtConfigInterfacePrivate::supportedOuterTypes() - calls GetEapMethods()");

    TUint err = mEapGsIf->GetEapMethods(mOuterEapsOn, mOuterEapsOff);

    if (err != KErrNone) {

        qDebug("ERROR: EapQtConfigInterfacePrivate::supportedOuterTypes() - GetEapMethods failed");

        mOuterEapsOn.Reset();

        mOuterEapsOff.Reset();

        // return empty list

        mSupportedOuterTypes.clear();

        return mSupportedOuterTypes;

    }

    // optimization: collect the list only once per instance life time

    // since no new EAPs will appear to the combination of mOuterEapsOn and mOuterEapsOff

    if (mSupportedOuterTypes.count() > 0) {

        qDebug(

            "EapQtConfigInterfacePrivate - supportedOuterTypes: supported EAPs already listed, return stored list");

        return mSupportedOuterTypes;

    }

    qDebug("EapQtConfigInterfacePrivate - supportedOuterTypes: copy response to QList");

    // copy response to qlist for easier comparison

    QList<QByteArray> outerEaps;

    appendEapTypes(&mOuterEapsOn, &outerEaps);

    appendEapTypes(&mOuterEapsOff, &outerEaps);

    qDebug("EapQtConfigInterfacePrivate - supportedOuterTypes: EAP server outer type count: %d",

        outerEaps.count());

    qDebug("EapQtConfigInterfacePrivate - supportedOuterTypes: collected UI plugin count: %d",

        mPluginInfos.count());

    // set mSupportedOuterTypes to contain only EAPs that both UI and EAP server support

    QByteArray tmpEap;

    for (int ind = 0; ind < mPluginInfos.count(); ind++) {

        tmpEap = mPluginInfos[ind].pluginHandle().type().eapExpandedData();

        if (outerEaps.contains(tmpEap)) {

            mSupportedOuterTypes.append(mPluginInfos[ind]);

            qDebug() << "EapQtConfigInterfacePrivate - supportedOuterTypes: appended EAP: "

                << tmpEap.toHex();

        }

    }

    qDebug("EapQtConfigInterfacePrivate - supportedOuterTypes: supported EAP count: %d",

        mSupportedOuterTypes.count());

    return mSupportedOuterTypes;

}

// checks if UI plugins support supplied eapType and returns the

// index (in mPluginInfos) of the supporting plugin

bool EapQtConfigInterfacePrivate::isUiSupported(const QByteArray &eapType, int &pluginIndex) const

{

    qDebug("EapQtConfigInterfacePrivate::isUiSupported(), this = 0x%08x", this);

    bool ret = false;

    for (int ind = 0; ind < mPluginInfos.count(); ind++) {

        qDebug("EapQtConfigInterfacePrivate::isUiSupported() - checking index: %d", ind);

        pluginIndex = ind;

        if (eapType == mPluginInfos[ind].pluginHandle().type().eapExpandedData()) {

            qDebug("EapQtConfigInterfacePrivate::isUiSupported() - ui supported!");

            ret = true;

            break;

        }

    }

    return ret;

}

QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedInnerTypes(

    const EapQtPluginHandle& outer)

{

    qDebug("EapQtConfigInterfacePrivate::supportedInnerTypes(), this = 0x%08x", this);

    checkInstanceThrowing();

    // check if we already have up-to-date data

    if (mLastOuterHandle == outer) {

        return mSupportedInnerTypes;

    }

    // clear previous query result

    mSupportedInnerTypes.clear();

    mLastOuterHandle = EapQtPluginHandle::PluginUndefined;

    qDebug()

        << "EapQtConfigInterfacePrivate::supportedInnerTypes() - calls isSupportedOuterType for: "

        << outer.type().eapExpandedData().toHex();

    // check if the queried outer EAP is supported

    if (!isSupportedOuterType(outer)) {

        qDebug()

            << "ERROR: EapQtConfigInterfacePrivate::supportedInnerTypes() - queried outer type not supported: "

            << outer.type().eapExpandedData().toHex();

        // return empty list

        return mSupportedInnerTypes;

    }

    qDebug("EapQtConfigInterfacePrivate::supportedInnerTypes() - calls getEapTypeIf");

    // get outer EAP settings interface

    getEapTypeIf(outer);

    if (mEapTypeIf.isNull()) {

        qDebug("ERROR: EapQtConfigInterfacePrivate::supportedInnerTypes() - getEapTypeIf failed");

        // return empty list

        return mSupportedInnerTypes;

    }

    // get outer EAP settings

    EAPSettings eapSettings;

    TRAPD(err, mEapTypeIf->GetConfigurationL(eapSettings));

    // getEapTypeIf has set mCurrentServerEapType correctly for comparison

    if (err != KErrNone || eapSettings.iEAPExpandedType != mCurrentServerEapType) {

        qDebug("ERROR: EapQtConfigInterfacePrivate::supportedInnerTypes - GetConfigurationL failed");

        // clear the instance so that the next attempt starts from scratch

        mEapTypeIf.reset(NULL);

        // return empty list

        return mSupportedInnerTypes;

    }

    // store inner EAPs supported by EAP server

    QList<QByteArray> innerEaps;

    appendEapTypes(&(eapSettings.iEnabledEncapsulatedEAPExpandedTypes), &innerEaps);

    appendEapTypes(&(eapSettings.iDisabledEncapsulatedEAPExpandedTypes), &innerEaps);

    int pluginIndex = 0;

    for (int ind = 0; ind < innerEaps.count(); ind++) {

        // report only EAPs which do have an UI plugin

        if (isUiSupported(innerEaps[ind], pluginIndex)) {

            mSupportedInnerTypes.append(mPluginInfos[pluginIndex]);

            qDebug() << "EapQtConfigInterfacePrivate::supportedInnerTypes - added inner EAP: "

                << innerEaps[ind].toHex();

        }

    }

    mLastOuterHandle = outer;

    return mSupportedInnerTypes;

}

void EapQtConfigInterfacePrivate::copyCertificateInfo(

    const RPointerArray<EapCertificateEntry>* const certEntries,

    QList<EapQtCertificateInfo>* const certInfos)

{

    qDebug("EapQtConfigInterfacePrivate::copyCertificateInfo(), this = 0x%08x", this);

    Q_ASSERT(certEntries);

    Q_ASSERT(certInfos);

    certInfos->clear();

    EapQtCertificateInfo cert;

    TKeyIdentifier subjectKeyId;

    const TDes* text = 0;

    int ind = 0;

    for (ind = 0; ind < certEntries->Count(); ind++) {

        EapCertificateEntry* certPtr = (*certEntries)[ind];

        qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo *** certificate starts *** ";

        if (certPtr->GetSubjectNamePresent() != EFalse) {

            text = certPtr->GetSubjectName();

            cert.setValue(EapQtCertificateInfo::SubjectName, QString::fromUtf16(text->Ptr(),

                text->Length()));

            qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo SubjectName: "

                << QString::fromUtf16(text->Ptr(), text->Length());

        }

        if (certPtr->GetIssuerNamePresent() != EFalse) {

            text = certPtr->GetIssuerName();

            cert.setValue(EapQtCertificateInfo::IssuerName, QString::fromUtf16(text->Ptr(),

                text->Length()));

            qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo IssuerName: "

                << QString::fromUtf16(text->Ptr(), text->Length());

        }

        if (certPtr->GetSerialNumberPresent() != EFalse) {

            text = certPtr->GetSerialNumber();

            cert.setValue(EapQtCertificateInfo::SerialNumber, QString::fromUtf16(text->Ptr(),

                text->Length()));

            qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo SerialNumber: "

                << QString::fromUtf16(text->Ptr(), text->Length());

        }

        if (certPtr->GetSubjectKeyIdPresent() != EFalse) {

            subjectKeyId = certPtr->GetSubjectKeyId();

            cert.setValue(EapQtCertificateInfo::SubjectKeyId, QByteArray(

                reinterpret_cast<const char*> (subjectKeyId.Ptr()), subjectKeyId.Length()));

            qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo SubjectKeyId: "

                << (QByteArray(reinterpret_cast<const char*> (subjectKeyId.Ptr()),

                    subjectKeyId.Length())).toHex();

        }

        if (certPtr->GetThumbprintPresent() != EFalse) {

            text = certPtr->GetThumbprint();

            cert.setValue(EapQtCertificateInfo::ThumbPrint, QString::fromUtf16(text->Ptr(),

                text->Length()));

            qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo ThumbPrint: "

                << QString::fromUtf16(text->Ptr(), text->Length());

        }

        if (certPtr->GetLabelPresent() != EFalse) {