1 /*

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

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description: 

    15  *   EAP method configuration QT interface

    16  *

    17  */

    18 

    19 /*

    20  * %version: 49 %

    21  */

    22 

    23 // System includes

    24 #include <QDir>

    25 #include <QList>

    26 #include <QVariant>

    27 #include <QPluginLoader>

    28 #include <HbTranslator>

    29 #include <QLocale>

    30 #include <QCoreApplication>

    31 #include <QDebug>

    32 #include <cmmanager.h>

    33 #include <cmpluginwlandef.h>

    34 #include <EapGeneralSettings.h>

    35 #include <eapqtplugininfo.h>

    36 #include <eapqtcertificateinfo.h>

    37 

    38 // User includes

    39 #include "cpeapplugininterface.h"

    40 #include "eapqtconfiginterface_p.h"

    41 #include "eapqtvalidatorpassword.h"

    42 #include "eapqtvalidatorusername.h"

    43 #include "eapqtvalidatorrealm.h"

    44 #include "eapqtvalidatorpacstorepassword.h"

    45 #include "eapqtvalidatorpacstorepasswordconfirm.h"

    46 

    47 /*!

    48  *  \class EapQtConfigInterfacePrivate

    49  *  \brief Private implementation of EAP QT configuration interface

    50  */

    51 

    52 // External function prototypes

    53 

    54 // Local constants

    55 static const QString eapTranslationFile("cpeapuiplugins");

    56 

    57 // ======== LOCAL FUNCTIONS ========

    58 

    59 // ======== MEMBER FUNCTIONS ========

    60 

    61 EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate() :

    62   mValidatorInstance(true),

    63   mLastOuterHandle(EapQtPluginHandle::PluginUndefined),

    64   mTranslator(NULL),

    65   mEapGsIf(NULL), 

    66   mEapTypeIf(NULL),

    67   mIapId(0),

    68   mEapBearer(ELan),

    69   mEapDbIndex(EapQtConfigInterface::IapIdUndefined),

    70   mEapDbIndexValid(false)

    71 {

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

    73 }

    74 

    75 EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate(

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

    77   mValidatorInstance(false),

    78   mLastOuterHandle(EapQtPluginHandle::PluginUndefined),

    79   mTranslator(NULL), 

    80   mEapGsIf(NULL), 

    81   mEapTypeIf(NULL),

    82   mIapId(iapId),

    83   mEapBearer(ELan),

    84   mEapDbIndex(EapQtConfigInterface::IapIdUndefined),

    85   mEapDbIndexValid(false)

    86 {

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

    88 

    89     switch (bearerType) {

    90     case EapQtConfigInterface::EapBearerTypeVpn:

    91         mEapBearer = EVpn;

    92         break;

    93     default:

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

    95         mEapBearer = ELan;

    96     }

    97 

    98     if (!setEapDbIndex(iapId)) {

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

   100             mEapBearer, iapId);

   101         shutdown();

   102         // throw an exception

   103         qt_symbian_throwIfError(KErrNotFound);

   104     }

   105 

   106     // load plugins after everything else is ok

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

   108     loadPlugins();

   109 

   110     qDebug("EapQtConfigInterfacePrivate() - ends");

   111 }

   112 

   113 EapQtConfigInterfacePrivate::~EapQtConfigInterfacePrivate()

   114 {

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

   116 

   117     shutdown();

   118 }

   119 

   120 void EapQtConfigInterfacePrivate::shutdown()

   121 {

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

   123 

   124     mOuterEapsOn.Close();

   125     mOuterEapsOff.Close();

   126 

   127     // cleanup Ecom

   128     REComSession::FinalClose();

   129 

   130     // mTranslator gets deleted automatically (QScopedPointer)

   131     // mEapTypeIf gets deleted automatically (QScopedPointer)

   132     // mEapGsIf gets deleted automatically (QScopedPointer)

   133 }

   134 

   135 bool EapQtConfigInterfacePrivate::setConfigurationReference(const int iapId)

   136 {

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

   138 

   139     checkInstanceThrowing();

   140     return setEapDbIndex(iapId);

   141 }

   142 

   143 bool EapQtConfigInterfacePrivate::setEapDbIndex(const int iapId)

   144 {

   145 

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

   147 

   148 

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

   150     // not change and mEapGsIf exists already

   151 

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

   153     // different than WLAN service ID

   154 

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

   156     // with a negative id last time and now again

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

   158         qDebug(

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

   160         return true;

   161     }

   162 

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

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

   165         qDebug(

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

   167         return true;

   168     }

   169 

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

   171     TInt previousEapDbIndex = mEapDbIndex;

   172     bool wlanIndexOk = true;

   173 

   174     // allow accessing certain methods with negative iapId

   175     if (iapId < 0) {

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

   177         mEapDbIndex = 0;

   178         mEapDbIndexValid = false;

   179     }

   180     // for real usage iapId must not be negative

   181     else {

   182         // for VPN

   183         mIapId = iapId;

   184         mEapDbIndex = iapId;

   185         mEapDbIndexValid = true;

   186 

   187         // for WLAN

   188         if (mEapBearer == ELan) {

   189             // get WLAN service ID as the reference

   190             mEapDbIndexValid = setEapWlanDbIndex(iapId);

   191             wlanIndexOk = mEapDbIndexValid;

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

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

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

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

   196                 return true;

   197             }

   198 

   199         }

   200     }

   201 

   202     // delete possibly existing instances

   203     mEapGsIf.reset(NULL);

   204     mEapTypeIf.reset(NULL);

   205 

   206     mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   207     mLastOuterHandle = EapQtPluginHandle::PluginUndefined;

   208 

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

   210         // setEapWlanDbIndex was called and failed

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

   212         return false;

   213     }

   214 

   215     qDebug(

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

   217         mEapBearer, mEapDbIndex);

   218 

   219     // load EAP general settings interface

   220     CEapGeneralSettings* tmp = NULL;

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

   222     if (err != KErrNone) {

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

   224         mEapDbIndexValid = false;

   225         return false;

   226     }

   227 

   228     // set to the created instance

   229     mEapGsIf.reset(tmp);

   230 

   231     return true;

   232 }

   233 

   234 bool EapQtConfigInterfacePrivate::setEapWlanDbIndex(const int iapId)

   235 {

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

   237 

   238     RCmManager cmm;

   239     TRAPD(err, cmm.OpenL());

   240     if (err != KErrNone) {

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

   242             mEapBearer, iapId);

   243         mEapDbIndex = EapQtConfigInterface::IapIdUndefined;

   244         mIapId = 0;

   245         return false;

   246     }

   247 

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

   249     if (err != KErrNone) {

   250         qDebug(

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

   252             mEapBearer, iapId);

   253         cmm.Close();

   254         mEapDbIndex = EapQtConfigInterface::IapIdUndefined;

   255         mIapId = 0;

   256         return false;

   257     }

   258 

   259     cmm.Close();

   260 

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

   262         mEapDbIndex);

   263 

   264     return true;

   265 }

   266 

   267 void EapQtConfigInterfacePrivate::checkInstanceThrowing() const

   268 {

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

   270         << mValidatorInstance;

   271 

   272     if (mValidatorInstance) {

   273         qDebug(

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

   275         qt_symbian_throwIfError(KErrNotSupported);

   276     }

   277 }

   278 

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

   280     QList<QByteArray>* const eapList)

   281 {

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

   283 

   284     Q_ASSERT(eapTypes);

   285     Q_ASSERT(eapList);

   286 

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

   288 

   289     QByteArray tmpEap;

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

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

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

   293         eapList->append(tmpEap);

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

   295         tmpEap.clear();

   296     }

   297 }

   298 

   299 QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedOuterTypes()

   300 {

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

   302 

   303     checkInstanceThrowing();

   304 

   305     if (mEapGsIf.isNull()) {

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

   307         mOuterEapsOn.Reset();

   308         mOuterEapsOff.Reset();

   309         // return empty list

   310         mSupportedOuterTypes.clear();

   311         return mSupportedOuterTypes;

   312     }

   313 

   314     // get outer EAPs from EAP server,

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

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

   317     // other methods

   318 

   319     mOuterEapsOn.Reset();

   320     mOuterEapsOff.Reset();

   321 

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

   323 

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

   325     if (err != KErrNone) {

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

   327         mOuterEapsOn.Reset();

   328         mOuterEapsOff.Reset();

   329         // return empty list

   330         mSupportedOuterTypes.clear();

   331         return mSupportedOuterTypes;

   332     }

   333 

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

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

   336     if (mSupportedOuterTypes.count() > 0) {

   337         qDebug(

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

   339         return mSupportedOuterTypes;

   340     }

   341 

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

   343 

   344     // copy response to qlist for easier comparison

   345     QList<QByteArray> outerEaps;

   346 

   347     appendEapTypes(&mOuterEapsOn, &outerEaps);

   348     appendEapTypes(&mOuterEapsOff, &outerEaps);

   349 

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

   351         outerEaps.count());

   352 

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

   354         mPluginInfos.count());

   355 

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

   357     QByteArray tmpEap;

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

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

   360         if (outerEaps.contains(tmpEap)) {

   361             mSupportedOuterTypes.append(mPluginInfos[ind]);

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

   363                 << tmpEap.toHex();

   364         }

   365     }

   366 

   367     // sort the list

   368     qSort(mSupportedOuterTypes.begin(), mSupportedOuterTypes.end(),

   369         EapQtConfigInterfacePrivate::pluginLessThan);

   370 

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

   372         mSupportedOuterTypes.count());

   373 

   374     return mSupportedOuterTypes;

   375 }

   376 

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

   378 // index (in mPluginInfos) of the supporting plugin

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

   380 {

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

   382 

   383     bool ret = false;

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

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

   386         pluginIndex = ind;

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

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

   389             ret = true;

   390             break;

   391         }

   392     }

   393     return ret;

   394 }

   395 

   396 QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedInnerTypes(

   397     const EapQtPluginHandle &outer)

   398 {

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

   400 

   401     checkInstanceThrowing();

   402 

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

   404     if (mLastOuterHandle == outer) {

   405         return mSupportedInnerTypes;

   406     }

   407 

   408     // clear previous query result

   409     mSupportedInnerTypes.clear();

   410     mLastOuterHandle = EapQtPluginHandle::PluginUndefined;

   411 

   412     qDebug()

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

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

   415 

   416     // check if the queried outer EAP is supported

   417     if (!isSupportedOuterType(outer)) {

   418         qDebug()

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

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

   421         // return empty list

   422         return mSupportedInnerTypes;

   423     }

   424 

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

   426 

   427     // get outer EAP settings interface

   428     getEapTypeIf(outer);

   429     if (mEapTypeIf.isNull()) {

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

   431         // return empty list

   432         return mSupportedInnerTypes;

   433     }

   434 

   435     // get outer EAP settings

   436     EAPSettings eapSettings;

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

   438     // getEapTypeIf has set mCurrentServerEapType correctly for comparison

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

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

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

   442         mEapTypeIf.reset(NULL);

   443         // return empty list

   444         return mSupportedInnerTypes;

   445     }

   446 

   447     // store inner EAPs supported by EAP server

   448     QList<QByteArray> innerEaps;

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

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

   451 

   452     int pluginIndex = 0;

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

   454         // report only EAPs which do have an UI plugin

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

   456             mSupportedInnerTypes.append(mPluginInfos[pluginIndex]);

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

   458                 << innerEaps[ind].toHex();

   459         }

   460     }

   461 

   462     mLastOuterHandle = outer;

   463 

   464     // sort the list

   465     qSort(mSupportedInnerTypes.begin(), mSupportedInnerTypes.end(),

   466         EapQtConfigInterfacePrivate::pluginLessThan);

   467 

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

   469         mSupportedInnerTypes.count());

   470 

   471     return mSupportedInnerTypes;

   472 }

   473 

   474 void EapQtConfigInterfacePrivate::copyCertificateInfo(

   475     const RPointerArray<EapCertificateEntry>* const certEntries,

   476     QList<EapQtCertificateInfo>* const certInfos)

   477 {

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

   479 

   480     Q_ASSERT(certEntries);

   481     Q_ASSERT(certInfos);

   482 

   483     certInfos->clear();

   484 

   485     EapQtCertificateInfo cert;

   486     TKeyIdentifier subjectKeyId;

   487     const TDes* text = 0;

   488     int ind = 0;

   489 

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

   491 

   492         // cleanup cert

   493         cert.clear();

   494 

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

   496 

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

   498 

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

   500 

   501             text = certPtr->GetSubjectName();

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

   503                 text->Length()));

   504 

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

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

   507         }

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

   509 

   510             text = certPtr->GetIssuerName();

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

   512                 text->Length()));

   513 

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

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

   516         }

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

   518 

   519             text = certPtr->GetSerialNumber();

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

   521                 text->Length()));

   522 

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

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

   525         }

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

   527 

   528             subjectKeyId = certPtr->GetSubjectKeyId();

   529             cert.setValue(EapQtCertificateInfo::SubjectKeyId, QByteArray(

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

   531 

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

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

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

   535         }

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

   537 

   538             text = certPtr->GetThumbprint();

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

   540                 text->Length()));

   541 

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

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

   544         }

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

   546 

   547             text = certPtr->GetLabel();

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

   549                 text->Length()));

   550 

   551             qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo CertificateLabel: "

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

   553         }

   554 

   555         qDebug() << "EapQtConfigInterfacePrivate - copyCertificateInfo *** certificate ends *** ";

   556 

   557         certInfos->append(cert);

   558 

   559     }

   560 }

   561 

   562 bool EapQtConfigInterfacePrivate::fetchCertificates(QList<EapQtCertificateInfo>* const caInfos,

   563     QList<EapQtCertificateInfo>* const clientInfos)

   564 {

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

   566 

   567     Q_ASSERT(caInfos != NULL || clientInfos != NULL);

   568     Q_ASSERT(!mEapGsIf.isNull());

   569 

   570     TInt err(KErrNone);

   571     RPointerArray<EapCertificateEntry> clientCerts;

   572     RPointerArray<EapCertificateEntry> caCerts;

   573 

   574     err = mEapGsIf->GetCertificateLists(clientCerts, caCerts);

   575     if (err != KErrNone) {

   576         qDebug("EapQtConfigInterfacePrivate - fetchCertificates failed: %d", err);

   577         caCerts.ResetAndDestroy();

   578         clientCerts.ResetAndDestroy();

   579         return false;

   580     }

   581 

   582     qDebug("user cert count: %d, CA cert count: %d", clientCerts.Count(), caCerts.Count());

   583 

   584     if (caInfos != NULL) {

   585         copyCertificateInfo(&caCerts, caInfos);

   586     }

   587     if (clientInfos != NULL) {

   588         copyCertificateInfo(&clientCerts, clientInfos);

   589     }

   590 

   591     caCerts.ResetAndDestroy();

   592     clientCerts.ResetAndDestroy();

   593     return true;

   594 }

   595 

   596 bool EapQtConfigInterfacePrivate::updateCertificates() {

   597 

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

   599 

   600     checkInstanceThrowing();

   601 

   602     // empty current state

   603     mCaCertificates.clear();

   604     mUserCertificates.clear();

   605 

   606     return fetchCertificates(&mCaCertificates, &mUserCertificates);

   607 }

   608 

   609 QList<EapQtCertificateInfo> EapQtConfigInterfacePrivate::certificateAuthorityCertificates()

   610 {

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

   612 

   613     checkInstanceThrowing();

   614 

   615     // update only if the list is empty

   616     if(mCaCertificates.length() == 0) {

   617         qDebug() << "EapQtConfigInterfacePrivate::certificateAuthorityCertificates() - updates certificate lists";

   618         updateCertificates();

   619     }

   620 

   621     return mCaCertificates;

   622 }

   623 

   624 QList<EapQtCertificateInfo> EapQtConfigInterfacePrivate::userCertificates()

   625 {

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

   627 

   628     // use the CA certificates method, it will update both the lists

   629     // if CA list is empty

   630     (void) certificateAuthorityCertificates();

   631     return mUserCertificates;

   632 }

   633 

   634 void EapQtConfigInterfacePrivate::getEapTypeIf(const EapQtPluginHandle &pluginHandle)

   635 {

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

   637 

   638     // dig up the EAP type in TEapExpandedType format

   639     TEapExpandedType eapServerType;

   640     QByteArray eapType = pluginHandle.type().eapExpandedData();

   641     TInt err(KErrNone);

   642 

   643     qDebug() << "EapQtConfigInterfacePrivate - getEapTypeIf: wanted EAP type: " << eapType.toHex();

   644 

   645     // no need to check if this is successful,

   646     // CEapType::NewL call will handle errors

   647     (void) eapServerType.SetValue(eapType.data(), eapType.length());

   648 

   649     // slight optimization, load interface only if it does not exist or the EAP type changes

   650     if (mEapTypeIf.isNull() || mCurrentServerEapType != eapServerType) {

   651 

   652         qDebug("EapQtConfigInterfacePrivate - getEapTypeIf deletes previous instance");

   653 

   654         // delete previous instance

   655         mEapTypeIf.reset(NULL);

   656         mCurrentServerEapType = eapServerType;

   657 

   658         qDebug("EapQtConfigInterfacePrivate - getEapTypeIf calls CEapType::NewL()");

   659 

   660         // trap all leaves

   661         CEapType* tmp = NULL;

   662         TRAP(err, tmp = CEapType::NewL(mEapBearer, mEapDbIndex, mCurrentServerEapType));

   663         if (err != KErrNone) {

   664             qDebug(

   665                 "ERROR: EapQtConfigInterfacePrivate - getEapTypeIf CEapType::NewL failed with error: %d",

   666                 err);

   667             mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   668         }

   669         mEapTypeIf.reset(tmp);

   670     }

   671 

   672     // always clear the tunnelling type state just in case some earlier call has set it

   673     if (!mEapTypeIf.isNull()) {

   674         mEapTypeIf->SetTunnelingType(*EapExpandedTypeNone.GetType());

   675     }

   676 

   677 }

   678 

   679 // in config:

   680 // if OuterType is defined, the configuration for pluginHandle is set inside this OuterType

   681 // if OuterType is not defined, pluginHandle is for an outer type

   682 // if InnerType is defined, the defined inner types in config are activated for pluginHandle

   683 // if InnerType is not defined, the pluginHandle does not activate any inner type (or they do not exist)

   684 bool EapQtConfigInterfacePrivate::saveConfiguration(const EapQtPluginHandle &pluginHandle,

   685     const EapQtConfig &config)

   686 {

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

   688 

   689     checkInstanceThrowing();

   690 

   691     if (!mEapDbIndexValid) {

   692         qDebug() << "ERROR: Database reference not valid, call setConfigurationReference first!";

   693         return false;

   694     }

   695 

   696     // set tunneling type & check if the requested EAP is supported

   697     // if we are configuring outer type, OuterType == QVariant::Invalid or

   698     // EapQtPluginHandle::PluginUndefined

   699 

   700     EapQtPluginHandle tmpOuterHandle;

   701     QVariant varValue = config.value(EapQtConfig::OuterType);

   702     if (varValue != QVariant::Invalid && !(varValue.value<EapQtPluginHandle> () == EapQtPluginHandle::PluginUndefined)) {

   703         tmpOuterHandle = varValue.value<EapQtPluginHandle> ();

   704         // check if supported

   705         if(!isSupportedInnerType(tmpOuterHandle, pluginHandle)) {

   706             qDebug("ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - not supported outer/inner type combination");

   707             return false;

   708         }

   709     }

   710     else {

   711         tmpOuterHandle = EapQtPluginHandle::PluginUndefined;

   712         // check if supported

   713         if(!isSupportedOuterType(pluginHandle)) {

   714             qDebug("ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - not supported outer type");

   715             return false;

   716         }

   717     }

   718 

   719     getEapTypeIf(pluginHandle);

   720     if (mEapTypeIf.isNull()) {

   721         qDebug("ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - getEapTypeIf failed");

   722         return false;

   723     }

   724 

   725     TEapExpandedType tmpOuterEap;

   726     tmpOuterEap.SetValue(tmpOuterHandle.type().eapExpandedData().data(),

   727         tmpOuterHandle.type().eapExpandedData().length());

   728 

   729     qDebug() << "EapQtConfigInterfacePrivate::saveConfiguration() - sets tunnelling type to: "

   730         << tmpOuterHandle.type().eapExpandedData().toHex();

   731 

   732     mEapTypeIf->SetTunnelingType(tmpOuterEap);

   733 

   734     // set EAP type here

   735     QByteArray eapType = pluginHandle.type().eapExpandedData();

   736 

   737     // copy config to EAP settings,

   738     // no need to check if this is successful,

   739     // SetConfigurationL call will handle errors

   740     EAPSettings eapSettings;

   741     (void) eapSettings.iEAPExpandedType.SetValue(eapType.data(), eapType.length());

   742 

   743     // copy the rest of the settings in the function

   744     copyToEapSettings(config, eapSettings);

   745     // store settings

   746     TRAPD(err, mEapTypeIf->SetConfigurationL(eapSettings));

   747     if (err != KErrNone) {

   748         qDebug("ERROR: EapQtConfigInterfacePrivate - saveConfiguration: SetConfigurationL failed");

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

   750         mEapTypeIf.reset(NULL);

   751         mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   752         return false;

   753     }

   754 

   755     return true;

   756 }

   757 

   758 // config must be empty when calling

   759 bool EapQtConfigInterfacePrivate::readConfiguration(const EapQtPluginHandle &outerHandle,

   760     const EapQtPluginHandle &pluginHandle, EapQtConfig &config)

   761 {

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

   763 

   764     // clear input

   765     config.clear();

   766 

   767     checkInstanceThrowing();

   768 

   769     if (!mEapDbIndexValid) {

   770         qDebug() << "ERROR: Database reference not valid, call setConfigurationReference first!";

   771         return false;

   772     }

   773 

   774     // check EAP type support

   775     if(!(outerHandle == EapQtPluginHandle::PluginUndefined)) {

   776         if(!isSupportedInnerType(outerHandle, pluginHandle)) {

   777             qDebug("ERROR: EapQtConfigInterfacePrivate::readConfiguration() - not supported outer/inner type combination");

   778             return false;

   779         }

   780     } else {

   781         if(!isSupportedOuterType(pluginHandle)) {

   782             qDebug("ERROR: EapQtConfigInterfacePrivate::readConfiguration() - not supported outer type");

   783             return false;

   784         }

   785     }

   786 

   787     getEapTypeIf(pluginHandle);

   788     if (mEapTypeIf.isNull()) {

   789         qDebug("ERROR: EapQtConfigInterfacePrivate::readConfiguration - getEapTypeIf failed");

   790         return false;

   791     }

   792 

   793     // set tunneling type

   794     // if we are configuring outer type, outerHandle == EapQtPluginHandle::PluginUndefined

   795     // and calling SetTunnelingType is also ok

   796     TEapExpandedType tmpEap;

   797     tmpEap.SetValue(outerHandle.type().eapExpandedData().data(),

   798         outerHandle.type().eapExpandedData().length());

   799 

   800     qDebug() << "EapQtConfigInterfacePrivate::readConfiguration - sets tunnelling type to: "

   801         << outerHandle.type().eapExpandedData().toHex();

   802 

   803     mEapTypeIf->SetTunnelingType(tmpEap);

   804 

   805     // always set OuterType,

   806     // set to EapQtPluginHandle::PluginUndefined if no outer type specified

   807     config.setValue(EapQtConfig::OuterType, qVariantFromValue(outerHandle));

   808 

   809     qDebug("EapQtConfigInterfacePrivate::readConfiguration - calls GetConfigurationL()");

   810 

   811     // trap all leaves

   812     EAPSettings eapSettings;

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

   814 

   815     // check if failed or something strange happened (incorrect EAP type settings received)  

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

   817         qDebug("ERROR: EapQtConfigInterfacePrivate - readConfiguration: GetConfigurationL failed");

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

   819         mEapTypeIf.reset(NULL);

   820         mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   821         // nothing to be set to config

   822         return false;

   823     }

   824     copyFromEapSettings(eapSettings, config);

   825     return true;

   826 }

   827 

   828 bool EapQtConfigInterfacePrivate::convertToBool(TBool value)

   829 {

   830     return (value != EFalse ? true : false);

   831 }

   832 

   833 TBool EapQtConfigInterfacePrivate::convertToTbool(bool value)

   834 {

   835     return (value ? ETrue : EFalse);

   836 }

   837 

   838 void EapQtConfigInterfacePrivate::copyToEapSettings(const EapQtConfig &config, EAPSettings &eapSettings)

   839 {

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

   841 

   842     int ind = 0;

   843 

   844     QVariant varValue = config.value(EapQtConfig::UsernameAutomatic);

   845     if (varValue.type() == QVariant::Bool) {

   846         eapSettings.iUseAutomaticUsernamePresent = ETrue;

   847         eapSettings.iUseAutomaticUsername = convertToTbool(varValue.toBool());

   848         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings UsernameAutomatic: "

   849             << varValue.toBool();

   850     }

   851 

   852     varValue = config.value(EapQtConfig::AuthorityCertificateAutomatic);

   853     if (varValue.type() == QVariant::Bool) {

   854         eapSettings.iUseAutomaticCACertificatePresent = ETrue;

   855         eapSettings.iUseAutomaticCACertificate = convertToTbool(varValue.toBool());

   856         qDebug()

   857             << "EapQtConfigInterfacePrivate - copyToEapSettings AuthorityCertificateAutomatic: "

   858             << varValue.toBool();

   859     }

   860 

   861     varValue = config.value(EapQtConfig::Username);

   862     // do not copy if too large string

   863     if (varValue.type() == QVariant::String && varValue.toString().count() <= StringMaxLength) {

   864         // QString::utf16 returns a null terminated string

   865         eapSettings.iUsername.Copy(varValue.toString().utf16());

   866         eapSettings.iUsernamePresent = ETrue;

   867         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings Username: "

   868             << varValue.toString();

   869     }

   870 

   871     varValue = config.value(EapQtConfig::PasswordPrompt);

   872     if (varValue.type() == QVariant::Bool) {

   873         eapSettings.iShowPassWordPromptPresent = ETrue;

   874         eapSettings.iShowPassWordPrompt = convertToTbool(varValue.toBool());

   875         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PasswordPrompt: "

   876             << varValue.toBool();

   877     }

   878 

   879     varValue = config.value(EapQtConfig::Password);

   880     // do not copy if too large string

   881     if (varValue.type() == QVariant::String && varValue.toString().count() <= StringMaxLength) {

   882         //QString::utf16 returns a null terminated string

   883         eapSettings.iPassword.Copy(varValue.toString().utf16());

   884         eapSettings.iPasswordPresent = ETrue;

   885         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings Password: "

   886             << varValue.toString();

   887     }

   888 

   889     varValue = config.value(EapQtConfig::PasswordClear);

   890     if (varValue.type() == QVariant::Bool) {

   891         eapSettings.iPasswordExistPresent = ETrue;

   892         eapSettings.iPasswordExist = convertToTbool(varValue.toBool());

   893         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PasswordClear: "

   894             << varValue.toBool();

   895     }

   896 

   897     varValue = config.value(EapQtConfig::RealmAutomatic);

   898     if (varValue.type() == QVariant::Bool) {

   899         eapSettings.iUseAutomaticRealmPresent = ETrue;

   900         eapSettings.iUseAutomaticRealm = convertToTbool(varValue.toBool());

   901         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings RealmAutomatic: "

   902             << varValue.toBool();

   903     }

   904 

   905     varValue = config.value(EapQtConfig::Realm);

   906     // do not copy if too large string

   907     if (varValue.type() == QVariant::String && varValue.toString().count() <= StringMaxLength) {

   908         // QString::utf16 returns a null terminated string

   909         eapSettings.iRealm.Copy(varValue.toString().utf16());

   910         eapSettings.iRealmPresent = ETrue;

   911         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings Realm: "

   912             << varValue.toString();

   913     }

   914 

   915     varValue = config.value(EapQtConfig::UsePseudonyms);

   916     if (varValue.type() == QVariant::Bool) {

   917         eapSettings.iUsePseudonymsPresent = ETrue;

   918         eapSettings.iUsePseudonyms = convertToTbool(varValue.toBool());

   919         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings UsePseudonyms: "

   920             << varValue.toBool();

   921     }

   922 

   923     varValue = config.value(EapQtConfig::VerifyServerRealm);

   924     if (varValue.type() == QVariant::Bool) {

   925         eapSettings.iVerifyServerRealmPresent = ETrue;

   926         eapSettings.iVerifyServerRealm = convertToTbool(varValue.toBool());

   927         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings VerifyServerRealm: "

   928             << varValue.toBool();

   929     }

   930 

   931     varValue = config.value(EapQtConfig::ClientAuthenticationRequired);

   932     if (varValue.type() == QVariant::Bool) {

   933         eapSettings.iRequireClientAuthenticationPresent = ETrue;

   934         eapSettings.iRequireClientAuthentication = convertToTbool(varValue.toBool());

   935         qDebug()

   936             << "EapQtConfigInterfacePrivate - copyToEapSettings ClientAuthenticationRequired: "

   937             << varValue.toBool();

   938     }

   939 

   940     varValue = config.value(EapQtConfig::SessionValidityTime);

   941     if (varValue.type() == QVariant::UInt) {

   942         eapSettings.iSessionValidityTimePresent = ETrue;

   943         eapSettings.iSessionValidityTime = varValue.toUInt();

   944         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings SessionValidityTime: "

   945             << varValue.toUInt();

   946     }

   947 

   948     varValue = config.value(EapQtConfig::PeapVersion0Allowed);

   949     if (varValue.type() == QVariant::Bool) {

   950         eapSettings.iPEAPVersionsPresent = ETrue;

   951         eapSettings.iPEAPv0Allowed = convertToTbool(varValue.toBool());

   952         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PeapVersion0Allowed: "

   953             << varValue.toBool();

   954     } else {

   955         // in any other case disable PEAP version;

   956         // no need to set eapSettings.iPEAPVersionsPresent,

   957         // it will be set if one of the other PEAP versions is enabled,

   958         // otherwise this setting is redundant and can be ignored

   959         eapSettings.iPEAPv0Allowed = EFalse;

   960     }

   961 

   962     varValue = config.value(EapQtConfig::PeapVersion1Allowed);

   963     if (varValue.type() == QVariant::Bool) {

   964         eapSettings.iPEAPVersionsPresent = ETrue;

   965         eapSettings.iPEAPv1Allowed = convertToTbool(varValue.toBool());

   966         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PeapVersion1Allowed: "

   967             << varValue.toBool();

   968     } else {

   969         // in any other case disable PEAP version;

   970         // no need to set eapSettings.iPEAPVersionsPresent,

   971         // it will be set if one of the other PEAP versions is enabled,

   972         // otherwise this setting is redundant and can be ignored

   973         eapSettings.iPEAPv1Allowed = EFalse;

   974     }

   975 

   976     varValue = config.value(EapQtConfig::PeapVersion2Allowed);

   977     if (varValue.type() == QVariant::Bool) {

   978         eapSettings.iPEAPVersionsPresent = ETrue;

   979         eapSettings.iPEAPv2Allowed = convertToTbool(varValue.toBool());

   980         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PeapVersion2Allowed: "

   981             << varValue.toBool();

   982     } else {

   983         // in any other case disable PEAP version;

   984         // no need to set eapSettings.iPEAPVersionsPresent,

   985         // it will be set if one of the other PEAP versions is enabled,

   986         // otherwise this setting is redundant and can be ignored

   987         eapSettings.iPEAPv2Allowed = EFalse;

   988     }

   989 

   990     varValue = config.value(EapQtConfig::ProvisioningModeAuthenticated);

   991     if (varValue.type() == QVariant::Bool) {

   992         eapSettings.iAuthProvModeAllowedPresent = ETrue;

   993         eapSettings.iAuthProvModeAllowed = convertToTbool(varValue.toBool());

   994         qDebug()

   995             << "EapQtConfigInterfacePrivate - copyToEapSettings ProvisioningModeAuthenticated: "

   996             << varValue.toBool();

   997     }

   998 

   999     varValue = config.value(EapQtConfig::ProvisioningModeUnauthenticated);

  1000     if (varValue.type() == QVariant::Bool) {

  1001         eapSettings.iUnauthProvModeAllowedPresent = ETrue;

  1002         eapSettings.iUnauthProvModeAllowed = convertToTbool(varValue.toBool());

  1003         qDebug()

  1004             << "EapQtConfigInterfacePrivate - copyToEapSettings ProvisioningModeUnauthenticated: "

  1005             << varValue.toBool();

  1006     }

  1007 

  1008     varValue = config.value(EapQtConfig::PACGroupReference);

  1009     // do not copy if too large string

  1010     if (varValue.type() == QVariant::String && varValue.toString().count() <= StringMaxLength) {

  1011         eapSettings.iPACGroupReference.Copy(varValue.toString().utf16());

  1012         eapSettings.iPACGroupReferencePresent = ETrue;

  1013         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings PACGroupReference: "

  1014             << varValue.toString();

  1015     }

  1016 

  1017     varValue = config.value(EapQtConfig::WarnADHPNoPAC);

  1018     if (varValue.type() == QVariant::Bool) {

  1019         eapSettings.iWarnADHPNoPACPresent = ETrue;

  1020         eapSettings.iWarnADHPNoPAC = convertToTbool(varValue.toBool());

  1021         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings WarnADHPNoPAC: "

  1022             << varValue.toBool();

  1023     }

  1024 

  1025     varValue = config.value(EapQtConfig::WarnADHPNoMatchingPAC);

  1026     if (varValue.type() == QVariant::Bool) {

  1027         eapSettings.iWarnADHPNoMatchingPACPresent = ETrue;

  1028         eapSettings.iWarnADHPNoMatchingPAC = convertToTbool(varValue.toBool());

  1029         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings WarnADHPNoMatchingPAC: "

  1030             << varValue.toBool();

  1031     }

  1032 

  1033     varValue = config.value(EapQtConfig::WarnNotDefaultServer);

  1034     if (varValue.type() == QVariant::Bool) {

  1035         eapSettings.iWarnNotDefaultServerPresent = ETrue;

  1036         eapSettings.iWarnNotDefaultServer = convertToTbool(varValue.toBool());

  1037         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings WarnNotDefaultServer: "

  1038             << varValue.toBool();

  1039     }

  1040 

  1041     varValue = config.value(EapQtConfig::UseIdentityPrivacy);

  1042     if (varValue.type() == QVariant::Bool) {

  1043         eapSettings.iUseIdentityPrivacyPresent = ETrue;

  1044         eapSettings.iUseIdentityPrivacy = convertToTbool(varValue.toBool());

  1045         qDebug() << "EapQtConfigInterfacePrivate - copyToEapSettings UseIdentityPrivacy: "

  1046             << varValue.toBool();

  1047     }

  1048 

  1049     varValue = config.value(EapQtConfig::InnerType);

  1050     if (varValue.type() == QVariant::List) {

  1051 

  1052         // not need to set disable inner types

  1053         // EAP server takes care of them internally

  1054 

  1055         qDebug() << "EapQtConfigInterfacePrivate::copyToEapSettings() - InnerType present";

  1056 

  1057         QList<QVariant> varList = varValue.toList();

  1058         TEapExpandedType tmpEap;

  1059         EapQtPluginHandle tmpHandle;

  1060 

  1061         for (ind = 0; ind < varList.count(); ind++) {

  1062             if (varList[ind].canConvert<EapQtPluginHandle> ()) {

  1063                 // set to true only if at least one item is ok

  1064                 eapSettings.iEnabledEncapsulatedEAPExpandedTypesPresent = ETrue;

  1065 

  1066                 tmpHandle = varList[ind].value<EapQtPluginHandle> ();

  1067                 tmpEap.SetValue(tmpHandle.type().eapExpandedData().data(),

  1068                     tmpHandle.type().eapExpandedData().length());

  1069                 eapSettings.iEnabledEncapsulatedEAPExpandedTypes.Append(tmpEap);

  1070 

  1071                 qDebug()

  1072                     << "EapQtConfigInterfacePrivate::copyToEapSettings() - Added to InnerType: "

  1073                     << tmpHandle.type().eapExpandedData().toHex();

  1074             }

  1075         }

  1076     }

  1077 

  1078     varValue = config.value(EapQtConfig::CipherSuites);

  1079     if (varValue.type() == QVariant::List) {

  1080 

  1081         qDebug() << "EapQtConfigInterfacePrivate::copyToEapSettings() - CipherSuites present";

  1082         QList<QVariant> varCiphers = varValue.toList();

  1083 

  1084         // clears the ciphersuite configuration if the provided list is empty

  1085         eapSettings.iCipherSuitesPresent = ETrue;

  1086 

  1087         for (ind = 0; ind < varCiphers.count(); ind++) {

  1088             // check that the item is of correct type (int also accepted to not be too strict)

  1089             if (varCiphers[ind].type() == QVariant::UInt || varCiphers[ind].type() == QVariant::Int) {

  1090                 eapSettings.iCipherSuites.Append(varCiphers[ind].toUInt());

  1091                 qDebug(

  1092                     "EapQtConfigInterfacePrivate::copyToEapSettings() - CipherSuites at %d: 0x%08x",

  1093                     ind, varCiphers[ind].toUInt());

  1094             }

  1095         }

  1096     }

  1097 

  1098     // set always to true to support clearing previously configured CA/user certificates

  1099     // if the EAP method in question does not use certificates,

  1100     // EAP server will ignore the setting;

  1101     // CA/user certificates get cleared if EapQtConfig::Authority/UserCertificate is QVariant::Invalid or

  1102     // the provided lists are empty

  1103     eapSettings.iCertificatesPresent = ETrue;

  1104 

  1105     varValue = config.value(EapQtConfig::AuthorityCertificate);

  1106     if (varValue.type() == QVariant::List) {

  1107 

  1108         qDebug()

  1109             << "EapQtConfigInterfacePrivate::copyToEapSettings() - AuthorityCertificate present";

  1110 

  1111         QList<QVariant> varCerts = varValue.toList();

  1112         for (ind = 0; ind < varCerts.count(); ind++) {

  1113             // check that the item is of correct type

  1114             if (varCerts[ind].canConvert<EapQtCertificateInfo> ()) {

  1115                 appendCertificateInfo(true, varCerts[ind].value<EapQtCertificateInfo> (),

  1116                     &(eapSettings.iCertificates));

  1117                 qDebug()

  1118                     << "EapQtConfigInterfacePrivate::copyToEapSettings() - AuthorityCertificate appended";

  1119             }

  1120         }

  1121     }

  1122 

  1123     varValue = config.value(EapQtConfig::UserCertificate);

  1124     if (varValue.type() == QVariant::List) {

  1125 

  1126         qDebug() << "EapQtConfigInterfacePrivate::copyToEapSettings() - UserCertificate present";

  1127 

  1128         QList<QVariant> varCerts = varValue.toList();

  1129         for (ind = 0; ind < varCerts.count(); ind++) {

  1130             // check that the item is of correct type

  1131             if (varCerts[ind].canConvert<EapQtCertificateInfo> ()) {

  1132                 appendCertificateInfo(false, varCerts[ind].value<EapQtCertificateInfo> (),

  1133                     &(eapSettings.iCertificates));