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:  Symbian specific private security module model

    15 *

    16 */

    17 

    18 #include "advsecsettingssecuritymodulemodel_symbian_p.h"

    19 #include "advsecsettingssecuritymodulemodel.h"

    20 #include "advsecsettingsstoreuids.h"

    21 #include "advsecsettingssecuritymoduleeraser_symbian.h"

    22 #include <unifiedkeystore.h>            // CUnifiedKeyStore

    23 #include <mctauthobject.h>              // MCTAuthenticationObject

    24 #include <QDebug>

    25 

    26 // TODO: split implementation into smaller parts, use CAdvSecSettingsSecurityModuleSymbian

    27 

    28 // Local functions in other cpp-files within this project

    29 QString CopyStringL(const TDesC16 &aDes16);

    30 QString Location(const TUid &aTokenType);

    31 

    32 // TODO: replace with proper logging

    33 #ifdef _DEBUG

    34 #define TRACE(x)        RDebug::Printf(x)

    35 #define TRACE1(x,y)     RDebug::Printf((x),(y))

    36 #define TRACE2(x,y,z)   RDebug::Printf((x),(y),(z))

    37 #else

    38 #define TRACE(x)

    39 #define TRACE1(x,y)

    40 #define TRACE2(x,y,z)

    41 #endif

    42 

    43 

    44 // ======== MEMBER FUNCTIONS ========

    45 

    46 // ---------------------------------------------------------------------------

    47 // AdvSecSettingsSecurityModuleModelPrivate::AdvSecSettingsSecurityModuleModelPrivate()

    48 // ---------------------------------------------------------------------------

    49 //

    50 AdvSecSettingsSecurityModuleModelPrivate::AdvSecSettingsSecurityModuleModelPrivate(

    51     AdvSecSettingsSecurityModuleModel *q) : CActive(CActive::EPriorityLow), q_ptr(q),

    52     iState(ENotInitialized)

    53 {

    54     TRACE("AdvSecSettingsSecurityModuleModelPrivate::AdvSecSettingsSecurityModuleModelPrivate");

    55     CActiveScheduler::Add(this);

    56 }

    57 

    58 // ---------------------------------------------------------------------------

    59 // AdvSecSettingsSecurityModuleModelPrivate::~AdvSecSettingsSecurityModuleModelPrivate()

    60 // ---------------------------------------------------------------------------

    61 //

    62 AdvSecSettingsSecurityModuleModelPrivate::~AdvSecSettingsSecurityModuleModelPrivate()

    63 {

    64     TRACE("AdvSecSettingsSecurityModuleModelPrivate::~AdvSecSettingsSecurityModuleModelPrivate");

    65     Cancel();

    66     delete iModuleEraser;

    67     iCurrentKeyStore = NULL;

    68     iCurrentAuthObject = NULL;

    69     iProtectedKeyStores.Reset();

    70     iAuthenticationObjects.Reset();

    71     iKeys.Close();

    72     delete iAllKeysFilter;

    73     delete iUnifiedKeyStore;

    74     iFs.Close();

    75     q_ptr = NULL;

    76 }

    77 

    78 // ---------------------------------------------------------------------------

    79 // AdvSecSettingsSecurityModuleModelPrivate::initialize()

    80 // ---------------------------------------------------------------------------

    81 //

    82 void AdvSecSettingsSecurityModuleModelPrivate::initialize()

    83 {

    84     TRACE("AdvSecSettingsSecurityModuleModelPrivate::initialize");

    85     if ((iState == ENotInitialized) && !IsActive()) {

    86         TRAPD(err, ConstructL());

    87         if (err == KErrNone) {

    88             iUnifiedKeyStore->Initialize(iStatus);

    89             iState = EInitializing;

    90             SetActive();

    91         } else {

    92             q_ptr->handleError(err);

    93         }

    94     } else {

    95         q_ptr->handleError(KErrAlreadyExists);

    96     }

    97 }

    98 

    99 // ---------------------------------------------------------------------------

   100 // AdvSecSettingsSecurityModuleModelPrivate::moduleCount()

   101 // ---------------------------------------------------------------------------

   102 //

   103 int AdvSecSettingsSecurityModuleModelPrivate::moduleCount() const

   104 {

   105     TRACE("AdvSecSettingsSecurityModuleModelPrivate::moduleCount");

   106     return iProtectedKeyStores.Count();

   107 }

   108 

   109 // ---------------------------------------------------------------------------

   110 // AdvSecSettingsSecurityModuleModelPrivate::moduleLabelsAndLocations()

   111 // ---------------------------------------------------------------------------

   112 //

   113 QMap<QString,QString> AdvSecSettingsSecurityModuleModelPrivate::moduleLabelsAndLocations() const

   114 {

   115     TRACE("AdvSecSettingsSecurityModuleModelPrivate::moduleLabelsAndLocations");

   116     QMap<QString,QString> map;

   117 

   118     for (TInt index = 0; index < iProtectedKeyStores.Count(); index++) {

   119         MCTToken &keyStoreToken = iProtectedKeyStores[index]->Token();

   120 

   121         QString label;

   122         if (keyStoreToken.TokenType().Type().iUid == KAdvSecSettingsFileKeyStore) {

   123             // TODO: localized UI string needed

   124             label = CopyStringL(_L("Phone key store"));

   125         } else {

   126             label = CopyStringL(keyStoreToken.Label());

   127         }

   128 

   129         map[label] = Location(keyStoreToken.TokenType().Type());

   130     }

   131 

   132     return map;

   133 }

   134 

   135 // ---------------------------------------------------------------------------

   136 // AdvSecSettingsSecurityModuleModelPrivate::getModuleStatus()

   137 // ---------------------------------------------------------------------------

   138 //

   139 void AdvSecSettingsSecurityModuleModelPrivate::getModuleStatus(int moduleIndex)

   140 {

   141     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::getModuleStatus, moduleIndex=%d", moduleIndex);

   142     if ((iState == EIdle) && !IsActive()) {

   143         if (moduleIndex >= 0 && moduleIndex < iAuthenticationObjects.Count()) {

   144             // TODO: this does not work yet

   145 #if 0

   146             iCurrentAuthObject = iAuthenticationObjects[moduleIndex];

   147             iTimeRemaining = 0;

   148             iCurrentAuthObject->TimeRemaining(iTimeRemaining, iStatus);

   149             iState = EReadingTimeRemaining;

   150             SetActive();

   151 #else

   152             TInt tempStatus = AdvSecSettingsSecurityModuleModel::EPinRequested;

   153             q_ptr->handleStatusCompleted(tempStatus);

   154 #endif

   155         } else {

   156             q_ptr->handleError(KErrArgument);

   157         }

   158     } else {

   159         q_ptr->handleError(KErrInUse);

   160     }

   161 }

   162 

   163 // ---------------------------------------------------------------------------

   164 // AdvSecSettingsSecurityModuleModelPrivate::setPinCodeRequestState()

   165 // ---------------------------------------------------------------------------

   166 //

   167 void AdvSecSettingsSecurityModuleModelPrivate::setPinCodeRequestState(int moduleIndex,

   168     bool isRequested)

   169 {

   170     TRACE2("AdvSecSettingsSecurityModuleModelPrivate::setPinCodeRequestState, moduleIndex=%d isRequested=%d",

   171         moduleIndex, isRequested);

   172     if ((iState == EIdle) && !IsActive()) {

   173         if (moduleIndex >= 0 && moduleIndex < iAuthenticationObjects.Count()) {

   174             iCurrentAuthObject = iAuthenticationObjects[moduleIndex];

   175             if (isRequested) {

   176                 iCurrentAuthObject->Enable(iStatus);

   177                 iState = EEnablingPinCodeRequest;

   178             } else {

   179                 iCurrentAuthObject->Disable(iStatus);

   180                 iState = EDisablingPinCodeRequest;

   181             }

   182             SetActive();

   183         } else {

   184             q_ptr->handleError(KErrArgument);

   185         }

   186     } else {

   187         q_ptr->handleError(KErrInUse);

   188     }

   189 }

   190 

   191 // ---------------------------------------------------------------------------

   192 // AdvSecSettingsSecurityModuleModelPrivate::changePinCode()

   193 // ---------------------------------------------------------------------------

   194 //

   195 void AdvSecSettingsSecurityModuleModelPrivate::changePinCode(int moduleIndex)

   196 {

   197     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::changePinCode, moduleIndex=%d", moduleIndex);

   198     if ((iState == EIdle) && !IsActive()) {

   199         if (moduleIndex >= 0 && moduleIndex < iAuthenticationObjects.Count()) {

   200             iCurrentAuthObject = iAuthenticationObjects[moduleIndex];

   201             ChangeCurrentAuthObjectPinCode();

   202         } else {

   203             q_ptr->handleError(KErrArgument);

   204         }

   205     } else {

   206         q_ptr->handleError(KErrInUse);

   207     }

   208 }

   209 

   210 // ---------------------------------------------------------------------------

   211 // AdvSecSettingsSecurityModuleModelPrivate::closeModule()

   212 // ---------------------------------------------------------------------------

   213 //

   214 void AdvSecSettingsSecurityModuleModelPrivate::closeModule(int moduleIndex)

   215 {

   216     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::closeModule, moduleIndex=%d", moduleIndex);

   217     if ((iState == EIdle) && !IsActive()) {

   218         if (moduleIndex >= 0 && moduleIndex < iAuthenticationObjects.Count()) {

   219             iCurrentAuthObject = iAuthenticationObjects[moduleIndex];

   220             iCurrentAuthObject->Close(iStatus);

   221             iState = EClosingAuthObject;

   222             SetActive();

   223         } else {

   224             q_ptr->handleError(KErrArgument);

   225         }

   226     } else {

   227         q_ptr->handleError(KErrInUse);

   228     }

   229 }

   230 

   231 // ---------------------------------------------------------------------------

   232 // AdvSecSettingsSecurityModuleModelPrivate::isSigningPinSupported()

   233 // ---------------------------------------------------------------------------

   234 //

   235 bool AdvSecSettingsSecurityModuleModelPrivate::isSigningPinSupported(int moduleIndex) const

   236 {

   237     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::isSigningPinSupported, moduleIndex=%d",

   238         moduleIndex);

   239     if (moduleIndex >= 0 && moduleIndex < iProtectedKeyStores.Count()) {

   240         MCTToken &keyStoreToken = iProtectedKeyStores[moduleIndex]->Token();

   241         if (keyStoreToken.TokenType().Type().iUid == KAdvSecSettingsFileKeyStore) {

   242             return false;

   243         } else {

   244             return true;

   245         }

   246     } else {

   247         return false;

   248     }

   249 }

   250 

   251 // ---------------------------------------------------------------------------

   252 // AdvSecSettingsSecurityModuleModelPrivate::changeSigningPinCode()

   253 // ---------------------------------------------------------------------------

   254 //

   255 void AdvSecSettingsSecurityModuleModelPrivate::changeSigningPinCode(int /*moduleIndex*/)

   256 {

   257     TRACE("AdvSecSettingsSecurityModuleModelPrivate::changeSigningPinCode" );

   258 

   259     // TODO: implement

   260     q_ptr->handleError(KErrNotSupported);

   261 }

   262 

   263 // ---------------------------------------------------------------------------

   264 // AdvSecSettingsSecurityModuleModelPrivate::isDeletable()

   265 // ---------------------------------------------------------------------------

   266 //

   267 bool AdvSecSettingsSecurityModuleModelPrivate::isDeletable(int moduleIndex) const

   268 {

   269     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::isDeletable, moduleIndex=%d",

   270         moduleIndex);

   271     if (moduleIndex >= 0 && moduleIndex < iProtectedKeyStores.Count()) {

   272         MCTToken &keyStoreToken = iProtectedKeyStores[moduleIndex]->Token();

   273         if (keyStoreToken.TokenType().Type().iUid == KAdvSecSettingsFileKeyStore) {

   274             TRACE("AdvSecSettingsSecurityModuleModelPrivate::isDeletable, true");

   275             return true;

   276         }

   277     }

   278     TRACE("AdvSecSettingsSecurityModuleModelPrivate::isDeletable, false");

   279     return false;

   280 }

   281 

   282 // ---------------------------------------------------------------------------

   283 // AdvSecSettingsSecurityModuleModelPrivate::deleteModule()

   284 // ---------------------------------------------------------------------------

   285 //

   286 void AdvSecSettingsSecurityModuleModelPrivate::deleteModule(int moduleIndex)

   287 {

   288     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::deleteModule, moduleIndex=%d",

   289         moduleIndex);

   290     if (moduleIndex >= 0 && moduleIndex < iProtectedKeyStores.Count()) {

   291         MCTToken &keyStoreToken = iProtectedKeyStores[moduleIndex]->Token();

   292         if (keyStoreToken.TokenType().Type().iUid == KAdvSecSettingsFileKeyStore) {

   293             TInt err = DoStartDeletingModule(moduleIndex);

   294             if (err) {

   295                 q_ptr->handleError(err);

   296             }

   297         }

   298     } else {

   299         q_ptr->handleError(KErrArgument);

   300     }

   301 }

   302 

   303 // ---------------------------------------------------------------------------

   304 // AdvSecSettingsSecurityModuleModelPrivate::DoCancel()

   305 // ---------------------------------------------------------------------------

   306 //

   307 void AdvSecSettingsSecurityModuleModelPrivate::DoCancel()

   308 {

   309     TRACE("AdvSecSettingsSecurityModuleModelPrivate::DoCancel");

   310     switch (iState) {

   311     case EInitializing:

   312         iUnifiedKeyStore->CancelInitialize();

   313         iState = ENotInitialized;

   314         break;

   315     case EListingKeys:

   316         iCurrentKeyStore->CancelList();

   317         iState = ENotInitialized;

   318         break;

   319     case EReadingTimeRemaining:

   320         iCurrentAuthObject->CancelTimeRemaining();

   321         iState = EIdle;

   322         break;

   323     case EChangingPinCode:

   324         iCurrentAuthObject->CancelChangeReferenceData();

   325         iState = EIdle;

   326         break;

   327     case EUnblockingToChangePinCode:

   328         iCurrentAuthObject->CancelUnblock();

   329         iState = EIdle;

   330         break;

   331     case EEnablingPinCodeRequest:

   332         iCurrentAuthObject->CancelEnable();

   333         iState = EIdle;

   334         break;

   335     case EDisablingPinCodeRequest:

   336         iCurrentAuthObject->CancelDisable();

   337         iState = EIdle;

   338         break;

   339     case EClosingAuthObject:

   340         iCurrentAuthObject->CancelClose();

   341         iState = EIdle;

   342         break;

   343     case EDeletingModule:

   344         delete iModuleEraser;

   345         iModuleEraser = NULL;

   346         break;

   347     default:

   348         break;

   349     }

   350     q_ptr->handleError(KErrCancel);

   351 }

   352 

   353 // ---------------------------------------------------------------------------

   354 // AdvSecSettingsSecurityModuleModelPrivate::RunL()

   355 // ---------------------------------------------------------------------------

   356 //

   357 void AdvSecSettingsSecurityModuleModelPrivate::RunL()

   358 {

   359     TRACE2("AdvSecSettingsSecurityModuleModelPrivate::RunL, status=%d state=%d", iStatus.Int(), iState);

   360     User::LeaveIfError(iStatus.Int());

   361     switch (iState) {

   362     case EInitializing:

   363         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EInitializing");

   364         iAuthenticationObjects.Reset();

   365         iProtectedKeyStores.Reset();

   366         ListKeysFromFirstKeyStoreL();

   367         break;

   368     case EListingKeys:

   369         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EListingKeys");

   370         AppendKeyStoresWithProtectedKeysL();

   371         ListKeysFromNextKeyStoreL();

   372         break;

   373     case EReadingTimeRemaining:

   374         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EReadingTimeRemaining");

   375         ReturnModuleStatusL();

   376         break;

   377     case EChangingPinCode:

   378         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EChangingPinCode");

   379         ReturnPinChanged();

   380         break;

   381     case EUnblockingToChangePinCode:

   382         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EUnblockingToChangePinCode");

   383         ChangeCurrentAuthObjectPinCode();

   384         break;

   385     case EEnablingPinCodeRequest:

   386     case EDisablingPinCodeRequest:

   387         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EEnabling/DisablingPinCodeRequest");

   388         ReturnPinRequestStateChanged();

   389         break;

   390     case EClosingAuthObject:

   391         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EClosingAuthObject");

   392         ReturnModuleClosed();

   393         break;

   394     case EDeletingModule:

   395         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, EDeletingModule");

   396         ReturnModuleDeleted();

   397         break;

   398     default:

   399         TRACE("AdvSecSettingsSecurityModuleModelPrivate::RunL, default");

   400         ASSERT(EFalse);

   401         break;

   402     }

   403 }

   404 

   405 // ---------------------------------------------------------------------------

   406 // AdvSecSettingsSecurityModuleModelPrivate::RunError()

   407 // ---------------------------------------------------------------------------

   408 //

   409 TInt AdvSecSettingsSecurityModuleModelPrivate::RunError(TInt aError)

   410 {

   411     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::RunError, aError=%d", aError);

   412     q_ptr->handleError(aError);

   413     return KErrNone;

   414 }

   415 

   416 // ---------------------------------------------------------------------------

   417 // AdvSecSettingsSecurityModuleModelPrivate::ConstructL()

   418 // ---------------------------------------------------------------------------

   419 //

   420 void AdvSecSettingsSecurityModuleModelPrivate::ConstructL()

   421 {

   422     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ConstructL");

   423     User::LeaveIfError(iFs.Connect());

   424     iUnifiedKeyStore = CUnifiedKeyStore::NewL(iFs);

   425 }

   426 

   427 // ---------------------------------------------------------------------------

   428 // AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromFirstKeyStoreL()

   429 // ---------------------------------------------------------------------------

   430 //

   431 void AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromFirstKeyStoreL()

   432 {

   433     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromFirstKeyStoreL, count=%d",

   434         iUnifiedKeyStore->KeyStoreCount());

   435     iKeyStoreIndex = 0;

   436     ListKeysFromOneKeyStoreL();

   437 }

   438 

   439 // ---------------------------------------------------------------------------

   440 // AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromOneKeyStoreL()

   441 // ---------------------------------------------------------------------------

   442 //

   443 void AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromOneKeyStoreL()

   444 {

   445     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromOneKeyStoreL, index=%d",

   446         iKeyStoreIndex);

   447     if (iKeyStoreIndex < iUnifiedKeyStore->KeyStoreCount()) {

   448         iKeys.Close();

   449         if (!iAllKeysFilter) {

   450             iAllKeysFilter = new( ELeave ) TCTKeyAttributeFilter;

   451             iAllKeysFilter->iPolicyFilter = TCTKeyAttributeFilter::EAllKeys;

   452         }

   453         iCurrentKeyStore = &(iUnifiedKeyStore->KeyStore(iKeyStoreIndex));

   454         iCurrentKeyStore->List(iKeys, *iAllKeysFilter, iStatus);

   455         iState = EListingKeys;

   456         SetActive();

   457     } else {

   458         iState = EIdle;

   459         q_ptr->handleInitializeCompleted();

   460     }

   461 }

   462 

   463 // ---------------------------------------------------------------------------

   464 // AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromNextKeyStoreL()

   465 // ---------------------------------------------------------------------------

   466 //

   467 void AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromNextKeyStoreL()

   468 {

   469     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ListKeysFromNextKeyStoreL");

   470     ++iKeyStoreIndex;

   471     ListKeysFromOneKeyStoreL();

   472 }

   473 

   474 // ---------------------------------------------------------------------------

   475 // AdvSecSettingsSecurityModuleModelPrivate::AppendKeyStoresWithProtectedKeysL()

   476 // ---------------------------------------------------------------------------

   477 //

   478 void AdvSecSettingsSecurityModuleModelPrivate::AppendKeyStoresWithProtectedKeysL()

   479 {

   480     TRACE("AdvSecSettingsSecurityModuleModelPrivate::AppendKeyStoresWithProtectedKeysL");

   481     for (TInt index = 0; index < iKeys.Count(); index++) {

   482         const CCTKeyInfo &keyInfo = *(iKeys[index]);

   483         if (keyInfo.Protector()) {

   484             TRACE("AdvSecSettingsSecurityModuleModelPrivate::AppendKeyStoresWithProtectedKeysL, added");

   485             iAuthenticationObjects.AppendL(keyInfo.Protector());

   486             iProtectedKeyStores.AppendL(&(iUnifiedKeyStore->KeyStore(iKeyStoreIndex)));

   487         }

   488     }

   489 }

   490 

   491 // ---------------------------------------------------------------------------

   492 // AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode()

   493 // ---------------------------------------------------------------------------

   494 //

   495 void AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode()

   496 {

   497     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode");

   498     TInt32 currentAuthObjectStatus = iCurrentAuthObject->Status();

   499     if (currentAuthObjectStatus & EAuthObjectBlocked) {

   500         TRACE("AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode, blocked");

   501         if (currentAuthObjectStatus & EUnblockDisabled) {

   502             TRACE("AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode, permanently");

   503             iState = EIdle;

   504             q_ptr->handleError(KErrPermissionDenied);

   505         } else {

   506             TRACE("AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode, unblocking");

   507             iCurrentAuthObject->Unblock(iStatus);

   508             iState = EUnblockingToChangePinCode;

   509             SetActive();

   510         }

   511     } else {

   512         if (currentAuthObjectStatus & EChangeDisabled) {

   513             TRACE("AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode, cannot change");

   514             iState = EIdle;

   515             q_ptr->handleError(KErrPermissionDenied);

   516         } else {

   517             TRACE("AdvSecSettingsSecurityModuleModelPrivate::ChangeCurrentAuthObjectPinCode, changing pin");

   518             iCurrentAuthObject->ChangeReferenceData(iStatus);

   519             iState = EChangingPinCode;

   520             SetActive();

   521         }

   522     }

   523 }

   524 

   525 // ---------------------------------------------------------------------------

   526 // AdvSecSettingsSecurityModuleModelPrivate::DoStartDeletingModule()

   527 // ---------------------------------------------------------------------------

   528 //

   529 TInt AdvSecSettingsSecurityModuleModelPrivate::DoStartDeletingModule(TInt aModuleIndex)

   530 {

   531     if (!iModuleEraser) {

   532         TRAPD(err, iModuleEraser = CAdvSecSettingsSecurityModuleEraser::NewL(*iUnifiedKeyStore));

   533         if (err) {

   534             return err;

   535         }

   536     }

   537     iModuleEraser->Erase(aModuleIndex, iStatus);

   538     iState = EDeletingModule;

   539     SetActive();

   540     return KErrNone;

   541 }

   542 

   543 // ---------------------------------------------------------------------------

   544 // AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleStatusL()

   545 // ---------------------------------------------------------------------------

   546 //

   547 void AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleStatusL()

   548 {

   549     int advSecSettingsStatus = 0;

   550 

   551     TUint32 currentTCTAuthenticationStatus = iCurrentAuthObject->Status();

   552     if (currentTCTAuthenticationStatus & EUnblockDisabled) {

   553         advSecSettingsStatus |= AdvSecSettingsSecurityModuleModel::EBlockedPermanently;

   554     }

   555     if (currentTCTAuthenticationStatus & EAuthObjectBlocked) {

   556         advSecSettingsStatus |= AdvSecSettingsSecurityModuleModel::EPinBlocked;

   557     }

   558     advSecSettingsStatus |= AdvSecSettingsSecurityModuleModel::EPinChangeAllowed;

   559     if (currentTCTAuthenticationStatus & EChangeDisabled) {

   560         advSecSettingsStatus ^= AdvSecSettingsSecurityModuleModel::EPinChangeAllowed;

   561     }

   562     if (currentTCTAuthenticationStatus & EEnabled) {

   563         advSecSettingsStatus |= AdvSecSettingsSecurityModuleModel::EPinRequested;

   564     }

   565     if (iTimeRemaining > 0) {

   566         advSecSettingsStatus |= AdvSecSettingsSecurityModuleModel::EPinEntered;

   567     }

   568 

   569     TRACE1("AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleStatusL 0x%08x",

   570         advSecSettingsStatus);

   571     iState = EIdle;

   572     q_ptr->handleStatusCompleted(advSecSettingsStatus);

   573 }

   574 

   575 // ---------------------------------------------------------------------------

   576 // AdvSecSettingsSecurityModuleModelPrivate::ReturnPinChanged()

   577 // ---------------------------------------------------------------------------

   578 //

   579 void AdvSecSettingsSecurityModuleModelPrivate::ReturnPinChanged()

   580 {

   581     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ReturnPinChanged");

   582     iState = EIdle;

   583     q_ptr->handlePinCodeChanged();

   584 }

   585 

   586 // ---------------------------------------------------------------------------

   587 // AdvSecSettingsSecurityModuleModelPrivate::ReturnPinRequestStateChanged()

   588 // ---------------------------------------------------------------------------

   589 //

   590 void AdvSecSettingsSecurityModuleModelPrivate::ReturnPinRequestStateChanged()

   591 {

   592     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ReturnPinRequestStateChanged");

   593     iState = EIdle;

   594     q_ptr->handlePinCodeRequestSet();

   595 }

   596 

   597 // ---------------------------------------------------------------------------

   598 // AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleClosed()

   599 // ---------------------------------------------------------------------------

   600 //

   601 void AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleClosed()

   602 {

   603     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleClosed");

   604     iState = EIdle;

   605     q_ptr->handleModuleClosed();

   606 }

   607 

   608 // ---------------------------------------------------------------------------

   609 // AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleDeleted()

   610 // ---------------------------------------------------------------------------

   611 //

   612 void AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleDeleted()

   613 {

   614     TRACE("AdvSecSettingsSecurityModuleModelPrivate::ReturnModuleDeleted");

   615     iState = EIdle;

   616     q_ptr->handleModuleDeleted();

   617 }

   618