FCL/sf/mw/securitysrv: comparison pkiutilities/CertSaver/src/CertSaverModel.cpp

equal deleted inserted replaced

-:09b1ac925e3f
+:03674e5abf46
 * Description:   Class that handles user input and launching of dialogs
 *
 */
+// INCLUDE FILES
+#include <aknnotewrappers.h>        // Note dialogs
+#include <aknmessagequerydialog.h>  // For CAknMessageQueryDialog
 #include <StringLoader.h>           // For loading resource strings
 #include <unifiedcertstore.h>       // For saving the certificates
 #include <mctwritablecertstore.h>   // For saving the certificates
 #include <sysutil.h>                // For FFSSpaceBelowCriticalLevelL(..)
 #include <X509CertNameParser.h>     // For default label
 #include <asnpkcs.h>
 #include <unifiedkeystore.h>
 #include <x509certext.h>
 #include <mctkeystore.h>
 #include <TrustedSitesStore.h>
-#include <eikenv.h>                 // CEikonEnv
-#include <AknUtils.h>               // AknTextUtils
 #include <CertSaver.rsg>
 #include "CertSaverModel.h"
 #include "CertSaverDocument.h"
 #include "CertSaverAppUi.h"
 #include "CertSaverSyncWrapper.h"
 #include "certsaver.hrh"
 #include "securityuisvariant.hrh"
-#include <hbdevicemessageboxsymbian.h>
-#include <hbdevicenotificationdialogsymbian.h>
-#include <hbsymbianvariant.h>
-#include "SecQueryUi.h"                   // needed for label dialog
 // CONSTANTS
 const TInt32 KWTLSTrusterUID( 268479059 );
 const TInt32 KInternetTrusterUID( 268441661 );
 const TInt32 KApplicationControllerTrusterUID( 268452523 );
 const TInt32 KJavaInstallTrusterUID( 270506792 );
 const TInt32 KOCSPTrusterUID( 268478646 );
 const TInt KTrusterArrayInitSize( 2 );
 const TInt KMaxLengthTextMeassageBody( 5000 );
 const TInt KMaxLengthTextDateString( 11 );    // "dd/mm/yyyy0"
-const TInt KMaxLengthTextCheckBoxData( 255 );    // "dd/mm/yyyy0"
 //Issuer and Owner max visible length
 const TInt KMaxLengthTextCertIdentifierVisible( 1000 );
 const TInt KAttempts( 3 );
 const TInt KFingerprintLength( 50 );
-const TInt KTokenLength( 32 );
 _LIT( KCertSaverListBoxItemPrefix, "1\t" );
 const TInt KItemBufLen = 2 + KMaxName;
 _LIT( KPrivateKeyLabel, "PrivateKey " );
 void CCertSaverModel::SaveCertificateL(
 const CX509Certificate& aCertificate,
 const TCertificateOwnerType& aOwnerType,
 const TCertificateFormat& aCertFormat )
 {
 iCertOwnerType = aOwnerType;
 iCertFormat = aCertFormat;
 iNewCert = &aCertificate;
 if ( aOwnerType == EPeerCertificate )
 //
 // ----------------------------------------------------------
 //
 void CCertSaverModel::DoSavePrivateKeyL( const TDesC8& aKey )
 {
 CheckFSSpaceL( aKey );
 TKeyIdentifier keyIdentifier;
 CDecPKCS8Data* pkcs8Data = TASN1DecPKCS8::DecodeDERL( aKey );
 CleanupStack::PushL( pkcs8Data );
 TBuf<KPrivaKeyLabelLength> keyLabel( KPrivateKeyLabel );
 TKeyUsagePKCS15 keyUsage = KeyUsageL( keyIdentifier, pkcs8Data->Algorithm() );
 CleanupStack::PopAndDestroy( pkcs8Data );
 if (KeyAlreadyExistsL( startDate, endDate, keyIdentifier, keyUsage) )
 {
-// used to leave with error none
+User::Leave( KErrNone );
-return;
 }
 TInt accessType( 0 );
 accessType |= CCTKeyInfo::EExtractable;
 break;
 }
 case KErrKeySize:
 case KErrArgument:
 {
-ShowInformationNoteL( R_CERTSAVER_KEY_TYPE_NOT_SUPPORTED );
+ShowErrorNoteL( R_CERTSAVER_KEY_TYPE_NOT_SUPPORTED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrKeyValidity:
 {
 ShowInformationNoteL( R_CERTSAVER_QTN_CM_PKCS12_EXPIRED );
 User::Leave( KErrCancel );
 }
 case KErrKeyUsage:
 {
-ShowInformationNoteL( R_CERTSAVER_PRIVATE_KEY_CORRUPTED );
+ShowErrorNoteL( R_CERTSAVER_PRIVATE_KEY_CORRUPTED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrCancel:
 case KErrPermissionDenied:
 {
-ShowInformationNoteL( R_CERTSAVER_PKCS12_DISCARDED );
+ShowErrorNoteL( R_CERTSAVER_PKCS12_DISCARDED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrCorrupt:
 case KErrEof:
 {
-ShowInformationNoteL( R_CERTSAVER_KEYSTORE_CORRUPTED );
+ShowErrorNoteL( R_CERTSAVER_KEYSTORE_CORRUPTED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrAlreadyExists:
 {
 TTime& aStartDate,
 TTime& aEndDate,
 const TKeyIdentifier& aKeyIdentifier,
 TKeyUsagePKCS15& aKeyUsage )
 {
 TBool ret = EFalse;
 TCTKeyAttributeFilter keyFilter;
 keyFilter.iKeyAlgorithm = CKeyInfoBase::EInvalidAlgorithm;
 keyFilter.iKeyId = aKeyIdentifier;
 keyFilter.iPolicyFilter = TCTKeyAttributeFilter::EManageableKeys;
 break;
 }
 case KErrCorrupt:
 case KErrEof:
 {
-ShowInformationNoteL( R_CERTSAVER_KEYSTORE_CORRUPTED );
+ShowErrorNoteL( R_CERTSAVER_KEYSTORE_CORRUPTED );
 User::Leave( KErrCancel );
 }
 default:
 {
 User::Leave( err );
 TTime& aStartDate,
 TTime& aEndDate,
 const TKeyIdentifier& aKeyIdentifier )
 {
 for ( TInt i = 0; i < iParser.UserCertificates().Count(); i++ )
 {
 const CX509Certificate* cert = iParser.UserCertificates().At( i );
 if ( cert->KeyIdentifierL() == aKeyIdentifier )
 {
 //
 // ----------------------------------------------------------
 //
 void CCertSaverModel::CreateKeyLabelL( TDes& aLabel )
 {
 TTime time;
 time.UniversalTime();
 TBuf<KPrivaKeyLabelLength> dateBuf;
 time.FormatL( dateBuf, KDateString );
 aLabel.Append( dateBuf );
 //
 // ----------------------------------------------------------
 //
 void CCertSaverModel::SavePrivateKeyL()
 {
 if ( iParser.Keys().Count() <= 0 )
 {
 return;
 }
 if ( NULL == iWrapper )
 //
 TKeyUsagePKCS15 CCertSaverModel::KeyUsageL(
 const TKeyIdentifier& aKeyIdentifier,
 TAlgorithmId aAlgorithm )
 {
 TKeyUsagePKCS15 pkcs15KeyUsage = EPKCS15UsageNone;
 TKeyUsageX509 x509Usage = EX509UsageNone;
 for ( TInt i = 0; i < iParser.UserCertificates().Count(); i++ )
 //    const TDesC8& aDataToSave)
 // ----------------------------------------------------------
 //
 void CCertSaverModel::CheckFSSpaceL( const TDesC8& aDataToSave )
 {
 if (SysUtil::FFSSpaceBelowCriticalLevelL( &iFs, aDataToSave.Size() ))
 {
-ShowInformationNoteL(R_CERTSAVER_MEMORY);
+HBufC* p = StringLoader::LoadLC( R_CERTSAVER_MEMORY );
+CAknErrorNote* note = new (ELeave) CAknErrorNote( ETrue );
+note->ExecuteLD( p->Des() );
+CleanupStack::PopAndDestroy( p );
 User::Leave( KErrExitApp );
 }
 }
 // ----------------------------------------------------------
 // CCertSaverModel::SaveCertL()
 // Saves certificate
 // ----------------------------------------------------------
 //
 void CCertSaverModel::SaveCertL()
 {
 if ( !CertificateOkL() )
 {
 User::Leave( KErrCancel );
 }
 HBufC* message = HBufC::NewLC( KMaxLengthTextMeassageBody );
 TPtr msgPtr = message->Des();
 ConstructMessageL( msgPtr );
-CHbDeviceMessageBoxSymbian::TButtonId selection =
+CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *message );
-CHbDeviceMessageBoxSymbian::QuestionL(msgPtr, KNullDesC, KNullDesC);
+CleanupStack::PopAndDestroy( message );
-TBool doSave= (selection == CHbDeviceMessageBoxSymbian::EAcceptButton);
+CleanupStack::PushL( dlg );
-CleanupStack::PopAndDestroy(message);
-/*
+dlg->PrepareLC( R_MESSAGE_QUERY_DOSAVE );
+HBufC* header = StringLoader::LoadLC( R_CERTSAVER_DETAILS_HEADING );
+dlg->QueryHeading()->SetTextL( header->Des() );
+CleanupStack::PopAndDestroy( header );
+CleanupStack::Pop( dlg );
+TBool doSave = dlg->RunLD();
 if ( doSave && iCertOwnerType == ECACertificate )
 {
 // warn user about security risk
-HBufC* stringHolder = StringLoader::LoadLC( R_CERTSAVER_WARNING_NOTE );
+CAknQueryDialog* warningDialog = CAknQueryDialog::NewL();
-CHbDeviceMessageBoxSymbian::TButtonId selection =
+doSave = warningDialog->ExecuteLD( R_CERTSAVER_WARNING_NOTE );
-CHbDeviceMessageBoxSymbian::QuestionL(stringHolder->Des(),KNullDesC, KNullDesC);
+}
-CleanupStack::PopAndDestroy(stringHolder);
-	    doSave=(selection == CHbDeviceMessageBoxSymbian::EAcceptButton);
-}
-*/
 if ( doSave )
 {
-//Check that there still is enough space to store the certificate.
+//Check that there still is enough space to store the
+//certificate.
 CheckFSSpaceL( iNewCert->Encoding() );
 DoSaveCertL();
 }
 else
 {
-ShowInformationNoteL(R_CERTSAVER_CERT_DISCARDED);
+ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
 User::Leave( KErrCancel );
 }
 }
 // ----------------------------------------------------------
 // CCertSaverModel::InitCertStoreL()
 //
 // ----------------------------------------------------------
 //
 void CCertSaverModel::InitCertStoreL()
 {
 if ( !iUnifiedCertStore )
 {
 TRAPD( status, iUnifiedCertStore = CUnifiedCertStore::NewL( iFs, ETrue ) );
 if ( status != KErrNone )
 {
-ShowInformationNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
 User::Leave( KErrExitApp );
 }
 // initialize unified cert store
 status = iWrapper->InitializeCertStore( *iUnifiedCertStore );
 if ( status )
 // Tries to save the certificate to phone memory.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::DoSaveCertL()
 {
 TInt status = KErrNone;
 CCertAttributeFilter* filter = NULL;
 TCertificateFormat certFormat = EX509Certificate;
 HBufC* secondaryName = NULL;
 TCertLabel labelBuf;
 MCTWritableCertStore& writableCertStore =
 iUnifiedCertStore->WritableCertStore( i );
 MCTToken& token = writableCertStore.Token();
 TUid tokenuid = token.Handle().iTokenTypeUid;
-if ( ( tokenuid == KTrustedServerTokenUid ) &&
+if ( ( tokenuid == KTrustedServerTokenUid ) && ( iCertOwnerType == EPeerCertificate ) ||
-( iCertOwnerType == EPeerCertificate ) ||
 ( tokenuid == KFileTokensUid ) && ( iCertOwnerType == ECACertificate ) ||
 ( tokenuid == KFileTokensUid ) && ( iCertOwnerType == EUserCertificate ) )
 {
 certstoreIndex = i;
 break;
 }
 if ( certstoreIndex < 0 )
 {
 // Couldn't find certificate storage
-ShowInformationNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
 User::Leave( KErrExitApp );
 }
 status = iWrapper->AddCert( iUnifiedCertStore->WritableCertStore( certstoreIndex ),
 labelBuf, iCertFormat, iCertOwnerType, 0, 0, iNewCert->Encoding() );
 }
 else
 {
 // If there is none WritableCertStore,
 // then at least cacerts.dat is corrupted.
-ShowInformationNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
 User::Leave( KErrExitApp );
 }
 if ( ECACertificate == iCertOwnerType )
 {
 // already exist.
 // ----------------------------------------------------------
 //
 TInt CCertSaverModel::QueryLabelL( TCertLabel& aLabel, CUnifiedCertStore& aStore )
 {
 CCertAttributeFilter* filter = NULL;
 TInt status = KErrNone;
 RMPointerArray<CCTCertInfo> entries;
 TBool loop = ETrue;
 while ( loop )
 {
-HBufC* labelprompt =  CEikonEnv::Static()->AllocReadResourceLC( R_CERTSAVER_ENTER_LABEL );
+CAknTextQueryDialog* dialog = CAknTextQueryDialog::NewL( aLabel );
-CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
+if ( !dialog->ExecuteLD( R_CERTSAVER_LABEL_QUERY ) )
-TInt queryAccepted = SecQueryUi->SecQueryDialog(labelprompt->Des(), aLabel,
-1,KMaxCertLabelLength,
-ESecUiAlphaSupported |
-ESecUiCancelSupported |
-ESecUiEmergencyNotSupported);
-CleanupStack::PopAndDestroy( labelprompt );
-delete SecQueryUi;
-SecQueryUi=NULL;
-if ( queryAccepted!=KErrNone )
 {
 // cancel
-ShowInformationNoteL(R_CERTSAVER_CERT_DISCARDED);
+ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
 return KErrCancel;
 }
 // Create filter to confirm that label doesn't already exist.
 filter = CCertAttributeFilter::NewL();
 filter->SetLabel( aLabel );
 // of the save operation.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::HandleSaveErrorL( TInt aStatus ) const
 {
 switch ( aStatus )
 {
 case KErrNone:
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_SAVEOK);
+ShowConfirmationNoteL( R_CERTSAVER_ERROR_SAVEOK );
 break;
 }
 case KErrNotSupported:
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_UNSUPPORTED_CERT);
+ShowErrorNoteL( R_CERTSAVER_ERROR_UNSUPPORTED_CERT );
 break;
 }
 case KErrBadName:
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_LABEL_ALREADY_EXISTS);
+ShowErrorNoteL( R_CERTSAVER_ERROR_LABEL_ALREADY_EXISTS );
 break;
 }
 case KErrAlreadyExists:
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_ALREADY_EXISTS);
+ShowErrorNoteL( R_CERTSAVER_ERROR_ALREADY_EXISTS );
 break;
 }
 case KErrArgument:
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED);
+ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
 break;
 }
 default:
 {
 //No error note defined for unknown error.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::AddToMessageWithStringL(
 TDes& aMessage, TInt aStringResID, const TDesC& aString ) const
 {
 HBufC* promptPtr = NULL;
 promptPtr = StringLoader::LoadL( aStringResID, aString );
 CleanupStack::PushL( promptPtr );
 TPtrC prompt( promptPtr->Des() );
 void CCertSaverModel::AddToMessageWithIntL(
 TDes& aMessage,
 TInt aStringResID,
 TInt aInt ) const
 {
 HBufC* promptPtr = NULL;
 promptPtr = StringLoader::LoadL( aStringResID, aInt );
 CleanupStack::PushL( promptPtr );
 TPtrC prompt( promptPtr->Des() );
 // String loaded from resources with StringLoader.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::AddToMessageL( TDes& aMessage, TInt aStringResID ) const
 {
 HBufC* promptPtr = NULL;
 promptPtr = StringLoader::LoadL( aStringResID );
 CleanupStack::PushL( promptPtr );
 TPtrC prompt( promptPtr->Des() );
 // Creates the certificate details message shown to the user.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::ConstructMessageL( TDes& aMessage ) const
 {
 HBufC16* issuerName = NULL;
 HBufC16* subjectName = NULL;
 X509CertNameParser::SubjectFullNameL( *((CX509Certificate*)iNewCert),
 // CCTSecurityDialogsAO::AddKeyUsageL(...)
 // -----------------------------------------------------------------------------
 //
 void CCertSaverModel::AddKeyUsageL( TDes& aMessage, const CX509Certificate& aCert ) const
 {
 TKeyUsageX509 x509Usage = EX509UsageNone;
 TKeyUsagePKCS15 pkcs15KeyUsage = EPKCS15UsageNone;
 const CX509CertExtension* ext = aCert.Extension( KKeyUsage );
 if (ext)
 {
 // -----------------------------------------------------------------------------
 //
 void CCertSaverModel::AddValidityPeriodL(
 TDes& aMessage, const CX509Certificate& aCert ) const
 {
 // Hometime's offset to UTC
 TLocale locale;
 TTimeIntervalSeconds offSet = locale.UniversalTimeOffset();
 AddToMessageL( aMessage, R_CERTSAVER_QTN_CM_VALID_FROM );
 dateFormatString = iAppUi->CoeEnv()->AllocReadResourceLC(
 R_QTN_DATE_USUAL_WITH_ZERO );
 // format the date to user readable format. The format is locale dependent
 finishValue.FormatL( finishString, *dateFormatString );
 AknTextUtils::DisplayTextLanguageSpecificNumberConversion( finishString );
-CleanupStack::PopAndDestroy(dateFormatString); // dateFormatString
+CleanupStack::PopAndDestroy(); // dateFormatString
 aMessage.Append( finishString );
 AddNewlinesToMessage( aMessage );
 }
 // ----------------------------------------------------------
 // Adds two new lines to message.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::AddNewlinesToMessage( TDes& aMessage ) const
 {
 aMessage.Append( KDoubleEnter );
 }
 // ----------------------------------------------------------
 // CCertSaverModel::CertificateSupported() const
 // Checks that cert is of supported type.
 // ----------------------------------------------------------
 //
 TBool CCertSaverModel::CertificateSupported() const
 {
 if ( iCertFormat == EX509Certificate &&
 ( iCertOwnerType == ECACertificate ||
 iCertOwnerType == EPeerCertificate ||
 iCertOwnerType == EUserCertificate))
 {
 // certificate.
 // ----------------------------------------------------------
 //
 TBool CCertSaverModel::CertificateOkL() const
 {
+if ( !CertificateSupported() )
-if ( !CertificateSupported() )
+{
-{
+ShowErrorNoteL( R_CERTSAVER_ERROR_UNSUPPORTED_CERT );
-ShowInformationNoteL(R_CERTSAVER_ERROR_UNSUPPORTED_CERT);
 return EFalse;
 }
 if ( CertNotValidAnymore() )
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_CERT_NOT_VALID);
+ShowErrorNoteL( R_CERTSAVER_ERROR_CERT_NOT_VALID );
 return ETrue;
 }
 else if ( CertNotValidYet() )
 {
-ShowInformationNoteL(R_CERTSAVER_ERROR_CERT_NOT_VALID_YET);
+ShowErrorNoteL( R_CERTSAVER_ERROR_CERT_NOT_VALID_YET );
 }
 return ETrue;
 }
 // ----------------------------------------------------------
 // Checks if cert isn't valid anymore.
 // ----------------------------------------------------------
 //
 TBool CCertSaverModel::CertNotValidAnymore() const
 {
 TTime homeTime;
 homeTime.HomeTime();
 if ( iNewCert->ValidityPeriod().Finish() < homeTime )
 {
 return ETrue;
 // Checks if cert isn't valid yet.
 // ----------------------------------------------------------
 //
 TBool CCertSaverModel::CertNotValidYet() const
 {
 TTime homeTime;
 homeTime.HomeTime();
 if ( iNewCert->ValidityPeriod().Start() > homeTime )
 {
 return ETrue;
 // Creates and shows a confirmation note.
 // ----------------------------------------------------------
 //
 void CCertSaverModel::ShowInformationNoteL( TInt aResourceID ) const
 {
 HBufC* buffer = iAppUi->CoeEnv()->AllocReadResourceLC( aResourceID );
-CHbDeviceMessageBoxSymbian* iMessageBox = CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EInformation);
+CAknInformationNote* note = new (ELeave) CAknInformationNote( ETrue );
-CleanupStack::PushL(iMessageBox);
+note->ExecuteLD( buffer->Des() );
-iMessageBox->SetTextL(buffer->Des());
+CleanupStack::PopAndDestroy( buffer );
-iMessageBox->SetTimeout(6000);
+}
-iMessageBox->ExecL();
+// ----------------------------------------------------------
-CleanupStack::PopAndDestroy(iMessageBox);
+// CCertSaverModel::ShowConfirmationNoteL() const
-CleanupStack::PopAndDestroy( buffer );
+// Creates and shows a confirmation note.
+// ----------------------------------------------------------
+//
+void CCertSaverModel::ShowConfirmationNoteL( TInt aResourceID ) const
+{
+HBufC* buffer = iAppUi->CoeEnv()->AllocReadResourceLC( aResourceID );
+CAknConfirmationNote* note = new (ELeave) CAknConfirmationNote( ETrue );
+note->ExecuteLD( buffer->Des() );
+CleanupStack::PopAndDestroy( buffer );
+}
+// ----------------------------------------------------------
+// CCertSaverModel::ShowErrorNoteL() const
+// Creates and shows an error note.
+// ----------------------------------------------------------
+//
+void CCertSaverModel::ShowErrorNoteL( TInt aResourceID ) const
+{
+HBufC* buffer = iAppUi->CoeEnv()->AllocReadResourceLC( aResourceID );
+CAknErrorNote* note = new (ELeave) CAknErrorNote( ETrue );
+note->ExecuteLD(buffer->Des());
+CleanupStack::PopAndDestroy( buffer );
 }
 // ----------------------------------------------------------
 // CCertSaverModel::TrimCertificateFields() const
 // Trims given descriptor so that everything after and
 // Returns the trimmed certificate field.
 // ----------------------------------------------------------
 //
 TPtrC CCertSaverModel::TrimCertificateFields( TPtrC aField ) const
 {
 TPtrC cutField = CutCertificateField( aField );
 // Find one semicolon at a time and crop the
 // helpField from the left to search for the next semicolon
 TInt position = cutField.Locate( ';' ); // 1st semicolon
 TInt fieldLength = cutField.Length();
 // this function cuts it.
 // ----------------------------------------------------------
 //
 TPtrC CCertSaverModel::CutCertificateField( TPtrC aField ) const
 {
 TInt fieldLength = aField.Length();
 if ( fieldLength >= KMaxLengthTextCertIdentifierVisible )
 {
 TPtrC cutCertLabel = aField.Mid( 0, KMaxLengthTextCertIdentifierVisible );
 return cutCertLabel;
 // Does needed tasks to exit.
 // ----------------------------------------------------------
 //
 TInt CCertSaverModel::QueryTrusterUidsL( RArray<TUid>& aUids )
 {
 TInt ret = KErrCancel;
+CArrayFixFlat<TInt>* selectionArray =
+new (ELeave)  CArrayFixFlat<TInt>( KTrusterArrayInitSize );
+CleanupStack::PushL( selectionArray );
 CDesCArray* itemsArray = new (ELeave) CDesCArrayFlat( KTrusterArrayInitSize );
 CleanupStack::PushL( itemsArray );
 CCertificateAppInfoManager* appInfoManager =
 CCertificateAppInfoManager::NewL( iFs, EFalse );
 const RArray<TCertificateAppInfo>& apps = appInfoManager->Applications();
 RArray<TCertificateAppInfo> appsInItemArray( KTrusterArrayInitSize );
 CleanupClosePushL( appsInItemArray );
 UpdateTrustListboxItemL( apps, appsInItemArray, *itemsArray );
-HBufC* title = CEikonEnv::Static()->AllocReadResourceLC( R_CERTSAVER_SELECT_TRUSTED_APPS);
+CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog( selectionArray );
+CleanupStack::PushL( dlg );
-RBuf rBuf;     // buffer for items with big enough space
+dlg->PrepareLC( R_CERTSAVER_TRUST_SETTINGS_QUERY );
-rBuf.CreateL(KMaxLengthTextMeassageBody);
+dlg->SetItemTextArray( itemsArray );
-CleanupClosePushL(rBuf);
+dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );
-for(TInt i = 0; i<itemsArray->Count(); i++)
+if ( dlg->RunLD() )
-rBuf.Append( (*itemsArray)[i] );
+{
+aUids.Reset();
-CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
+for ( TInt i = 0; i < selectionArray->Count(); ++i )
-TInt saved = SecQueryUi->SecQueryDialog(*title, rBuf,1,KTokenLength,
+{
-ESecUiAlphaSupported | ESecUiCancelSupported |
+TInt ii = (*selectionArray)[ i ];
-ESecUiBasicTypeMultiCheck |
+aUids.Append( appsInItemArray[ ii ].Id() );
-ESecUiEmergencyNotSupported);
+}
-delete SecQueryUi;
-SecQueryUi=NULL;
-if (saved==KErrNone)
-{
-TLex16 lex(rBuf);
-TChar ch;
-TBuf16<KTokenLength> token;
-TInt  val;
-while((ch = lex.Get()) != 0 ){
-while ((ch = lex.Peek()) != '|' && ch!=0) lex.Inc();
-token.Copy(lex.MarkedToken());
-TLex lexc(token);
-if(lexc.Val(val)!=KErrNone) val=0;
-if(val<=appsInItemArray.Count()-1)
-aUids.Append( appsInItemArray[ val ].Id() );
-lex.Inc();
-lex.Mark();
-}
 ret = KErrNone;
 }
 else
 {
-ShowInformationNoteL(R_CERTSAVER_CERT_DISCARDED);
+ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
 ret = KErrCancel;
 }
+CleanupStack::Pop( dlg );
-rBuf.Close();
+CleanupStack::PopAndDestroy( 4, selectionArray );
-CleanupStack::PopAndDestroy(&rBuf);
-CleanupStack::PopAndDestroy(title);
-CleanupStack::PopAndDestroy(&appsInItemArray);
-CleanupStack::PopAndDestroy(appInfoManager);
-CleanupStack::PopAndDestroy(itemsArray);
 return ret;
 }
 // ----------------------------------------------------------
 // CCertSaverModel::QueryTrustedSiteL()
 // Shows query for trusted site certificate
 // ----------------------------------------------------------
 //
 TInt CCertSaverModel::QueryTrustedSiteL()
 {
 TInt ret = KErrCancel;
 HBufC* label = NULL;
 HBufC* secondaryName = NULL;
 TCertLabel labelBuf;
 (*(CX509Certificate*)iNewCert), label, secondaryName );
 CleanupStack::PushL( label );
 delete secondaryName;
 secondaryName = NULL;
 labelBuf = label->Des().Left( CERTSAVER_MAX_LABEL_LEN );
 HBufC* prompt = StringLoader::LoadLC( R_CERTSAVER_TRUSTEDSITE_WARNING, labelBuf );
-CHbDeviceMessageBoxSymbian::TButtonId selection =
-CHbDeviceMessageBoxSymbian::QuestionL(prompt->Des(), KNullDesC, KNullDesC);
+CAknMessageQueryDialog* note = CAknMessageQueryDialog::NewL( *prompt );
-if ( selection == CHbDeviceMessageBoxSymbian::EAcceptButton)
+note->PrepareLC( R_CERTSAVER_TRUSTED_SITE_QUERY );
+note->SetPromptL( *prompt );
+if ( note->RunLD() )
 {
 ret = KErrNone;
 }
 else
 {
-ShowInformationNoteL(R_CERTSAVER_CERT_DISCARDED);
+ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
 ret = KErrCancel;
 }
 CleanupStack::PopAndDestroy( prompt );
 CleanupStack::PopAndDestroy( label );
 return ret;
 }
 // ----------------------------------------------------------
 void CCertSaverModel::UpdateTrustListboxItemL(
 const RArray<TCertificateAppInfo>& aApps,
 RArray<TCertificateAppInfo>& aAppsInItemArray,
 CDesCArray& aItemsArray ) const
 {
 for ( TInt i = 0; i < aApps.Count(); i++ )
 {
 TCertificateAppInfo appInfo = aApps[ i ];
 TBuf<KItemBufLen> item;
 item.Append( KCertSaverListBoxItemPrefix );
 // CCertManUIViewAuthority::DevideToBlocks
 // ---------------------------------------------------------
 //
 void CCertSaverModel::DivideToBlocks( const TDesC8& aInput, TDes& aOutput ) const
 {
 _LIT( KBlockSeparator, " " );
 const TInt KBlockLength = 2;
 TInt blockIndex = 0;
 for ( TInt j = 0 ; j < aInput.Length() ; j++ )
 {
 // Saves content of the PKCS#12 file
 // ----------------------------------------------------
 //
 void CCertSaverModel::SavePKCS12L()
 {
 HBufC* message = HBufC::NewLC( KMaxLengthTextMeassageBody );
 TPtr msgPtr = message->Des();
 ConstructPKCS12QueryMsgL(msgPtr, iParser.Keys().Count(),
 iParser.UserCertificates().Count(),
 iParser.CACertificates().Count() );
+TBool save = DoMessageQueryL(
-//TODO: Should be in loc file but hardcoded now
+R_MESSAGE_QUERY_DOSAVE, R_CERTSAVER_HEADER_PKCS12_FILE_CONTAINS,
-_LIT(KCheckBoxCaption,"Protect with Password|1");
+*message );
-TBuf<KMaxLengthTextCheckBoxData> CheckeBoxData(KCheckBoxCaption);
+CleanupStack::PopAndDestroy( message );
-CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
-TInt save = SecQueryUi->SecQueryDialog(*message, CheckeBoxData,1,1,
-ESecUiAlphaSupported | ESecUiCancelSupported |
-ESecUiBasicTypeCheck | ESecUiEmergencyNotSupported);
-CleanupStack::Pop(message);
 message = NULL;
-delete SecQueryUi;
+if ( !save )
-SecQueryUi=NULL;
-if ( save!=KErrNone )
 {
 ShowInformationNoteL( R_CERTSAVER_PKCS12_DISCARDED );
 User::Leave( KErrExitApp );
 }
 TInt status = KErrNone;
 // save private keys
-if(CheckeBoxData.Compare(_L("1"))==0)
+TRAP( status, SavePrivateKeyL() );
-{
-TRAP( status, SavePrivateKeyL() );
-}
 // save user certificates if private key was saved.
 if ( ( iSavedKeysCount > 0 || iKeyAlreadyExists ) && iParser.UserCertificates().Count() > 0 )
 {
 for ( TInt i = 0; i < iParser.UserCertificates().Count(); i++ )
 {
 {
 User::Leave( KErrExitApp );
 }
 }
 }
-/*
 if ( iSavedCACertsCount != 0 || iSavedKeysCount != 0
 || iSavedUserCertsCount != 0 )
 {
-// show how many have been saved
+message = HBufC::NewLC( KMaxLengthTextMeassageBody );
-HBufC* p = StringLoader::LoadLC( R_CERTSAVER_HEADER_SAVED );
+TPtr msgPtr2 = message->Des();
-message = HBufC::NewLC( KMaxLengthTextMeassageBody );
+ConstructPKCS12QueryMsgL(
-message->Des().Append(p->Des());
-TPtr msgPtr2 = message->Des();
-ConstructPKCS12QueryMsgL(
 msgPtr2, iSavedKeysCount, iSavedUserCertsCount, iSavedCACertsCount );
-CHbDeviceMessageBoxSymbian::InformationL(message->Des());
+DoMessageQueryL(
-CleanupStack::PopAndDestroy( message );
+R_MESSAGE_QUERY_SAVED, R_CERTSAVER_HEADER_SAVED, *message );
-CleanupStack::PopAndDestroy( p );
+CleanupStack::PopAndDestroy( message );
 }
 else
 {
-// the contents could not be saved is dropped
 ShowInformationNoteL( R_QTN_CM_PKCS12_SAVING_FAILED );
-CleanupStack::PopAndDestroy( message );
+}
 }
-*/
+// ----------------------------------------------------------
+// CCertSaverModel::DoMessageQuery()
+// Displays message query dialog for user.
+// ----------------------------------------------------------
+//
+TBool CCertSaverModel::DoMessageQueryL(
+TInt aDialogResId,
+TInt aHeadingResId,
+TDesC& aMessage )
+{
+CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( aMessage );
+CleanupStack::PushL( dlg );
+dlg->PrepareLC( aDialogResId );
+HBufC* header = StringLoader::LoadLC( aHeadingResId );
+dlg->QueryHeading()->SetTextL( header->Des() );
+CleanupStack::PopAndDestroy( header );
+CleanupStack::Pop( dlg );
+return dlg->RunLD();
 }
 // ----------------------------------------------------------
 // CCertSaverModel::ConstructPKCS12QueryMsgL() const
 // Creates the certificate details message shown to the user.
 TDes& aMessage,
 TInt aPrivateKeys,
 TInt aUserCerts,
 TInt aCACerts ) const
 {
 if ( aPrivateKeys > 0 )
 {
 if ( aPrivateKeys == 1 )
 {
 AddToMessageL( aMessage, R_CERTSAVER_ONE_PRIVATE_KEY );

branch	RCL_3
changeset 50	03674e5abf46
parent 49	09b1ac925e3f
child 54	94da73d93b58