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 the License "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: 39 %

    21  */

    22 

    23 #include <QDir>

    24 #include <QList>

    25 #include <QVariant>

    26 #include <QPluginLoader>

    27 #include <HbTranslator>

    28 #include <QLocale>

    29 #include <QCoreApplication>

    30 #include <QDebug>

    31 

    32 #include <cmmanager.h>

    33 #include <cmpluginwlandef.h>

    34 #include <EapGeneralSettings.h>

    35 

    36 #include <eapqtplugininfo.h>

    37 #include <eapqtcertificateinfo.h>

    38 

    39 #include "cpeapplugininterface.h"

    40 #include "eapqtconfiginterface_p.h"

    41 

    42 // validators

    43 #include "eapqtvalidatorpassword.h"

    44 #include "eapqtvalidatorusername.h"

    45 #include "eapqtvalidatorrealm.h"

    46 

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

    48 static const QString eapTranslationFile("cpeapuiplugins");

    49 

    50 EapQtConfigInterfacePrivate::EapQtConfigInterfacePrivate() :

    51   mValidatorInstance(true),

    52   mLastOuterHandle(EapQtPluginHandle::PluginUndefined),

    53   mTranslator(NULL),

    54   mEapGsIf(NULL), 

    55   mEapTypeIf(NULL),

    56   mIapId(0),

    57   mEapBearer(ELan),

    58   mEapDbIndex(EapQtConfigInterface::IapIdUndefined),

    59   mEapDbIndexValid(false)

    60 {

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

    62 

    63 }

    64 

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

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

    67   mValidatorInstance(false),

    68   mLastOuterHandle(EapQtPluginHandle::PluginUndefined),

    69   mTranslator(NULL), 

    70   mEapGsIf(NULL), 

    71   mEapTypeIf(NULL),

    72   mIapId(iapId),

    73   mEapBearer(ELan),

    74   mEapDbIndex(EapQtConfigInterface::IapIdUndefined),

    75   mEapDbIndexValid(false)

    76 {

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

    78 

    79 

    80     switch (bearerType) {

    81     case EapQtConfigInterface::EapBearerTypeVpn:

    82         mEapBearer = EVpn;

    83         break;

    84     default:

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

    86         mEapBearer = ELan;

    87     }

    88 

    89     if (!setEapDbIndex(iapId)) {

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

    91             mEapBearer, iapId);

    92         shutdown();

    93         // throw an exception

    94         qt_symbian_throwIfError(KErrNotFound);

    95     }

    96 

    97     // load plugins after everything else is ok

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

    99     loadPlugins();

   100 

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

   102 }

   103 

   104 EapQtConfigInterfacePrivate::~EapQtConfigInterfacePrivate()

   105 {

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

   107 

   108     shutdown();

   109 }

   110 

   111 void EapQtConfigInterfacePrivate::shutdown()

   112 {

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

   114 

   115 

   116     mOuterEapsOn.Close();

   117     mOuterEapsOff.Close();

   118 

   119     // cleanup Ecom

   120     REComSession::FinalClose();

   121 

   122     // mTranslator gets deleted automatically (QScopedPointer)

   123     // mEapTypeIf gets deleted automatically (QScopedPointer)

   124     // mEapGsIf gets deleted automatically (QScopedPointer)

   125 }

   126 

   127 bool EapQtConfigInterfacePrivate::setConfigurationReference(const int iapId)

   128 {

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

   130 

   131     checkInstanceThrowing();

   132     return setEapDbIndex(iapId);

   133 }

   134 

   135 bool EapQtConfigInterfacePrivate::setEapDbIndex(const int iapId)

   136 {

   137 

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

   139 

   140 

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

   142     // not change and mEapGsIf exists already

   143 

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

   145     // different than WLAN service ID

   146 

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

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

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

   150         qDebug(

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

   152         return true;

   153     }

   154 

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

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

   157         qDebug(

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

   159         return true;

   160     }

   161 

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

   163     TInt previousEapDbIndex = mEapDbIndex;

   164     bool wlanIndexOk = true;

   165 

   166     // allow accessing certain methods with negative iapId

   167     if (iapId < 0) {

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

   169         mEapDbIndex = 0;

   170         mEapDbIndexValid = false;

   171     }

   172     // for real usage iapId must not be negative

   173     else {

   174         // for VPN

   175         mIapId = iapId;

   176         mEapDbIndex = iapId;

   177         mEapDbIndexValid = true;

   178 

   179         // for WLAN

   180         if (mEapBearer == ELan) {

   181             // get WLAN service ID as the reference

   182             mEapDbIndexValid = setEapWlanDbIndex(iapId);

   183             wlanIndexOk = mEapDbIndexValid;

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

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

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

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

   188                 return true;

   189             }

   190 

   191         }

   192     }

   193 

   194     // delete possibly existing instances

   195     mEapGsIf.reset(NULL);

   196     mEapTypeIf.reset(NULL);

   197 

   198     mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   199     mLastOuterHandle = EapQtPluginHandle::PluginUndefined;

   200 

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

   202         // setEapWlanDbIndex was called and failed

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

   204         return false;

   205     }

   206 

   207     qDebug(

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

   209         mEapBearer, mEapDbIndex);

   210 

   211     // load EAP general settings interface

   212     CEapGeneralSettings* tmp = NULL;

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

   214     if (err != KErrNone) {

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

   216         mEapDbIndexValid = false;

   217         return false;

   218     }

   219 

   220     // set to the created instance

   221     mEapGsIf.reset(tmp);

   222 

   223     return true;

   224 }

   225 

   226 bool EapQtConfigInterfacePrivate::setEapWlanDbIndex(const int iapId)

   227 {

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

   229 

   230 

   231     RCmManager cmm;

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

   233     if (err != KErrNone) {

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

   235             mEapBearer, iapId);

   236         mEapDbIndex = EapQtConfigInterface::IapIdUndefined;

   237         mIapId = 0;

   238         return false;

   239     }

   240 

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

   242     if (err != KErrNone) {

   243         qDebug(

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

   245             mEapBearer, iapId);

   246         cmm.Close();

   247         mEapDbIndex = EapQtConfigInterface::IapIdUndefined;

   248         mIapId = 0;

   249         return false;

   250     }

   251 

   252     cmm.Close();

   253 

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

   255         mEapDbIndex);

   256 

   257     return true;

   258 }

   259 

   260 void EapQtConfigInterfacePrivate::checkInstanceThrowing() const

   261 {

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

   263         << mValidatorInstance;

   264 

   265     if (mValidatorInstance) {

   266         qDebug(

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

   268         qt_symbian_throwIfError(KErrNotSupported);

   269     }

   270 }

   271 

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

   273     QList<QByteArray>* const eapList)

   274 {

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

   276 

   277 

   278     Q_ASSERT(eapTypes);

   279     Q_ASSERT(eapList);

   280 

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

   282 

   283     QByteArray tmpEap;

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

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

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

   287         eapList->append(tmpEap);

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

   289         tmpEap.clear();

   290     }

   291 }

   292 

   293 QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedOuterTypes()

   294 {

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

   296 

   297 

   298     checkInstanceThrowing();

   299 

   300     if (mEapGsIf.isNull()) {

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

   302         mOuterEapsOn.Reset();

   303         mOuterEapsOff.Reset();

   304         // return empty list

   305         mSupportedOuterTypes.clear();

   306         return mSupportedOuterTypes;

   307     }

   308 

   309     // get outer EAPs from EAP server,

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

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

   312     // other methods

   313 

   314     mOuterEapsOn.Reset();

   315     mOuterEapsOff.Reset();

   316 

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

   318 

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

   320     if (err != KErrNone) {

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

   322         mOuterEapsOn.Reset();

   323         mOuterEapsOff.Reset();

   324         // return empty list

   325         mSupportedOuterTypes.clear();

   326         return mSupportedOuterTypes;

   327     }

   328 

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

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

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

   332         qDebug(

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

   334         return mSupportedOuterTypes;

   335     }

   336 

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

   338 

   339     // copy response to qlist for easier comparison

   340     QList<QByteArray> outerEaps;

   341 

   342     appendEapTypes(&mOuterEapsOn, &outerEaps);

   343     appendEapTypes(&mOuterEapsOff, &outerEaps);

   344 

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

   346         outerEaps.count());

   347 

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

   349         mPluginInfos.count());

   350 

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

   352     QByteArray tmpEap;

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

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

   355         if (outerEaps.contains(tmpEap)) {

   356             mSupportedOuterTypes.append(mPluginInfos[ind]);

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

   358                 << tmpEap.toHex();

   359         }

   360     }

   361 

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

   363         mSupportedOuterTypes.count());

   364 

   365     return mSupportedOuterTypes;

   366 }

   367 

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

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

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

   371 {

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

   373 

   374     bool ret = false;

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

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

   377         pluginIndex = ind;

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

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

   380             ret = true;

   381             break;

   382         }

   383     }

   384     return ret;

   385 }

   386 

   387 QList<EapQtPluginInfo> EapQtConfigInterfacePrivate::supportedInnerTypes(

   388     const EapQtPluginHandle& outer)

   389 {

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

   391 

   392 

   393     checkInstanceThrowing();

   394 

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

   396     if (mLastOuterHandle == outer) {

   397         return mSupportedInnerTypes;

   398     }

   399 

   400     // clear previous query result

   401     mSupportedInnerTypes.clear();

   402     mLastOuterHandle = EapQtPluginHandle::PluginUndefined;

   403 

   404     qDebug()

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

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

   407 

   408     // check if the queried outer EAP is supported

   409     if (!isSupportedOuterType(outer)) {

   410         qDebug()

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

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

   413         // return empty list

   414         return mSupportedInnerTypes;

   415     }

   416 

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

   418 

   419     // get outer EAP settings interface

   420     getEapTypeIf(outer);

   421     if (mEapTypeIf.isNull()) {

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

   423         // return empty list

   424         return mSupportedInnerTypes;

   425     }

   426 

   427     // get outer EAP settings

   428     EAPSettings eapSettings;

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

   430     // getEapTypeIf has set mCurrentServerEapType correctly for comparison

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

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

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

   434         mEapTypeIf.reset(NULL);

   435         // return empty list

   436         return mSupportedInnerTypes;

   437     }

   438 

   439     // store inner EAPs supported by EAP server

   440     QList<QByteArray> innerEaps;

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

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

   443 

   444     int pluginIndex = 0;

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

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

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

   448             mSupportedInnerTypes.append(mPluginInfos[pluginIndex]);

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

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

   451         }

   452     }

   453 

   454     mLastOuterHandle = outer;

   455 

   456     return mSupportedInnerTypes;

   457 }

   458 

   459 void EapQtConfigInterfacePrivate::copyCertificateInfo(

   460     const RPointerArray<EapCertificateEntry>* const certEntries,

   461     QList<EapQtCertificateInfo>* const certInfos)

   462 {

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

   464 

   465 

   466     Q_ASSERT(certEntries);

   467     Q_ASSERT(certInfos);

   468 

   469     certInfos->clear();

   470 

   471     EapQtCertificateInfo cert;

   472     TKeyIdentifier subjectKeyId;

   473     const TDes* text = 0;

   474     int ind = 0;

   475 

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

   477 

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

   479 

   480         if ((*certEntries)[ind]->GetSubjectNamePresent() != EFalse) {

   481 

   482             text = (*certEntries)[ind]->GetSubjectName();

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

   484                 text->Length()));

   485 

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

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

   488         }

   489         if ((*certEntries)[ind]->GetIssuerNamePresent() != EFalse) {

   490 

   491             text = (*certEntries)[ind]->GetIssuerName();

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

   493                 text->Length()));

   494 

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

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

   497         }

   498         if ((*certEntries)[ind]->GetSerialNumberPresent() != EFalse) {

   499 

   500             text = (*certEntries)[ind]->GetSerialNumber();

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

   502                 text->Length()));

   503 

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

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

   506         }

   507         if ((*certEntries)[ind]->GetSubjectKeyIdPresent() != EFalse) {

   508 

   509             subjectKeyId = (*certEntries)[ind]->GetSubjectKeyId();

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

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

   512 

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

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

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

   516         }

   517         if ((*certEntries)[ind]->GetThumbprintPresent() != EFalse) {

   518 

   519             text = (*certEntries)[ind]->GetThumbprint();

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

   521                 text->Length()));

   522 

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

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

   525         }

   526         if ((*certEntries)[ind]->GetLabelPresent() != EFalse) {

   527 

   528             text = (*certEntries)[ind]->GetLabel();

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

   530                 text->Length()));

   531 

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

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

   534         }

   535 

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

   537 

   538         certInfos->append(cert);

   539 

   540     }

   541 }

   542 

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

   544     QList<EapQtCertificateInfo>* const clientInfos)

   545 {

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

   547 

   548 

   549     Q_ASSERT(caInfos != NULL || clientInfos != NULL || !mEapGsIf.isNull());

   550 

   551     TInt err(KErrNone);

   552     RPointerArray<EapCertificateEntry> clientCerts;

   553     RPointerArray<EapCertificateEntry> caCerts;

   554 

   555     // lists are always queried again as the user might have installed new certificates

   556     // during the life time of the object

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

   558     if (err != KErrNone) {

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

   560         caCerts.ResetAndDestroy();

   561         clientCerts.ResetAndDestroy();

   562         return false;

   563     }

   564 

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

   566 

   567     if (caInfos != NULL) {

   568         copyCertificateInfo(&caCerts, caInfos);

   569     }

   570     if (clientInfos != NULL) {

   571         copyCertificateInfo(&clientCerts, clientInfos);

   572     }

   573 

   574     caCerts.ResetAndDestroy();

   575     clientCerts.ResetAndDestroy();

   576     return true;

   577 }

   578 

   579 QList<EapQtCertificateInfo> EapQtConfigInterfacePrivate::certificateAuthorityCertificates()

   580 {

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

   582 

   583 

   584     checkInstanceThrowing();

   585 

   586     QList<EapQtCertificateInfo> list;

   587     if (!fetchCertificates(&list, 0)) {

   588         // query failed

   589         list.clear();

   590     }

   591     return list;

   592 }

   593 

   594 QList<EapQtCertificateInfo> EapQtConfigInterfacePrivate::userCertificates()

   595 {

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

   597 

   598 

   599     checkInstanceThrowing();

   600 

   601     QList<EapQtCertificateInfo> list;

   602     if (!fetchCertificates(0, &list)) {

   603         // query failed

   604         list.clear();

   605     }

   606     return list;

   607 }

   608 

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

   610 {

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

   612 

   613 

   614     // dig up the EAP type in TEapExpandedType format

   615     TEapExpandedType eapServerType;

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

   617     TInt err(KErrNone);

   618 

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

   620 

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

   622     // CEapType::NewL call will handle errors

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

   624 

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

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

   627 

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

   629 

   630         // delete previous instance

   631         mEapTypeIf.reset(NULL);

   632         mCurrentServerEapType = eapServerType;

   633 

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

   635 

   636         // trap all leaves

   637         CEapType* tmp = NULL;

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

   639         if (err != KErrNone) {

   640             qDebug(

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

   642                 err);

   643             mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   644         }

   645         mEapTypeIf.reset(tmp);

   646     }

   647 

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

   649     if (!mEapTypeIf.isNull()) {

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

   651     }

   652 

   653 }

   654 

   655 // in config:

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

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

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

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

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

   661     EapQtConfig& config)

   662 {

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

   664 

   665 

   666     checkInstanceThrowing();

   667 

   668     if (!mEapDbIndexValid) {

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

   670         return false;

   671     }

   672 

   673     // only check if EAP ui is supported here,

   674     // getEapTypeIf checks the EAP server support

   675     int dummy = 0;

   676     if (!isUiSupported(pluginHandle.type().eapExpandedData(), dummy)) {

   677         qDebug(

   678             "ERROR: EapQtConfigInterfacePrivate::saveConfiguration() - UI not supported for the requested EAP");

   679         return false;

   680     }

   681 

   682     getEapTypeIf(pluginHandle);

   683     if (mEapTypeIf.isNull()) {

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

   685         return false;

   686     }

   687 

   688     // set tunneling type

   689     // if we are configuring outer type, OuterType == Invalid or EapQtPluginHandle::PluginUndefined

   690 

   691     EapQtPluginHandle tmpOuterHandle;

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

   693     if (varValue != QVariant::Invalid) {

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

   695     }

   696     else {

   697         tmpOuterHandle = EapQtPluginHandle::PluginUndefined;

   698     }

   699 

   700     TEapExpandedType tmpOuterEap;

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

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

   703 

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

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

   706 

   707     mEapTypeIf->SetTunnelingType(tmpOuterEap);

   708 

   709     // set EAP type here

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

   711 

   712     // copy config to EAP settings,

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

   714     // SetConfigurationL call will handle errors

   715     EAPSettings eapSettings;

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

   717 

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

   719     copyToEapSettings(config, eapSettings);

   720     // store settings

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

   722     if (err != KErrNone) {

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

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

   725         mEapTypeIf.reset(NULL);

   726         mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   727         return false;

   728     }

   729 

   730     return true;

   731 }

   732 

   733 // config must be empty when calling

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

   735     const EapQtPluginHandle& pluginHandle, EapQtConfig& config)

   736 {

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

   738 

   739 

   740     // clear input

   741     config.clear();

   742 

   743     checkInstanceThrowing();

   744 

   745     if (!mEapDbIndexValid) {

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

   747         return false;

   748     }

   749 

   750     // only check if UI is supported for pluginHandle here,

   751     // getEapTypeIf checks the EAP server support

   752     int dummy = 0;

   753     if (!isUiSupported(pluginHandle.type().eapExpandedData(), dummy)) {

   754         qDebug(

   755             "ERROR: EapQtConfigInterfacePrivate::readConfiguration - UI not supported for the requested EAP");

   756         return false;

   757     }

   758 

   759     getEapTypeIf(pluginHandle);

   760     if (mEapTypeIf.isNull()) {

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

   762         return false;

   763     }

   764 

   765     // set tunneling type

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

   767     // and calling SetTunnelingType is also ok

   768     TEapExpandedType tmpEap;

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

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

   771 

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

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

   774 

   775     mEapTypeIf->SetTunnelingType(tmpEap);

   776 

   777     // always set OuterType,

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

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

   780 

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

   782 

   783     // trap all leaves

   784     EAPSettings eapSettings;

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

   786 

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

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

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

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

   791         mEapTypeIf.reset(NULL);

   792         mCurrentServerEapType = *EapExpandedTypeNone.GetType();

   793         // nothing to be set to config

   794         return false;

   795     }

   796     copyFromEapSettings(eapSettings, config);

   797     return true;

   798 }

   799 

   800 bool EapQtConfigInterfacePrivate::convertToBool(TBool value)

   801 {

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

   803 }

   804 

   805 TBool EapQtConfigInterfacePrivate::convertToTbool(bool value)

   806 {

   807     return (value ? ETrue : EFalse);

   808 }

   809 

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

   811 {

   812     // TODO:

   813     // - fix & add validation

   814     // - check if there are something missing still defined in EapSettings.h

   815     // - pac store parameters from eapqtconfig.h

   816 

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

   818 

   819 

   820     int ind = 0;

   821 

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

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

   824         eapSettings.iUseAutomaticUsernamePresent = ETrue;

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

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

   827             << varValue.toBool();

   828     }

   829 

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

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

   832         eapSettings.iUseAutomaticCACertificatePresent = ETrue;

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

   834         qDebug()

   835             << "EapQtConfigInterfacePrivate - copyToEapSettings AuthorityCertificateAutomatic: "

   836             << varValue.toBool();

   837     }

   838 

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

   840     // do not copy if too large string

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

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

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

   844         eapSettings.iUsernamePresent = ETrue;

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

   846             << varValue.toString();

   847     }

   848 

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

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

   851         eapSettings.iShowPassWordPromptPresent = ETrue;

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

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

   854             << varValue.toBool();

   855     }

   856 

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

   858     // do not copy if too large string

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

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

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

   862         eapSettings.iPasswordPresent = ETrue;

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

   864             << varValue.toString();

   865     }

   866 

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

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

   869         eapSettings.iPasswordExistPresent = ETrue;

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

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

   872             << varValue.toBool();

   873     }

   874 

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

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

   877         eapSettings.iUseAutomaticRealmPresent = ETrue;

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

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

   880             << varValue.toBool();

   881     }

   882 

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

   884     // do not copy if too large string

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

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

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

   888         eapSettings.iRealmPresent = ETrue;

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

   890             << varValue.toString();

   891     }

   892 

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

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

   895         eapSettings.iUsePseudonymsPresent = ETrue;

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

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

   898             << varValue.toBool();

   899     }

   900 

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

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

   903         eapSettings.iVerifyServerRealmPresent = ETrue;

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

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

   906             << varValue.toBool();

   907     }

   908 

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

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

   911         eapSettings.iRequireClientAuthenticationPresent = ETrue;

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

   913         qDebug()

   914             << "EapQtConfigInterfacePrivate - copyToEapSettings ClientAuthenticationRequired: "

   915             << varValue.toBool();

   916     }

   917 

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

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

   920         eapSettings.iSessionValidityTimePresent = ETrue;

   921         eapSettings.iSessionValidityTime = varValue.toUInt();

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

   923             << varValue.toUInt();

   924     }

   925 

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

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

   928         eapSettings.iPEAPVersionsPresent = ETrue;

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

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

   931             << varValue.toBool();

   932     }

   933 

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

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

   936         eapSettings.iPEAPVersionsPresent = ETrue;

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

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

   939             << varValue.toBool();

   940     }

   941 

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

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

   944         eapSettings.iPEAPVersionsPresent = ETrue;

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

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

   947             << varValue.toBool();

   948     }

   949 

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

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

   952         eapSettings.iAuthProvModeAllowedPresent = ETrue;

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

   954         qDebug()

   955             << "EapQtConfigInterfacePrivate - copyToEapSettings ProvisioningModeAuthenticated: "

   956             << varValue.toBool();

   957     }

   958 

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

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

   961         eapSettings.iUnauthProvModeAllowedPresent = ETrue;

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

   963         qDebug()

   964             << "EapQtConfigInterfacePrivate - copyToEapSettings ProvisioningModeUnauthenticated: "

   965             << varValue.toBool();

   966     }

   967 

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

   969     // do not copy if too large string

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

   971         // TODO: what is the format (ascii/unicode?) of iPACGroupReference?

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

   973             << varValue.toString();

   974     }

   975 

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

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

   978         eapSettings.iWarnADHPNoPACPresent = ETrue;

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

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

   981             << varValue.toBool();

   982     }

   983 

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

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

   986         eapSettings.iWarnADHPNoMatchingPACPresent = ETrue;

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

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

   989             << varValue.toBool();

   990     }

   991 

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

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

   994         eapSettings.iWarnNotDefaultServerPresent = ETrue;

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

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

   997             << varValue.toBool();

   998     }

   999 

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

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

  1002         eapSettings.iUseIdentityPrivacyPresent = ETrue;

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

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

  1005             << varValue.toBool();

  1006     }

  1007 

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

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

  1010 

  1011         // not need to set disable inner types

  1012         // EAP server takes care of them internally

  1013 

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

  1015 

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

  1017         TEapExpandedType tmpEap;

  1018         EapQtPluginHandle tmpHandle;

  1019 

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

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

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

  1023                 eapSettings.iEnabledEncapsulatedEAPExpandedTypesPresent = ETrue;

  1024 

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

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

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

  1028                 eapSettings.iEnabledEncapsulatedEAPExpandedTypes.Append(tmpEap);

  1029 

  1030                 qDebug()

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

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

  1033             }

  1034         }

  1035     }

  1036 

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

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

  1039 

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

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

  1042 

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

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

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

  1046                 // set to true only if at least item cipher is ok

  1047                 eapSettings.iCipherSuitesPresent = ETrue;

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

  1049                 qDebug(

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

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

  1052             }

  1053         }

  1054     }

  1055 

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

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

  1058 

  1059         qDebug()

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

  1061 

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

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

  1064             // check that the item is of correct type

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

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

  1067                 eapSettings.iCertificatesPresent = ETrue;

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

  1069                     &(eapSettings.iCertificates));

  1070                 qDebug()

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

  1072             }

  1073         }

  1074     }

  1075 

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

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

  1078 

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

  1080 

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

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

  1083             // check that the item is of correct type

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

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

  1086                 eapSettings.iCertificatesPresent = ETrue;

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

  1088                     &(eapSettings.iCertificates));

  1089                 qDebug()

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

  1091             }

  1092         }

  1093     }

  1094 

  1095 }

  1096 

  1097 // caller takes care of deallocating resulting data in certList

  1098 void EapQtConfigInterfacePrivate::appendCertificateInfo(bool isCaCertificate,

  1099     const EapQtCertificateInfo& certInfo, RPointerArray<EapCertificateEntry>* const certList)

  1100 {

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

  1102 

  1103 

  1104     Q_ASSERT(certList);

  1105 

  1106     // use scoped pointer to make sure memory is not leaked in failures

  1107     QScopedPointer<EapCertificateEntry> certEntry(new EapCertificateEntry);

  1108 

  1109     // set certificate enabled in EAP settings

  1110     certEntry->SetIsEnabledPresent();

  1111     certEntry->SetIsEnabled(ETrue);

  1112 

  1113     if (isCaCertificate) {

  1114         qDebug("EapQtConfigInterfacePrivate::appendCertificateInfo() - CA certificate");

  1115         certEntry->SetCertType(EapCertificateEntry::ECA);

  1116     }

  1117     else {

  1118         qDebug("EapQtConfigInterfacePrivate::appendCertificateInfo() - Client certificate");

  1119         certEntry->SetCertType(EapCertificateEntry::EUser);

  1120     }

  1121 

  1122     qDebug("EapQtConfigInterfacePrivate::appendCertificateInfo() - *** Adding cert data");

  1123 

  1124     TBuf<KGeneralStringMaxLength> certText;

  1125 

  1126     QVariant varValue = certInfo.value(EapQtCertificateInfo::SubjectName);

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

  1128         certEntry->SetSubjectNamePresent();

  1129         certText.Copy(varValue.toString().utf16());

  1130         certEntry->SetSubjectName(certText);

  1131 

  1132         qDebug() << "EapQtConfigInterfacePrivate::appendCertificateInfo() - SubjectName: "

  1133             << varValue.toString();

  1134     }