1 /*

     2 * Copyright (c) 2003-2009 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:   Implementation of class CCertManUICertificateHelper

    15 *

    16 */

    17 

    18 

    19 #include <X509CertNameParser.h>

    20 #include <certmanui.rsg>

    21 #include <hash.h>                   // MD5 fingerprint

    22 #include <aknmessagequerydialog.h>

    23 #include <pkixcertchain.h>          // for validation

    24 #include <aknnotewrappers.h>        // for warning & information notes

    25 #include <sysutil.h>

    26 #include <ErrorUI.h>

    27 #include <unifiedkeystore.h>

    28 #include <TrustedSitesStore.h>

    29 #include <x509keys.h>               // TX509KeyFactory

    30 #include <e32math.h>                // Pow

    31 #include "Certmanui.hrh"

    32 #include "CertmanuiCertificateHelper.h"

    33 #include "CertmanuiCommon.h"

    34 #include "CertmanuiSyncWrapper.h"

    35 #include "CertManUILogger.h"

    36 

    37 const TInt KFileCertStoreUid( 0x101F501A );

    38 const TInt KTrustedServerCertStoreUid( 0x101FB66F );

    39 const TInt KDeviceCertStoreUid( 0x101FB668 );

    40 const TInt KDeviceKeyStoreUid( 0x101FB66A );

    41 

    42 _LIT( KBlockSeparator, " " );

    43 

    44 template <class T>

    45 class CleanupResetAndDestroy

    46     {

    47 public:

    48     inline static void PushL( T& aRef );

    49 private:

    50     static void ResetAndDestroy( TAny *aPtr );

    51     };

    52 

    53 template <class T>

    54 inline void CleanupResetAndDestroyPushL( T& aRef );

    55 

    56 template <class T>

    57 inline void CleanupResetAndDestroy<T>::PushL( T& aRef )

    58     {

    59     CleanupStack::PushL( TCleanupItem( &ResetAndDestroy, &aRef ) );

    60     }

    61 

    62 template <class T>

    63 void CleanupResetAndDestroy<T>::ResetAndDestroy( TAny *aPtr )

    64     {

    65     if( aPtr )

    66         {

    67         static_cast<T*>( aPtr )->ResetAndDestroy();

    68         }

    69     }

    70 

    71 template <class T>

    72 inline void CleanupResetAndDestroyPushL( T& aRef )

    73     {

    74     CleanupResetAndDestroy<T>::PushL( aRef );

    75     }

    76 

    77 

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

    79 // CCertManUICertificateHelper::CCertManUICertificateHelper()

    80 // Default C++ Constructor

    81 // ---------------------------------------------------------

    82 //

    83 CCertManUICertificateHelper::CCertManUICertificateHelper( CCertManUIKeeper& aKeeper )

    84 : iKeeper(aKeeper)

    85     {

    86   }

    87 

    88 // ---------------------------------------------------------

    89 // CCertManUICertificateHelper::~CCertManUICertificateHelper()

    90 // Destructor

    91 // ---------------------------------------------------------

    92 //

    93 CCertManUICertificateHelper::~CCertManUICertificateHelper()

    94     {

    95     }

    96 

    97 // ---------------------------------------------------------

    98 // CCertManUICertificateHelper::CutCertificateField(TPtrC aField)

    99 // If CertLabel, Issuer and Owner length is over 80 characters,

   100 // cut it down to 80

   101 // Returns the cut certificate field.

   102 // ---------------------------------------------------------

   103 //

   104 TPtrC CCertManUICertificateHelper::CutCertificateField( TPtrC aField )

   105     {

   106     CERTMANUILOGGER_ENTERFN(

   107          "CCertManUICertificateHelper::CutCertificateField" );

   108 

   109     TInt fieldLength = aField.Length();

   110     if ( fieldLength >= KMaxLengthTextCertLabelVisible )

   111         {

   112         TPtrC cutCertLabel = aField.Mid( 0, KMaxLengthTextCertLabelVisible );

   113 

   114         CERTMANUILOGGER_LEAVEFN(

   115            "CCertManUICertificateHelper::CutCertificateField" );

   116 

   117         return cutCertLabel;

   118         }

   119 

   120     CERTMANUILOGGER_LEAVEFN(

   121         "CCertManUICertificateHelper::CutCertificateField" );

   122 

   123     return aField;

   124     }

   125 

   126 // ---------------------------------------------------------

   127 // CCertManUICertificateHelper::IsCertificateDeletable

   128 // Check whether certificate is deletable

   129 // ---------------------------------------------------------

   130 //

   131 TBool CCertManUICertificateHelper::IsCertificateDeletable( TInt aIndex,

   132     TInt aType ) const

   133     {

   134     CERTMANUILOGGER_ENTERFN(

   135         "CCertManUICertificateHelper::IsCertificateDeletable" );

   136     TBool ret = ETrue;

   137 

   138     // If wim has not been enabled and certificate resides in smart card

   139     // we cannot delete it since we don't have smart card certificate

   140     // delete functionality in non WIM builds. So in non WIM builds all

   141     // smart card certificates are marked read-only.

   142     if( aIndex > -1 )

   143         {

   144         CCTCertInfo* entry;

   145         if ( aType == KCertTypeAuthority )

   146             {

   147             entry = iKeeper.iCALabelEntries[ aIndex ]->iCAEntry;

   148             }

   149         else if( aType == KCertTypeTrustedSite )

   150             {

   151             entry = iKeeper.iPeerLabelEntries[ aIndex ]->iPeerEntry;

   152             }

   153         else if( aType == KCertTypeDevice )

   154             {

   155             entry = iKeeper.iDeviceLabelEntries[ aIndex ]->iDeviceEntry;

   156             }

   157         else

   158             {

   159             entry = iKeeper.iUserLabelEntries[ aIndex ]->iUserEntry;

   160             }

   161         if ( !entry->IsDeletable() )

   162             {

   163             ret = EFalse;

   164             }

   165         }

   166 

   167     CERTMANUILOGGER_LEAVEFN(

   168         "CCertManUICertificateHelper::IsCertificateDeletable" );

   169     return ret;

   170     }

   171 

   172 // ---------------------------------------------------------

   173 // CCertManUICertificateHelper::IsOneMarkedCertificateDeletable

   174 // Check whether one marked certificate is deletable, or

   175 // if none certificate is marked, check if the highlighted

   176 // certificate is deletable

   177 // ---------------------------------------------------------

   178 //

   179 TBool CCertManUICertificateHelper::IsOneMarkedCertificateDeletable

   180     ( CEikColumnListBox* aListBox, TInt aType ) const

   181     {

   182     CERTMANUILOGGER_ENTERFN(

   183         "CCertManUICertificateHelper::IsOneMarkedCertificateDeletable" );

   184 

   185     const CArrayFix<TInt>* array  = aListBox->SelectionIndexes();

   186     TInt markedCount = array->Count();

   187     TBool oneIsDeletable = EFalse;

   188 

   189     if ( 0 == markedCount )

   190         {

   191         TInt currentItem = aListBox->CurrentItemIndex();

   192         return IsCertificateDeletable( currentItem, aType );

   193         }

   194 

   195     for ( TInt i = 0; !oneIsDeletable && i < markedCount; i++ )

   196         {

   197         oneIsDeletable = IsCertificateDeletable( (*array)[i], aType );

   198         }

   199 

   200     CERTMANUILOGGER_LEAVEFN(

   201         "CCertManUICertificateHelper::IsOneMarkedCertificateDeletable" );

   202 

   203     return oneIsDeletable;

   204     }

   205 

   206 // ---------------------------------------------------------

   207 // CCertManUICertificateHelper::MessageQueryViewDetailsL(TInt aIndex)

   208 // Creates the whole of certificate details view

   209 // Appends strings from both resources and CertManAPI to one

   210 // message body text and displays it.

   211 // ---------------------------------------------------------

   212 //

   213 void CCertManUICertificateHelper::MessageQueryViewDetailsL( TInt aIndex,

   214     TInt aType,

   215     CEikonEnv* aEikonEnv )

   216     {

   217     CERTMANUILOGGER_ENTERFN(

   218         "CCertManUICertificateHelper::MessageQueryViewDetailsL" );

   219      LOG_WRITE_FORMAT( "certificate index %i", aIndex );

   220 

   221     iKeeper.StartWaitDialogL( ECertmanUiWaitDialog );

   222 

   223     HBufC* message = HBufC::NewLC( KMaxLengthTextDetailsBody );

   224     TRAPD( err, CreateMessageBodyTextL( aIndex, aType, aEikonEnv, *message ) );

   225 

   226     iKeeper.CloseWaitDialogL();

   227     User::LeaveIfError( err );

   228 

   229     if( message->Length() )

   230         {

   231         HBufC* header = StringLoader::LoadLC( R_TEXT_RESOURCE_DETAILS_VIEW_HEADER );

   232         CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *message );

   233         dlg->PrepareLC( R_MESSAGE_QUERY_DETAILS_VIEW );

   234         dlg->QueryHeading()->SetTextL( *header );

   235         dlg->RunLD();

   236         CleanupStack::PopAndDestroy( header );

   237         }

   238 

   239     CleanupStack::PopAndDestroy( message );

   240 

   241     CERTMANUILOGGER_LEAVEFN(

   242         "CCertManUICertificateHelper::MessageQueryViewDetailsL" );

   243     }

   244 

   245 // ---------------------------------------------------------

   246 // CCertManUIViewAuthority::ValidateCertificateL(

   247 // Checks if the certificate is corrupted

   248 // Checks the validity period of the certificate

   249 // Display only one warning note, in the following order:

   250 // 1) Expired/Not yet valid

   251 // 2) Corrupted

   252 // 3) Not trusted

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

   254 //

   255 void CCertManUICertificateHelper::ValidateCertificateL(

   256     TInt aIndex, CCertificate* aDetails, const CCTCertInfo& aCertInfo, TInt aType )

   257     {

   258     CERTMANUILOGGER_ENTERFN(

   259         "CCertManUICertificateHelper::ValidateCertificateL" );

   260 

   261     TInt poppableItems = 0;

   262     // Check allways first the validity period

   263     // Show Expired/Not yet valid notes

   264     const CValidityPeriod& validityPeriod = aDetails->ValidityPeriod();

   265     const TTime& startValue = validityPeriod.Start();

   266     const TTime& finishValue = validityPeriod.Finish();

   267     TTime current;

   268     current.UniversalTime();

   269 

   270     if ( startValue > current )

   271         {

   272         // certificate is not valid yet

   273         HBufC* string = StringLoader::LoadLC(

   274             R_WARNING_NOTE_TEXT_CERTIFICATE_NOT_VALID_YET );

   275         DisplayWarningNoteLD(string);

   276         }

   277     else if ( finishValue < current )

   278         {

   279         // certificate is expired

   280         HBufC* string = StringLoader::LoadLC(

   281             R_WARNING_NOTE_TEXT_CERTIFICATE_EXPIRED );

   282         DisplayWarningNoteLD( string );

   283         }

   284     else

   285         {

   286         // put here check for certificate status, show warning notes if needed

   287         TBool noValidationError = ETrue;

   288         CArrayFixFlat<TValidationError>* status = NULL;

   289         TCertificateFormat certificateFormat;

   290 

   291         if ( aType == KCertTypeAuthority )

   292             {

   293             certificateFormat = iKeeper.iCALabelEntries[aIndex]->

   294                                         iCAEntry->CertificateFormat();

   295             }

   296         else if ( aType == KCertTypeTrustedSite )

   297             {

   298             certificateFormat = iKeeper.iPeerLabelEntries[aIndex]->

   299                                         iPeerEntry->CertificateFormat();

   300             }

   301         else if ( aType == KCertTypeDevice )

   302             {

   303             certificateFormat = iKeeper.iDeviceLabelEntries[aIndex]->

   304                                         iDeviceEntry->CertificateFormat();

   305             }

   306         else

   307             {

   308             certificateFormat = iKeeper.iUserLabelEntries[aIndex]->

   309                                         iUserEntry->CertificateFormat();

   310             }

   311 

   312         switch ( certificateFormat )

   313             {

   314             case EX509Certificate:

   315                 {

   316                 status = ValidateX509CertificateL(

   317                     (CX509Certificate*)aDetails );

   318                 break;

   319                 }

   320             default:

   321                 {

   322                 status = new ( ELeave) CArrayFixFlat<TValidationError>( 1 );

   323                 break;

   324                 }

   325             }

   326         CleanupStack::PushL( status );

   327         poppableItems++;

   328 

   329         TInt errorCount = status->Count();

   330         TBool ready = EFalse;

   331         for ( TInt i = 0; i < errorCount && !ready; i++ )

   332             {

   333             TValidationError errorType = status->At(i);

   334 

   335             switch ( errorType )

   336                 {

   337                 case EValidatedOK:

   338                 case EChainHasNoRoot:

   339                 case EBadKeyUsage:

   340                 // Ignore these errors

   341                     LOG_WRITE( "Ignored certificate validation error" );

   342                     break;

   343 

   344                 default:

   345                 // certificate is corrupted

   346                 noValidationError = EFalse;

   347                 HBufC* string = StringLoader::LoadLC(

   348                     R_WARNING_NOTE_TEXT_CERTIFICATE_CORRUPTED );

   349                 DisplayWarningNoteLD( string );

   350                 ready = ETrue;

   351                     break;

   352                 }

   353             }

   354 

   355         if ( noValidationError  && (aType == KCertTypeAuthority ))

   356         // Check for last if the CA certificate has no clients,

   357         // ie. the trust state of every client is No

   358         // For user certificates we don't do the check

   359             {

   360 

   361             RArray<TUid> trusterUids;

   362             CleanupClosePushL( trusterUids );

   363             poppableItems++;

   364 

   365             iKeeper.iWrapper->GetApplicationsL(

   366                 iKeeper.CertManager(), aCertInfo, trusterUids );

   367 

   368             if ( trusterUids.Count() == 0)

   369                 {

   370                 HBufC* string = StringLoader::LoadLC(

   371                     R_WARNING_NOTE_TEXT_CERTIFICATE_NOT_TRUSTED );

   372                 DisplayWarningNoteLD( string );

   373                 }

   374             }

   375         }

   376     CleanupStack::PopAndDestroy( poppableItems );

   377 

   378     CERTMANUILOGGER_LEAVEFN(

   379         "CCertManUICertificateHelper::ValidateCertificateL" );

   380     }

   381 

   382 // ---------------------------------------------------------

   383 // CCertManUICertificateHelper::DetailsFieldDynamicL(

   384 // Appends a field that has string from resources and string from CertManAPI

   385 // to the details view message body

   386 // ---------------------------------------------------------

   387 //

   388 void CCertManUICertificateHelper::DetailsFieldDynamicL(

   389     HBufC& aMessage, TPtrC aValue, TInt aResourceOne, TInt aResourceTwo )

   390     {

   391     CERTMANUILOGGER_ENTERFN(

   392         "CCertManUICertificateHelper::DetailsFieldDynamicL" );

   393 

   394     DetailsResourceL( aMessage, aResourceOne );

   395     DetailsDynamicL( aMessage, aValue, aResourceTwo );

   396     aMessage.Des().Append( KCertManUIDetailsViewEnter );

   397 

   398     CERTMANUILOGGER_LEAVEFN(

   399         "CCertManUICertificateHelper::DetailsFieldDynamicL" );

   400     }

   401 

   402 // ---------------------------------------------------------

   403 // CCertManUICertificateHelper::DetailsResourceL(

   404 // Reads line from resources

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

   406 //

   407 void CCertManUICertificateHelper::DetailsResourceL(

   408     HBufC& aMessage, TInt aResourceOne )

   409     {

   410     CERTMANUILOGGER_ENTERFN(

   411         "CCertManUICertificateHelper::DetailsResourceL" );

   412 

   413     HBufC* stringHolder = StringLoader::LoadLC( aResourceOne );

   414     aMessage.Des().Append( stringHolder->Des() );

   415     CleanupStack::PopAndDestroy();  // stringHolder

   416     aMessage.Des().Append( KCertManUIDetailsViewEnter );

   417 

   418     CERTMANUILOGGER_LEAVEFN(

   419         "CCertManUICertificateHelper::DetailsResourceL" );

   420     }

   421 

   422 // ---------------------------------------------------------

   423 // CCertManUICertificateHelper::DetailsFieldResourceL(

   424 // Appends a field that has two strings from resources

   425 // to the details view message body

   426 // ---------------------------------------------------------

   427 //

   428 void CCertManUICertificateHelper::DetailsFieldResourceL(

   429     HBufC& aMessage, TInt aResourceOne,

   430     TInt aResourceTwo)

   431     {

   432     CERTMANUILOGGER_ENTERFN(

   433         "CCertManUICertificateHelper::DetailsFieldResourceL" );

   434 

   435     DetailsResourceL( aMessage, aResourceOne );

   436     DetailsResourceL( aMessage, aResourceTwo );

   437     aMessage.Des().Append( KCertManUIDetailsViewEnter );

   438 

   439     CERTMANUILOGGER_LEAVEFN(

   440         "CCertManUICertificateHelper::DetailsFieldResourceL" );

   441     }

   442 

   443 // ---------------------------------------------------------

   444 // CCertManUICertificateHelper::DevideToBlocks

   445 // ---------------------------------------------------------

   446 //

   447 void CCertManUICertificateHelper::DevideToBlocks( const TDesC8& aInput, TPtr aOutput )

   448     {

   449     const TInt KBlockLength = 2;

   450     TInt blockIndex = 0;

   451     for ( TInt j = 0 ; j < aInput.Length() ; j++ )

   452         {

   453         if ( blockIndex == KBlockLength )

   454             {

   455             aOutput.Append( KBlockSeparator );

   456             blockIndex = 0;

   457             }

   458         aOutput.AppendNumFixedWidthUC( (TUint)(aInput[ j ]), EHex, 2 );

   459         ++blockIndex;

   460         }

   461     }

   462 

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

   464 // CCertManUICertificateHelper::DisplayWarningNoteLD(HBufC* aString)

   465 // Displays the warning note for corrupted/expired/not yet valid certificate

   466 // ---------------------------------------------------------

   467 //

   468 void CCertManUICertificateHelper::DisplayWarningNoteLD( HBufC* aString )

   469     {

   470     CERTMANUILOGGER_ENTERFN(

   471         "CCertManUICertificateHelper::DisplayWarningNoteLD" );

   472 

   473     CAknWarningNote* note = new ( ELeave ) CAknWarningNote( ETrue );

   474     note->ExecuteLD( *aString );

   475     CleanupStack::PopAndDestroy();  // aString

   476 

   477     CERTMANUILOGGER_LEAVEFN(

   478         "CCertManUICertificateHelper::DisplayWarningNoteLD" );

   479     }

   480 

   481 // ---------------------------------------------------------

   482 // CCertManUICertificateHelper::ValidateX509CertificateL(CX509Certificate* aDetails)

   483 // Checks if the certificate is corrupted

   484 // Checks the validity period of the certificate

   485 // Display only one warning note, in the following order:

   486 // 1) Expired/Not yet valid

   487 // 2) Corrupted

   488 // 3) Not trusted

   489 // ---------------------------------------------------------

   490 //

   491 CArrayFixFlat<TValidationError>* CCertManUICertificateHelper::

   492     ValidateX509CertificateL( CX509Certificate* aDetails )

   493     {

   494     TInt poppableItems = 0;

   495     CArrayFixFlat<TValidationError>* status =

   496         new ( ELeave ) CArrayFixFlat<TValidationError>( 1 );

   497     CleanupStack::PushL( status ); //This is returned, so it isn't destroyed at the end.

   498 

   499     TTime GMTTime;

   500     GMTTime.UniversalTime(); // Get Universal Time

   501     RPointerArray<CX509Certificate> certArray( &aDetails, 1 );

   502 

   503     CPKIXCertChain* chain = CPKIXCertChain::NewLC(

   504         iKeeper.iRfs, aDetails->Encoding(), certArray );

   505     poppableItems++;

   506 

   507     CPKIXValidationResult* result = CPKIXValidationResult::NewLC();

   508     poppableItems++;

   509     iKeeper.iWrapper->ValidateX509RootCertificateL( result, GMTTime, chain );

   510 

   511     TValidationStatus validationStatus = result->Error();

   512     //Set reserve space. One for error, other for warnings.

   513     status->SetReserveL( 1 + result->Warnings().Count() );

   514     status->AppendL(validationStatus.iReason);

   515     for ( TUint8 i = 0; i < result->Warnings().Count(); i++ )

   516         {

   517         status->AppendL( result->Warnings().At(0).iReason );

   518         }

   519 

   520     CleanupStack::PopAndDestroy( poppableItems );    //  All but status.

   521     CleanupStack::Pop();        //  status

   522     return status;

   523     }

   524 

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

   526 // CCertManUICertificateHelper::DetailsDynamicL(

   527 // HBufC& aMessage, TPtrC aValue, TInt aResourceOne)

   528 // Reads dynamic text from CertManAPI, if the string is empty

   529 // put a not defined text from the resource in its place

   530 // KMaxLengthTextCertLabel = 510, used by CertLabel(), Issuer(), Owner()

   531 // ---------------------------------------------------------

   532 //

   533 void CCertManUICertificateHelper::DetailsDynamicL(

   534     HBufC& aMessage, TPtrC aValue, TInt aResourceOne )

   535     {

   536     CERTMANUILOGGER_ENTERFN(

   537         "CCertManUICertificateHelper::DetailsDynamicL" );

   538 

   539     HBufC* buf = HBufC::NewLC( KMaxLengthTextCertLabel );

   540     buf->Des() = aValue;

   541     buf->Des().TrimLeft();

   542     // Cut CertLabel after fourth semi colon

   543     TPtrC trimmedCertLabel = CutCertificateField( buf->Des() );

   544     buf->Des().Copy( trimmedCertLabel );

   545     TInt length = buf->Des().Length();

   546     if ( length == 0 )

   547         {

   548         DetailsResourceL( aMessage, aResourceOne );

   549         }

   550     else

   551         {

   552         //LRM (Left-to-Right mark 200E)

   553         const TInt KLRMark = 0x200E;

   554         aMessage.Des().Append( buf->Des() );

   555         aMessage.Des().Append(KLRMark);

   556         aMessage.Des().Append( KCertManUIDetailsViewEnter );

   557         }

   558     CleanupStack::PopAndDestroy();  // buf

   559 

   560     CERTMANUILOGGER_LEAVEFN(

   561         "CCertManUICertificateHelper::DetailsDynamicL" );

   562     }

   563 

   564 // ---------------------------------------------------------

   565 // CCertManUIViewAuthority::ConfirmationQueryDeleteCertL()

   566 // Deletes either certificate in focus if there are no marked items,

   567 // or deletes the marked items

   568 // Shows read-only information notes if certificates are not deletable

   569 // Returns ETrue if at least one certificate is deleted

   570 // ---------------------------------------------------------

   571 //

   572 TBool CCertManUICertificateHelper::ConfirmationQueryDeleteCertL(

   573     TInt aType,

   574     CEikColumnListBox* aListBox )

   575     {

   576     CERTMANUILOGGER_ENTERFN(

   577         "CCertManUICertificateHelper::ConfirmationQueryDeleteCertL" );

   578 

   579     TBool result = EFalse;

   580 

   581     const CArrayFix<TInt>* array = aListBox->SelectionIndexes();

   582     TInt focusPosition = aListBox->CurrentItemIndex();

   583     CCTCertInfo* entry;

   584     TInt queryOk = 0;

   585     // comes here when there is no selection, can be read-only

   586     // certificate if Clear key is pressed, must check

   587     if ( array->Count() == 0 && IsCertificateDeletable( focusPosition, aType ) )

   588         {

   589         if( aType == KCertTypeAuthority )

   590             {

   591             entry = iKeeper.iCALabelEntries[ focusPosition ]->iCAEntry;

   592             }

   593         else if( aType == KCertTypeTrustedSite )

   594             {

   595             entry = iKeeper.iPeerLabelEntries[ focusPosition ]->iPeerEntry;

   596             }

   597         else if( aType == KCertTypeDevice )

   598             {

   599             entry = iKeeper.iDeviceLabelEntries[ focusPosition ]->iDeviceEntry;

   600             }

   601         else

   602             {

   603             entry = iKeeper.iUserLabelEntries[ focusPosition ]->iUserEntry;

   604             }

   605         queryOk = DeleteSingleItemQueryL( *entry );

   606         if ( queryOk )

   607             {

   608             if (IsCertificateDeletable( focusPosition, aType ))

   609                 {

   610                 DeleteSingleItemL( *entry, focusPosition, aListBox, aType );

   611 

   612 

   613                 AknListBoxUtils::HandleItemRemovalAndPositionHighlightL(

   614                     aListBox, focusPosition, ETrue );

   615                 result = ETrue;

   616                 }

   617             else

   618                 {

   619                 ReadOnlySingleItemNoteL( *entry );

   620                 }

   621             }

   622         }

   623     else if ( IsOneMarkedCertificateDeletable(aListBox, aType) ) //if (array->Count()=>1)

   624         {

   625         if ( aType == KCertTypeAuthority )

   626             {

   627             entry = iKeeper.iCALabelEntries[ array->At(0) ]->iCAEntry;

   628             }

   629         else if ( aType == KCertTypeTrustedSite )

   630             {

   631             entry = iKeeper.iPeerLabelEntries[ array->At(0) ]->iPeerEntry;

   632             }

   633         else if( aType == KCertTypeDevice )

   634             {

   635             entry = iKeeper.iDeviceLabelEntries[ array->At(0) ]->iDeviceEntry;

   636             }

   637         else

   638             {

   639             entry = iKeeper.iUserLabelEntries[ array->At(0) ]->iUserEntry;

   640             }

   641 

   642         if (array->Count()==1)

   643             {

   644             queryOk = DeleteSingleItemQueryL( *entry );

   645             }

   646         else

   647             {

   648             HBufC* prompt = StringLoader::LoadLC(

   649                 R_CONFIRMATION_QUERY_DELETE_CERT_PLURAL, array->Count() );

   650             queryOk = DisplayConfirmationLD( prompt );

   651             }

   652         if ( queryOk )

   653             {

   654             TInt readonlyCount = 0;

   655             TInt singleReadOnlyPosition = 0;

   656             TInt markedPosition = 0;

   657             TKeyArrayFix ownKey( 0, ECmpTInt );

   658             CONST_CAST(CArrayFix<int>*, array)->Sort( ownKey ); //lint !e665 expression macro param ok

   659             TInt markedCount = array->Count();

   660             CArrayFixFlat<TInt>* deletedIndexes = new (ELeave)CArrayFixFlat<TInt>( 4 );

   661             CleanupStack::PushL( deletedIndexes );

   662 

   663             iKeeper.StartWaitDialogL( ECertmanUiDeleteDialog );

   664             CleanupCloseWaitDialogPushL( iKeeper );

   665 

   666             for ( TInt i = markedCount; i > 0; i-- )

   667                 {

   668                 markedPosition = array->At( i-1 );

   669                 // move focus up the list if marked items were

   670                 // between focus and the beginning of the list

   671                 if ( focusPosition > markedPosition )

   672                     {

   673                     focusPosition--;

   674                     }

   675 

   676                 // Check whether certificate is deletable

   677 

   678                 if( aType == KCertTypeAuthority )

   679                     {

   680                     entry = iKeeper.iCALabelEntries[ markedPosition ]->iCAEntry;

   681                     }

   682                 else if( aType == KCertTypeTrustedSite )

   683                     {

   684                     entry = iKeeper.iPeerLabelEntries[ markedPosition ]->iPeerEntry;

   685                     }

   686                 else if( aType == KCertTypeDevice )

   687                     {

   688                     entry = iKeeper.iDeviceLabelEntries[ markedPosition ]->iDeviceEntry;

   689                     }

   690                 else

   691                     {

   692                     entry = iKeeper.iUserLabelEntries[ markedPosition ]->iUserEntry;

   693                     }

   694 

   695                 if (IsCertificateDeletable(markedPosition, aType))

   696                     {

   697                     DeleteSingleItemL( *entry, markedPosition, aListBox, aType );

   698                     deletedIndexes->AppendL(markedPosition);

   699                     result = ETrue;

   700                     }

   701                 else // Cannot be deleted

   702                     {

   703                     readonlyCount++;

   704                     singleReadOnlyPosition = markedPosition;

   705                     }

   706                 }

   707 

   708             CleanupStack::PopAndDestroy();    // closes wait dialog

   709 

   710             if ( readonlyCount == 1 )

   711                 {

   712                 if( aType == KCertTypeAuthority  )

   713                     {

   714                     entry = iKeeper.iCALabelEntries[ singleReadOnlyPosition ]->iCAEntry;

   715                     }

   716                 else if( aType == KCertTypeTrustedSite  )

   717                     {

   718                     entry = iKeeper.iPeerLabelEntries[ singleReadOnlyPosition ]->iPeerEntry;

   719                     }

   720                 else if( aType == KCertTypeDevice )

   721                     {

   722                     entry = iKeeper.iDeviceLabelEntries[ singleReadOnlyPosition ]->iDeviceEntry;

   723                     }

   724                 else

   725                     {

   726                     entry = iKeeper.iUserLabelEntries[ singleReadOnlyPosition ]->iUserEntry;

   727                     }

   728 

   729                 ReadOnlySingleItemNoteL( *entry );

   730                 }

   731             else if ( readonlyCount > 1 )

   732                 {

   733                 HBufC* string = StringLoader::LoadLC(

   734                     R_INFO_NOTE_TEXT_CERTIFICATE_READ_ONLY_MULTIPLE,

   735                     readonlyCount );

   736                 DisplayNoteLD( string );

   737                 }

   738             else

   739                 { // For lint

   740                 }

   741 

   742             aListBox->ClearSelection();

   743             AknListBoxUtils::HandleItemRemovalAndPositionHighlightL(

   744                 aListBox, focusPosition, *deletedIndexes);

   745             CleanupStack::PopAndDestroy(deletedIndexes);

   746 

   747             }

   748         }

   749     else

   750         {

   751         result = EFalse;

   752         }

   753 

   754     aListBox->DrawNow();//lint !e539

   755 

   756     CERTMANUILOGGER_LEAVEFN(

   757         "CCertManUICertificateHelper::ConfirmationQueryDeleteCertL" );

   758 

   759 

   760     return result;

   761     }

   762 

   763 // ---------------------------------------------------------

   764 // CCertManUIViewAuthority::DeleteSingleItemQueryL(CCTCertInfo& aEntry)

   765 // Gets the certificate name (or No label/No subject) for the Confirmation note

   766 // ---------------------------------------------------------

   767 //

   768 TInt CCertManUICertificateHelper::DeleteSingleItemQueryL( CCTCertInfo& aEntry )

   769     {

   770     CERTMANUILOGGER_ENTERFN(

   771         "CCertManUICertificateHelper::DeleteSingleItemQueryL" );

   772 

   773     TInt selection = 0;

   774 

   775     HBufC* buf = HBufC::NewLC( KMaxLengthTextCertLabel );

   776     buf->Des() = aEntry.Label();

   777     buf->Des().TrimLeft();

   778     // Cut CertLabel after fourth semi colon

   779     TPtrC trimmedCertLabel = CutCertificateField( buf->Des() );

   780     buf->Des().Copy(trimmedCertLabel);

   781     TInt length = buf->Des().Length();

   782     if ( length == 0 )

   783         {

   784         // here the resource name is _NO_LABEL, but it returns only "Delete certificate?"

   785         // not any "No label" or "No subject" string

   786         HBufC* prompt = StringLoader::LoadLC(

   787             R_CONFIRMATION_QUERY_DELETE_CERT_NO_LABEL );

   788         selection = DisplayConfirmationLD( prompt );

   789         }

   790     else

   791         {

   792         HBufC* prompt = StringLoader::LoadLC(

   793             R_CONFIRMATION_QUERY_DELETE_CERT, buf->Des() );

   794         selection = DisplayConfirmationLD(prompt);

   795         }

   796     CleanupStack::PopAndDestroy();  // buf

   797 

   798     CERTMANUILOGGER_LEAVEFN(

   799         "CCertManUICertificateHelper::DeleteSingleItemQueryL" );

   800 

   801     return selection;

   802     }

   803 

   804 

   805 // ---------------------------------------------------------

   806 // CCertManUICertificateHelper::DeleteSingleItemL(CCrCertEntry& aEntry, TInt aPosition, TInt aType)

   807 // Deletes one item from CertManAPI and from listbox

   808 // ---------------------------------------------------------

   809 //

   810 void CCertManUICertificateHelper::DeleteSingleItemL( CCTCertInfo& aEntry,

   811     TInt aPosition,

   812     CEikColumnListBox* aListBox,

   813     TInt aType )

   814     {

   815     CERTMANUILOGGER_ENTERFN(

   816         "CCertManUICertificateHelper::DeleteSingleItemL" );

   817 

   818     TInt status( KErrNone );

   819 

   820     if ( aType == KCertTypeTrustedSite )

   821         {

   822         status = iKeeper.iWrapper->DeleteCertL(

   823                                               iKeeper.CertManager(),

   824                                               aEntry,

   825                                               KCMTrustedServerTokenUid

   826                                               );

   827         }

   828     else if( aType == KCertTypeDevice )

   829         {

   830         status = iKeeper.iWrapper->DeleteCertL(

   831                                               iKeeper.CertManager(),

   832                                               aEntry,

   833                                               KCMDeviceCertStoreTokenUid

   834                                               );

   835         }

   836     else

   837         {

   838         status = iKeeper.iWrapper->DeleteCertL( iKeeper.CertManager(), aEntry );

   839         }

   840 

   841     // Update the list after delete. In case of a error, a note show inside DeleteCertL.

   842     if ( status == KErrNone )

   843         {

   844         MDesCArray *itemList = aListBox->Model()->ItemTextArray();

   845         CDesCArray* itemArray = STATIC_CAST( CDesCArray*, itemList );

   846         itemArray->Delete( aPosition );

   847         }

   848 

   849     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::DeleteSingleItemL" ); //lint !e539

   850     }

   851 

   852 

   853 // ---------------------------------------------------------

   854 // CCertManUICertificateHelper::MoveKeyL(const TCTKeyAttributeFilter& aFilter,

   855 //                       TUid aSourceStore, TUid aSourceStore )

   856 // Moves a key from one store to another

   857 // ---------------------------------------------------------

   858 //

   859 void CCertManUICertificateHelper::MoveKeyL(

   860     const TCTKeyAttributeFilter& aFilter,

   861     const TUid aSourceStore,

   862     const TUid aTargetStore )

   863     {

   864     CERTMANUILOGGER_ENTERFN(

   865         "CCertManUICertificateHelper::MoveCertL" );

   866 

   867     iKeeper.iWrapper->MoveKeyL( iKeeper.KeyManager(), aFilter, aSourceStore, aTargetStore );

   868 

   869     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::MoveCertL" );

   870     }

   871 

   872 

   873 // ---------------------------------------------------------

   874 // CCertManUICertificateHelper::MoveCertL(CCrCertEntry& aEntry,

   875 //                        TInt aPosition, CEikColumnListBox* aListBox,

   876 //                        TUid aSourceStore, TUid aSourceStore )

   877 // Moves a certificate from one store to another

   878 // ---------------------------------------------------------

   879 //

   880 void CCertManUICertificateHelper::MoveCertL( CCTCertInfo& aEntry,

   881     TInt aPosition,

   882     CEikColumnListBox* aListBox,

   883     const TUid aSourceStore,

   884     const TUid aTargetStore )

   885     {

   886     CERTMANUILOGGER_ENTERFN(

   887         "CCertManUICertificateHelper::MoveCertL" );

   888 

   889     TInt certCount(0);

   890 

   891     TRAPD( err, certCount = iKeeper.iWrapper->MoveCertL( iKeeper.CertManager(), aEntry, aSourceStore, aTargetStore ));

   892 

   893     // Update the list after moving the certificate

   894     if ( err == KErrNone )

   895         {

   896         MDesCArray *itemList = aListBox->Model()->ItemTextArray();

   897         CDesCArray* itemArray = STATIC_CAST( CDesCArray*, itemList );

   898         if ( certCount == 1  )

   899             {

   900             // Delete single item

   901             itemArray->Delete( aPosition );

   902             AknListBoxUtils::HandleItemRemovalAndPositionHighlightL(

   903                           aListBox, aPosition, ETrue );

   904             }

   905          else

   906             {

   907             // More than one certificate moved. Empty listbox items.

   908             // It will be updated later

   909             itemArray->Reset();

   910             }

   911         }

   912     else

   913         {

   914         User::Leave( err );

   915         }

   916 

   917     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::MoveCertL" );

   918     }

   919 

   920 

   921 // ---------------------------------------------------------

   922 // CCertManUICertificateHelper::ReadOnlySingleItemNoteL(CCTCertInfo& aEntry)

   923 // Gets the certificate name (or No label/No subject) for the read-only note

   924 // ---------------------------------------------------------

   925 //

   926 void CCertManUICertificateHelper::ReadOnlySingleItemNoteL(CCTCertInfo& aEntry )

   927     {

   928     CERTMANUILOGGER_ENTERFN( "CCertManUICertificateHelper::ReadOnlySingleItemNoteL" );

   929 

   930     HBufC* buf = HBufC::NewLC( KMaxLengthTextCertLabel );

   931     buf->Des() = aEntry.Label();

   932     buf->Des().TrimLeft();

   933     // Cut CertLabel after fourth semi colon

   934     TPtrC trimmedCertLabel = CutCertificateField( buf->Des() );

   935     buf->Des().Copy(trimmedCertLabel);

   936     TInt length = buf->Des().Length();

   937     if ( length == 0 )

   938         {

   939         // here the resource name is _NO_LABEL, but it returns only "Cannot delete certificate"

   940         // not any "No label" or "No subject" string

   941         HBufC* stringHolder = StringLoader::LoadLC(

   942                                 R_INFO_NOTE_TEXT_CERTIFICATE_READ_ONLY_NO_LABEL );

   943         DisplayNoteLD( stringHolder );

   944         }

   945     else

   946         {

   947         HBufC* stringHolder = StringLoader::LoadLC(

   948                                 R_INFO_NOTE_TEXT_CERTIFICATE_READ_ONLY, buf->Des() );

   949         DisplayNoteLD( stringHolder );

   950         }

   951     CleanupStack::PopAndDestroy();  // buf

   952 

   953 

   954     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::ReadOnlySingleItemNoteL" );

   955     }

   956 // ---------------------------------------------------------

   957 // CCertManUICertificateHelper::DisplayConfirmationLD(HBufC* aString)

   958 // Displays Delete yes/no confirmation notes

   959 // ---------------------------------------------------------

   960 //

   961 TInt CCertManUICertificateHelper::DisplayConfirmationLD( HBufC* aString )

   962     {

   963     CERTMANUILOGGER_ENTERFN( "CCertManUICertificateHelper::DisplayConfirmationLD" );

   964 

   965     CAknQueryDialog* dlg = CAknQueryDialog::NewL( CAknQueryDialog::ENoTone );

   966     TInt selection = dlg->ExecuteLD( R_CERTMANUI_CONFIRMATION_QUERY_YES_NO, *aString );

   967     // Takes ownership and destroys aString

   968     CleanupStack::PopAndDestroy();  // aString

   969 

   970     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::DisplayConfirmationLD" );

   971 

   972     return selection;

   973     }

   974 

   975 // ---------------------------------------------------------

   976 // CCertManUICertificateHelper::DisplayNoteLD(HBufC* aString)

   977 // Displays read-only information notes

   978 // ---------------------------------------------------------

   979 //

   980 void CCertManUICertificateHelper::DisplayNoteLD(HBufC* aString)

   981     {

   982     CERTMANUILOGGER_ENTERFN( "CCertManUICertificateHelper::DisplayNoteLD" );

   983 

   984     CAknInformationNote* note = new ( ELeave ) CAknInformationNote( ETrue );

   985     note->ExecuteLD( *aString );

   986     CleanupStack::PopAndDestroy();  // aString

   987 

   988     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::DisplayNoteLD" );

   989     }

   990 

   991 // ---------------------------------------------------------

   992 // CCertManUICertificateHelper::FFSSpaceBelowCriticalLevelL

   993 // Handle deleting when disk is getting full

   994 // ---------------------------------------------------------

   995 //

   996 TBool CCertManUICertificateHelper::FFSSpaceBelowCriticalLevelL(

   997     TBool aShowErrorNote, TInt aBytesToWrite )

   998     {

   999     CERTMANUILOGGER_ENTERFN(

  1000         "CCertManUICertificateHelper::FFSSpaceBelowCriticalLevelL" );

  1001 

  1002     TBool ret = EFalse;

  1003     if ( SysUtil::FFSSpaceBelowCriticalLevelL(

  1004         &(CCoeEnv::Static()->FsSession()), aBytesToWrite ) )

  1005         {

  1006         ret = ETrue;

  1007         if ( aShowErrorNote )

  1008             {

  1009             CErrorUI* errorUi = CErrorUI::NewLC( *(CCoeEnv::Static()) );

  1010             errorUi->ShowGlobalErrorNoteL( KErrDiskFull );

  1011             CleanupStack::PopAndDestroy();  // errorUi

  1012             }

  1013         }

  1014 

  1015     CERTMANUILOGGER_LEAVEFN(

  1016         "CCertManUICertificateHelper::FFSSpaceBelowCriticalLevelL" );

  1017 

  1018     return ret;

  1019     }

  1020 // ---------------------------------------------------------

  1021 // CCertManUICertificateHelper::HandleMarkableListCommandL( TInt aCommand )

  1022 // Handles marking and unmarking of the list.

  1023 // ---------------------------------------------------------

  1024 //

  1025 void CCertManUICertificateHelper::HandleMarkableListCommandL( TInt aCommand,

  1026                                                     CEikColumnListBox* aListBox )

  1027     {

  1028     CERTMANUILOGGER_ENTERFN(

  1029         "CCertManUICertificateHelper::HandleMarkableListCommandL" );

  1030 

  1031     TInt index;

  1032     switch ( aCommand )

  1033         {

  1034         case ECertManUICmdMark:

  1035             {

  1036             index = aListBox->CurrentItemIndex();

  1037             if ( index >= 0 )

  1038                 {

  1039                 // This is done to make sure listbox updates its state

  1040                 // to make shift+arrow work correctly after shift+ok

  1041                 aListBox->View()->UpdateSelectionL( CListBoxView::EDisjointSelection );

  1042                 aListBox->View()->SelectItemL( index );

  1043                 }

  1044             break;

  1045             }

  1046         case ECertManUICmdUnmark:

  1047             {

  1048             index = aListBox->CurrentItemIndex();

  1049             if ( index >= 0 )

  1050                 {

  1051                 // This is done to make sure listbox updates its state

  1052                 // to make shift+arrow work correctly after shift+ok

  1053                 aListBox->View()->UpdateSelectionL(

  1054                       CListBoxView::EDisjointSelection );

  1055                 aListBox->View()->DeselectItem( index );

  1056                 }

  1057             break;

  1058             }

  1059         case ECertManUICmdMarkAll:

  1060             {

  1061             aListBox->ClearSelection();

  1062             TInt count = aListBox->Model()->NumberOfItems();

  1063             if ( count )

  1064                 {

  1065                 CArrayFixFlat<TInt>* selection =

  1066                     new( ELeave ) CArrayFixFlat<TInt>( 1 );

  1067                 CleanupStack::PushL( selection );

  1068                 selection->SetReserveL( count );

  1069                 for( TInt i = 0; i < count; i++ )

  1070                     {

  1071                     selection->AppendL( i );

  1072                     }

  1073                 aListBox->SetSelectionIndexesL( selection );

  1074                 CleanupStack::PopAndDestroy();  // selection

  1075                 }

  1076             break;

  1077             }

  1078         case ECertManUICmdUnmarkAll:

  1079             {

  1080             aListBox->ClearSelection();

  1081             break;

  1082             }

  1083         default:

  1084       break;

  1085       }

  1086 

  1087     CERTMANUILOGGER_LEAVEFN(

  1088         "CCertManUICertificateHelper::HandleMarkableListCommandL" );

  1089     }

  1090 

  1091 // ---------------------------------------------------------

  1092 // CCertManUICertificateHelper::GetKeyUsageAndLocationL( CCTCertInfo* aCertEntry,

  1093 //                                                      TUid* aKeyLocation)

  1094 // Returns key usage and location.

  1095 // ---------------------------------------------------------

  1096 //

  1097 TKeyUsagePKCS15 CCertManUICertificateHelper::GetKeyUsageAndLocationL( CCTCertInfo* aCertEntry,

  1098                                                                      TUid* aKeyLocation )

  1099     {

  1100     TKeyUsagePKCS15 keyUsage;

  1101 

  1102     CERTMANUILOGGER_ENTERFN( "CCertManUICertificateHelper::GetKeyUsageAndLocationL" );

  1103 

  1104     // Check whether we have key for this certificate

  1105     RMPointerArray<CCTKeyInfo> keyEntry;

  1106     TCTKeyAttributeFilter filter;

  1107     filter.iKeyId = aCertEntry->SubjectKeyId();

  1108 

  1109     iKeeper.iWrapper->ListL( iKeeper.KeyManager(), &keyEntry, filter );

  1110 

  1111     if (keyEntry.Count())

  1112         {

  1113         keyUsage = keyEntry[0]->Usage();

  1114         // Get Location

  1115         aKeyLocation->iUid = keyEntry[0]->Token().TokenType().Type().iUid ;

  1116         }

  1117     else

  1118         {

  1119         keyUsage = EPKCS15UsageNone;

  1120         }

  1121 

  1122     keyEntry.Close();

  1123     LOG_WRITE_FORMAT( "Key usage : %X", keyUsage );

  1124     CERTMANUILOGGER_LEAVEFN( "CCertManUICertificateHelper::GetKeyUsageAndLocationL" );

  1125     return keyUsage;

  1126     }

  1127 

  1128 // ---------------------------------------------------------

  1129 // CCertManUICertificateHelper::SetLocationInfoL( (HBufC& aMessage,

  1130 //                                               TBool aCertificate,

  1131 //                                               TUid* aLocUid)

  1132 // Adds certificate/private key's location info to certificate details

  1133 // ---------------------------------------------------------

  1134 //