FCL/sf/mw/accesssec: comparison securitysettings/qtconfigutils/eapqtconfiginterface/src/eapqtconfiginterface

equal deleted inserted replaced

-:7a0216d033ac
+:fe6b6762fccd
 /*
 * 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"
+* 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.
 *   EAP method configuration QT interface
 *
 */
 /*
-* %version: 41 %
+* %version: 49 %
 */
+// System includes
 #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>
+// User includes
 #include "cpeapplugininterface.h"
 #include "eapqtconfiginterface_p.h"
-// validators
 #include "eapqtvalidatorpassword.h"
 #include "eapqtvalidatorusername.h"
 #include "eapqtvalidatorrealm.h"
+#include "eapqtvalidatorpacstorepassword.h"
-static const QString eapPluginDir("\\resource\\qt\\plugins\\controlpanel\\eapsecurity");
+#include "eapqtvalidatorpacstorepasswordconfirm.h"
+/*!
+*  \class EapQtConfigInterfacePrivate
+*  \brief Private implementation of EAP QT configuration interface
+*/
+// External function prototypes
+// Local constants
 static const QString eapTranslationFile("cpeapuiplugins");
+// ======== LOCAL FUNCTIONS ========
+// ======== MEMBER FUNCTIONS ========
 EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate() :
 mValidatorInstance(true),
 mLastOuterHandle(EapQtPluginHandle::PluginUndefined),
 mTranslator(NULL),
 mEapBearer(ELan),
 mEapDbIndex(EapQtConfigInterface::IapIdUndefined),
 mEapDbIndexValid(false)
 {
 qDebug("EapQtConfigInterfacePrivate() - created validator instance, this = 0x%08x", this);
+}
-}
+EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate(
-EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate(/* EapQtConfigInterface *configIf, */
 const EapQtConfigInterface::EapBearerType bearerType, const int iapId) :
 mValidatorInstance(false),
 mLastOuterHandle(EapQtPluginHandle::PluginUndefined),
 mTranslator(NULL),
 mEapGsIf(NULL),
 mEapDbIndex(EapQtConfigInterface::IapIdUndefined),
 mEapDbIndexValid(false)
 {
 qDebug("EapQtConfigInterfacePrivate() - creating non-validator instance, this = 0x%08x", this);
 switch (bearerType) {
 case EapQtConfigInterface::EapBearerTypeVpn:
 mEapBearer = EVpn;
 break;
 default:
 }
 void EapQtConfigInterfacePrivate::shutdown()
 {
 qDebug("EapQtConfigInterfacePrivate::shutdown(), this = 0x%08x", this);
 mOuterEapsOn.Close();
 mOuterEapsOff.Close();
 // cleanup Ecom
 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);
 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());
 }
 QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedOuterTypes()
 {
 qDebug("EapQtConfigInterfacePrivate::supportedOuterTypes(), this = 0x%08x", this);
 checkInstanceThrowing();
 if (mEapGsIf.isNull()) {
 qDebug("ERROR: EapQtConfigInterfacePrivate::supportedOuterTypes() - mEapGsIf is NULL");
 qDebug() << "EapQtConfigInterfacePrivate - supportedOuterTypes: appended EAP: "
 << tmpEap.toHex();
 }
 }
+// sort the list
+qSort(mSupportedOuterTypes.begin(), mSupportedOuterTypes.end(),
+EapQtConfigInterfacePrivate::pluginLessThan);
 qDebug("EapQtConfigInterfacePrivate - supportedOuterTypes: supported EAP count: %d",
 mSupportedOuterTypes.count());
 return mSupportedOuterTypes;
 }
 }
 return ret;
 }
 QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedInnerTypes(
-const EapQtPluginHandle& outer)
+const EapQtPluginHandle &outer)
 {
 qDebug("EapQtConfigInterfacePrivate::supportedInnerTypes(), this = 0x%08x", this);
 checkInstanceThrowing();
 // check if we already have up-to-date data
 if (mLastOuterHandle == outer) {
 }
 }
 mLastOuterHandle = outer;
+// sort the list
+qSort(mSupportedInnerTypes.begin(), mSupportedInnerTypes.end(),
+EapQtConfigInterfacePrivate::pluginLessThan);
+qDebug("EapQtConfigInterfacePrivate - supportedInnerTypes: supported EAP count: %d",
+mSupportedInnerTypes.count());
 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();
 const TDes* text = 0;
 int ind = 0;
 for (ind = 0; ind < certEntries->Count(); ind++) {
+// cleanup cert
+cert.clear();
 EapCertificateEntry* certPtr = (*certEntries)[ind];
 qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo *** certificate starts *** ";
 if (certPtr->GetSubjectNamePresent() != EFalse) {
 bool EapQtConfigInterfacePrivate::fetchCertificates(QList<EapQtCertificateInfo>* const caInfos,
 QList<EapQtCertificateInfo>* const clientInfos)
 {
 qDebug("EapQtConfigInterfacePrivate::fetchCertificates(), this = 0x%08x", this);
+Q_ASSERT(caInfos != NULL || clientInfos != NULL);
-Q_ASSERT(caInfos != NULL || clientInfos != NULL || !mEapGsIf.isNull());
+Q_ASSERT(!mEapGsIf.isNull());
 TInt err(KErrNone);
 RPointerArray<EapCertificateEntry> clientCerts;
 RPointerArray<EapCertificateEntry> caCerts;
-// lists are always queried again as the user might have installed new certificates
-// during the life time of the object
 err = mEapGsIf->GetCertificateLists(clientCerts, caCerts);
 if (err != KErrNone) {
 qDebug("EapQtConfigInterfacePrivate - fetchCertificates failed: %d", err);
 caCerts.ResetAndDestroy();
 clientCerts.ResetAndDestroy();
 caCerts.ResetAndDestroy();
 clientCerts.ResetAndDestroy();
 return true;
 }
+bool EapQtConfigInterfacePrivate::updateCertificates() {
+qDebug("EapQtConfigInterfacePrivate::updateCertificates(), this = 0x%08x", this);
+checkInstanceThrowing();
+// empty current state
+mCaCertificates.clear();
+mUserCertificates.clear();
+return fetchCertificates(&mCaCertificates, &mUserCertificates);
+}
 QList<EapQtCertificateInfo> EapQtConfigInterfacePrivate::certificateAuthorityCertificates()
 {
 qDebug("EapQtConfigInterfacePrivate::certificateAuthorityCertificates(), this = 0x%08x", this);
 checkInstanceThrowing();
-QList<EapQtCertificateInfo> list;
+// update only if the list is empty
-if (!fetchCertificates(&list, 0)) {
+if(mCaCertificates.length() == 0) {
-// query failed
+qDebug() << "EapQtConfigInterfacePrivate::certificateAuthorityCertificates() - updates certificate lists";
-list.clear();
+updateCertificates();
 }
-return list;
+return mCaCertificates;
 }
 QList<EapQtCertificateInfo> EapQtConfigInterfacePrivate::userCertificates()
 {
 qDebug("EapQtConfigInterfacePrivate::userCertificates(), this = 0x%08x", this);
+// use the CA certificates method, it will update both the lists
-checkInstanceThrowing();
+// if CA list is empty
+(void) certificateAuthorityCertificates();
-QList<EapQtCertificateInfo> list;
+return mUserCertificates;
-if (!fetchCertificates(0, &list)) {
+}
-// query failed
-list.clear();
+void EapQtConfigInterfacePrivate::getEapTypeIf(const EapQtPluginHandle &pluginHandle)
-}
-return list;
-}
-void EapQtConfigInterfacePrivate::getEapTypeIf(const EapQtPluginHandle& pluginHandle)
 {
 qDebug("EapQtConfigInterfacePrivate::getEapTypeIf(), this = 0x%08x", this);
 // dig up the EAP type in TEapExpandedType format
 TEapExpandedType eapServerType;
 QByteArray eapType = pluginHandle.type().eapExpandedData();
 TInt err(KErrNone);
 // in config:
 // if OuterType is defined, the configuration for pluginHandle is set inside this OuterType
 // if OuterType is not defined, pluginHandle is for an outer type
 // if InnerType is defined, the defined inner types in config are activated for pluginHandle
 // if InnerType is not defined, the pluginHandle does not activate any inner type (or they do not exist)
-bool EapQtConfigInterfacePrivate::saveConfiguration(const EapQtPluginHandle& pluginHandle,
+bool EapQtConfigInterfacePrivate::saveConfiguration(const EapQtPluginHandle &pluginHandle,
-EapQtConfig& config)
+const EapQtConfig &config)
 {
 qDebug("EapQtConfigInterfacePrivate::saveConfiguration(), this = 0x%08x", this);
 checkInstanceThrowing();
 if (!mEapDbIndexValid) {
 qDebug() << "ERROR: Database reference not valid, call setConfigurationReference first!";
 return false;
 }
-// only check if EAP ui is supported here,
+// set tunneling type & check if the requested EAP is supported
-// getEapTypeIf checks the EAP server support
+// if we are configuring outer type, OuterType == QVariant::Invalid or
-int dummy = 0;
+// EapQtPluginHandle::PluginUndefined
-if (!isUiSupported(pluginHandle.type().eapExpandedData(), dummy)) {
-qDebug(
+EapQtPluginHandle tmpOuterHandle;
-"ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - UI not supported for the requested EAP");
+QVariant varValue = config.value(EapQtConfig::OuterType);
-return false;
+if (varValue != QVariant::Invalid && !(varValue.value<EapQtPluginHandle> () == EapQtPluginHandle::PluginUndefined)) {
+tmpOuterHandle = varValue.value<EapQtPluginHandle> ();
+// check if supported
+if(!isSupportedInnerType(tmpOuterHandle, pluginHandle)) {
+qDebug("ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - not supported outer/inner type combination");
+return false;
+}
+}
+else {
+tmpOuterHandle = EapQtPluginHandle::PluginUndefined;
+// check if supported
+if(!isSupportedOuterType(pluginHandle)) {
+qDebug("ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - not supported outer type");
+return false;
+}
 }
 getEapTypeIf(pluginHandle);
 if (mEapTypeIf.isNull()) {
 qDebug("ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - getEapTypeIf failed");
 return false;
-}
-// set tunneling type
-// if we are configuring outer type, OuterType == Invalid or EapQtPluginHandle::PluginUndefined
-EapQtPluginHandle tmpOuterHandle;
-QVariant varValue = config.value(EapQtConfig::OuterType);
-if (varValue != QVariant::Invalid) {
-tmpOuterHandle = varValue.value<EapQtPluginHandle> ();
-}
-else {
-tmpOuterHandle = EapQtPluginHandle::PluginUndefined;
 }
 TEapExpandedType tmpOuterEap;
 tmpOuterEap.SetValue(tmpOuterHandle.type().eapExpandedData().data(),
 tmpOuterHandle.type().eapExpandedData().length());
 return true;
 }
 // config must be empty when calling
-bool EapQtConfigInterfacePrivate::readConfiguration(const EapQtPluginHandle& outerHandle,
+bool EapQtConfigInterfacePrivate::readConfiguration(const EapQtPluginHandle &outerHandle,
-const EapQtPluginHandle& pluginHandle, EapQtConfig& config)
+const EapQtPluginHandle &pluginHandle, EapQtConfig &config)
 {
 qDebug("EapQtConfigInterfacePrivate::readConfiguration(), this = 0x%08x", this);
 // clear input
 config.clear();
 if (!mEapDbIndexValid) {
 qDebug() << "ERROR: Database reference not valid, call setConfigurationReference first!";
 return false;
 }
-// only check if UI is supported for pluginHandle here,
+// check EAP type support
-// getEapTypeIf checks the EAP server support
+if(!(outerHandle == EapQtPluginHandle::PluginUndefined)) {
-int dummy = 0;
+if(!isSupportedInnerType(outerHandle, pluginHandle)) {
-if (!isUiSupported(pluginHandle.type().eapExpandedData(), dummy)) {
+qDebug("ERROR: EapQtConfigInterfacePrivate::readConfiguration() - not supported outer/inner type combination");
-qDebug(
+return false;
-"ERROR: EapQtConfigInterfacePrivate::readConfiguration - UI not supported for the requested EAP");
+}
-return false;
+} else {
+if(!isSupportedOuterType(pluginHandle)) {
+qDebug("ERROR: EapQtConfigInterfacePrivate::readConfiguration() - not supported outer type");
+return false;
+}
 }
 getEapTypeIf(pluginHandle);
 if (mEapTypeIf.isNull()) {
 qDebug("ERROR: EapQtConfigInterfacePrivate::readConfiguration - getEapTypeIf failed");
 TBool EapQtConfigInterfacePrivate::convertToTbool(bool value)
 {
 return (value ? ETrue : EFalse);
 }
-void EapQtConfigInterfacePrivate::copyToEapSettings(EapQtConfig& config, EAPSettings& eapSettings)
+void EapQtConfigInterfacePrivate::copyToEapSettings(const EapQtConfig &config, EAPSettings &eapSettings)
 {
 qDebug("EapQtConfigInterfacePrivate::copyToEapSettings(), this = 0x%08x", this);
 int ind = 0;
 QVariant varValue = config.value(EapQtConfig::UsernameAutomatic);
 if (varValue.type() == QVariant::Bool) {
 if (varValue.type() == QVariant::Bool) {
 eapSettings.iPEAPVersionsPresent = ETrue;
 eapSettings.iPEAPv0Allowed = convertToTbool(varValue.toBool());
 qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PeapVersion0Allowed: "
 << varValue.toBool();
+} else {
+// in any other case disable PEAP version;
+// no need to set eapSettings.iPEAPVersionsPresent,
+// it will be set if one of the other PEAP versions is enabled,
+// otherwise this setting is redundant and can be ignored
+eapSettings.iPEAPv0Allowed = EFalse;
 }
 varValue = config.value(EapQtConfig::PeapVersion1Allowed);
 if (varValue.type() == QVariant::Bool) {
 eapSettings.iPEAPVersionsPresent = ETrue;
 eapSettings.iPEAPv1Allowed = convertToTbool(varValue.toBool());
 qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PeapVersion1Allowed: "
 << varValue.toBool();
+} else {
+// in any other case disable PEAP version;
+// no need to set eapSettings.iPEAPVersionsPresent,
+// it will be set if one of the other PEAP versions is enabled,
+// otherwise this setting is redundant and can be ignored
+eapSettings.iPEAPv1Allowed = EFalse;
 }
 varValue = config.value(EapQtConfig::PeapVersion2Allowed);
 if (varValue.type() == QVariant::Bool) {
 eapSettings.iPEAPVersionsPresent = ETrue;
 eapSettings.iPEAPv2Allowed = convertToTbool(varValue.toBool());
 qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PeapVersion2Allowed: "
 << varValue.toBool();
+} else {
+// in any other case disable PEAP version;
+// no need to set eapSettings.iPEAPVersionsPresent,
+// it will be set if one of the other PEAP versions is enabled,
+// otherwise this setting is redundant and can be ignored
+eapSettings.iPEAPv2Allowed = EFalse;
 }
 varValue = config.value(EapQtConfig::ProvisioningModeAuthenticated);
 if (varValue.type() == QVariant::Bool) {
 eapSettings.iAuthProvModeAllowedPresent = ETrue;
 }
 varValue = config.value(EapQtConfig::PACGroupReference);
 // do not copy if too large string
 if (varValue.type() == QVariant::String && varValue.toString().count() <= StringMaxLength) {
-// not supported
+eapSettings.iPACGroupReference.Copy(varValue.toString().utf16());
+eapSettings.iPACGroupReferencePresent = ETrue;
 qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PACGroupReference: "
 << varValue.toString();
 }
 varValue = config.value(EapQtConfig::WarnADHPNoPAC);
 if (varValue.type() == QVariant::List) {
 qDebug() << "EapQtConfigInterfacePrivate::copyToEapSettings() - CipherSuites present";
 QList<QVariant> varCiphers = varValue.toList();
+// clears the ciphersuite configuration if the provided list is empty
+eapSettings.iCipherSuitesPresent = ETrue;
 for (ind = 0; ind < varCiphers.count(); ind++) {
 // check that the item is of correct type (int also accepted to not be too strict)
 if (varCiphers[ind].type() == QVariant::UInt || varCiphers[ind].type() == QVariant::Int) {
-// set to true only if at least item cipher is ok
-eapSettings.iCipherSuitesPresent = ETrue;
 eapSettings.iCipherSuites.Append(varCiphers[ind].toUInt());
 qDebug(
 "EapQtConfigInterfacePrivate::copyToEapSettings() - CipherSuites at %d: 0x%08x",
 ind, varCiphers[ind].toUInt());
 }
 }
 }
+// set always to true to support clearing previously configured CA/user certificates
+// if the EAP method in question does not use certificates,
+// EAP server will ignore the setting;
+// CA/user certificates get cleared if EapQtConfig::Authority/UserCertificate is QVariant::Invalid or
+// the provided lists are empty
+eapSettings.iCertificatesPresent = ETrue;
 varValue = config.value(EapQtConfig::AuthorityCertificate);
 if (varValue.type() == QVariant::List) {
 qDebug()
 << "EapQtConfigInterfacePrivate::copyToEapSettings() - AuthorityCertificate present";
 QList<QVariant> varCerts = varValue.toList();
 for (ind = 0; ind < varCerts.count(); ind++) {
 // check that the item is of correct type
 if (varCerts[ind].canConvert<EapQtCertificateInfo> ()) {
-// set to true only if at least one item is ok
-eapSettings.iCertificatesPresent = ETrue;
 appendCertificateInfo(true, varCerts[ind].value<EapQtCertificateInfo> (),
 &(eapSettings.iCertificates));
 qDebug()
 << "EapQtConfigInterfacePrivate::copyToEapSettings() - AuthorityCertificate appended";
 }
 QList<QVariant> varCerts = varValue.toList();
 for (ind = 0; ind < varCerts.count(); ind++) {
 // check that the item is of correct type
 if (varCerts[ind].canConvert<EapQtCertificateInfo> ()) {
-// set to true only if at least one item is ok
-eapSettings.iCertificatesPresent = ETrue;
 appendCertificateInfo(false, varCerts[ind].value<EapQtCertificateInfo> (),
 &(eapSettings.iCertificates));
 qDebug()
 << "EapQtConfigInterfacePrivate::copyToEapSettings() - AuthorityCertificate appended";
 }
 // caller takes care of deallocating resulting data in certList
 void EapQtConfigInterfacePrivate::appendCertificateInfo(bool isCaCertificate,
 const EapQtCertificateInfo& certInfo, RPointerArray<EapCertificateEntry>* const certList)
 {
 qDebug("EapQtConfigInterfacePrivate::appendCertificateInfo(), this = 0x%08x", this);
 Q_ASSERT(certList);
 // use scoped pointer to make sure memory is not leaked in failures
 QScopedPointer<EapCertificateEntry> certEntry(new EapCertificateEntry);
 // all ok, remove the ownerhsip from scoped pointer
 (void) certEntry.take();
 }
-void EapQtConfigInterfacePrivate::copyFromEapSettings(EAPSettings& eapSettings, EapQtConfig& config)
+void EapQtConfigInterfacePrivate::copyFromEapSettings(EAPSettings &eapSettings, EapQtConfig &config)
 {
 qDebug("EapQtConfigInterfacePrivate::copyFromEapSettings(), this = 0x%08x", this);
 int ind = 0;
 QList<EapQtPluginHandle> EapQtConfigInterfacePrivate::selectedOuterTypes()
 {
 qDebug("EapQtConfigInterfacePrivate::selectedOuterTypes(), this = 0x%08x", this);
 checkInstanceThrowing();
 if (!mEapDbIndexValid) {
 qDebug() << "ERROR: Database reference not valid, call setConfigurationReference first!";
 return QList<EapQtPluginHandle> ();
 selectedOuterTypes.count());
 return selectedOuterTypes;
 }
-bool EapQtConfigInterfacePrivate::isSupportedOuterType(const EapQtPluginHandle& handle)
+bool EapQtConfigInterfacePrivate::isSupportedOuterType(const EapQtPluginHandle &handle)
 {
 qDebug("EapQtConfigInterfacePrivate::isSupportedOuterType(), this = 0x%08x", this);
 checkInstanceThrowing();
 // check if mSupportedOuterTypes is up-to-date
 if (mSupportedOuterTypes.count() <= 0) {
 }
 return ret;
 }
 bool EapQtConfigInterfacePrivate::setSelectedOuterTypes(
-const QList<EapQtPluginHandle>& outerHandles)
+const QList<EapQtPluginHandle> &outerHandles)
 {
 qDebug("EapQtConfigInterfacePrivate::setSelectedOuterTypes()");
 checkInstanceThrowing();
 if (!mEapDbIndexValid || mEapGsIf.isNull()) {
 qDebug()
 ret = false;
 }
 return ret;
 }
-bool EapQtConfigInterfacePrivate::isSupportedInnerType(const EapQtPluginHandle& outerHandle,
+bool EapQtConfigInterfacePrivate::isSupportedInnerType(const EapQtPluginHandle &outerHandle,
-const EapQtPluginHandle& innerHandle)
+const EapQtPluginHandle &innerHandle)
 {
 qDebug("EapQtConfigInterfacePrivate::isSupportedInnerType(), this = 0x%08x", this);
 checkInstanceThrowing();
 // update mSupportedInnerTypes
 (void) supportedInnerTypes(outerHandle);
 }
 bool EapQtConfigInterfacePrivate::deleteConfiguration()
 {
 qDebug("EapQtConfigInterfacePrivate::deleteConfiguration(), this = 0x%08x", this);
 checkInstanceThrowing();
 if (!mEapDbIndexValid || mEapGsIf.isNull()) {
 qDebug()
 {
 qDebug("EapQtConfigInterfacePrivate::loadPlugins(), this = 0x%08x", this);
 checkInstanceThrowing();
-QDir pluginsDir(eapPluginDir);
+// plugin directory defined in cpeapplugininterface.h
+QDir pluginsDir(CpEapPluginInterfacePluginDirectory);
 foreach( QString fileName, pluginsDir.entryList(QDir::Files) )
 {
 QPluginLoader loader(pluginsDir.absoluteFilePath(fileName));
 QObject *tmp = loader.instance();
 if (tmp) {
 // collect UI plugin infos
 QList<CpEapPluginInterface*>::iterator iter;
 for (iter = mPlugins.begin(); iter != mPlugins.end(); ++iter) {
 mPluginInfos.append((*iter)->pluginInfo());
 }
-}
+// sort the UI plugins according to their order number
-CpBaseSettingView *EapQtConfigInterfacePrivate::uiInstance(const EapQtPluginHandle& outerHandle,
+qSort(mPluginInfos.begin(), mPluginInfos.end(), EapQtConfigInterfacePrivate::pluginLessThan);
-const EapQtPluginHandle& pluginHandle)
+qDebug("EapQtConfigInterfacePrivate - loadPlugins: supported EAP plugin count: %d",
+mPluginInfos.count());
+}
+bool EapQtConfigInterfacePrivate::pluginLessThan(
+const EapQtPluginInfo &plugin1,
+const EapQtPluginInfo &plugin2)
+{
+return plugin1.orderNumber() < plugin2.orderNumber();
+}
+CpBaseSettingView *EapQtConfigInterfacePrivate::uiInstance(const EapQtPluginHandle &outerHandle,
+const EapQtPluginHandle &pluginHandle)
 {
 qDebug("EapQtConfigInterfacePrivate::uiInstance(), this = 0x%08x", this);
 checkInstanceThrowing();
 // if outer type UI is requested, outerHandle must be undefined and pluginHandle
 // must be supported as outer type
 break;
 }
 return ret;
 }
-EapQtValidator *EapQtConfigInterfacePrivate::validatorEap(EapQtExpandedEapType type,
+EapQtValidator *EapQtConfigInterfacePrivate::validatorEap(const EapQtExpandedEapType &type,
-EapQtConfig::SettingsId id)
+const EapQtConfig::SettingsId id)
 {
 qDebug("EapQtConfigInterfacePrivate::validatorEap(), this = 0x%08x", this);
+qDebug() << "EapQtConfigInterfacePrivate::validatorEap() - requested EAP: "
+<< type.eapExpandedData().toHex();
+qDebug() << "EapQtConfigInterfacePrivate::validatorEap() - setting: " << id;
 EapQtValidator *ret = NULL;
 switch (id) {
 default:
 ret = NULL;
 }
+qDebug() << "EapQtConfigInterfacePrivate::validatorEap() - is returning NULL: " << (ret == NULL);
 return ret;
 }
+bool EapQtConfigInterfacePrivate::readPacStoreConfiguration(EapQtPacStoreConfig& /* config */)
+{
+// not supported
+return false;
+}
+bool EapQtConfigInterfacePrivate::savePacStoreConfiguration(const EapQtPacStoreConfig& /* config */)
+{
+// not supported
+return false;
+}
+EapQtValidator *EapQtConfigInterfacePrivate::validatorPacStore(
+const EapQtPacStoreConfig::PacStoreSettings id)
+{
+qDebug("EapQtConfigInterfacePrivate::validatorPacStore(), this = 0x%08x", this);
+EapQtValidator *ret = NULL;
+switch (id) {
+case EapQtPacStoreConfig::PacStorePassword:
+ret = new EapQtValidatorPacStorePassword();
+break;
+case EapQtPacStoreConfig::PacStorePasswordConfirmation:
+ret = new EapQtValidatorPacStorePasswordConfirm();
+break;
+default:
+ret = NULL;
+}
+return ret;
+}

changeset 39	fe6b6762fccd
parent 33	938269283a16
child 42	53085837e73a