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

equal deleted inserted replaced

-:63339781d179
+:09b1ac925e3f
 * 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) )
 {
-User::Leave( KErrNone );
+// used to leave with error none
+return;
 }
 TInt accessType( 0 );
 accessType |= CCTKeyInfo::EExtractable;
 break;
 }
 case KErrKeySize:
 case KErrArgument:
 {
-ShowErrorNoteL( R_CERTSAVER_KEY_TYPE_NOT_SUPPORTED );
+ShowInformationNoteL( R_CERTSAVER_KEY_TYPE_NOT_SUPPORTED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrKeyValidity:
 {
 ShowInformationNoteL( R_CERTSAVER_QTN_CM_PKCS12_EXPIRED );
 User::Leave( KErrCancel );
 }
 case KErrKeyUsage:
 {
-ShowErrorNoteL( R_CERTSAVER_PRIVATE_KEY_CORRUPTED );
+ShowInformationNoteL( R_CERTSAVER_PRIVATE_KEY_CORRUPTED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrCancel:
 case KErrPermissionDenied:
 {
-ShowErrorNoteL( R_CERTSAVER_PKCS12_DISCARDED );
+ShowInformationNoteL( R_CERTSAVER_PKCS12_DISCARDED );
 User::Leave( KErrCancel );
 break;
 }
 case KErrCorrupt:
 case KErrEof:
 {
-ShowErrorNoteL( R_CERTSAVER_KEYSTORE_CORRUPTED );
+ShowInformationNoteL( 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:
 {
-ShowErrorNoteL( R_CERTSAVER_KEYSTORE_CORRUPTED );
+ShowInformationNoteL( 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() ))
 {
-HBufC* p = StringLoader::LoadLC( R_CERTSAVER_MEMORY );
+ShowInformationNoteL(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 );
-CAknMessageQueryDialog* dlg = CAknMessageQueryDialog::NewL( *message );
+CHbDeviceMessageBoxSymbian::TButtonId selection =
-CleanupStack::PopAndDestroy( message );
+CHbDeviceMessageBoxSymbian::QuestionL(msgPtr, KNullDesC, KNullDesC);
-CleanupStack::PushL( dlg );
+TBool doSave= (selection == CHbDeviceMessageBoxSymbian::EAcceptButton);
+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
-CAknQueryDialog* warningDialog = CAknQueryDialog::NewL();
+HBufC* stringHolder = StringLoader::LoadLC( R_CERTSAVER_WARNING_NOTE );
-doSave = warningDialog->ExecuteLD( R_CERTSAVER_WARNING_NOTE );
+CHbDeviceMessageBoxSymbian::TButtonId selection =
-}
+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
+//Check that there still is enough space to store the certificate.
-//certificate.
 CheckFSSpaceL( iNewCert->Encoding() );
 DoSaveCertL();
 }
 else
 {
-ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
+ShowInformationNoteL(R_CERTSAVER_CERT_DISCARDED);
 User::Leave( KErrCancel );
 }
 }
 // ----------------------------------------------------------
 // CCertSaverModel::InitCertStoreL()
 //
 // ----------------------------------------------------------
 //
 void CCertSaverModel::InitCertStoreL()
 {
 if ( !iUnifiedCertStore )
 {
 TRAPD( status, iUnifiedCertStore = CUnifiedCertStore::NewL( iFs, ETrue ) );
 if ( status != KErrNone )
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowInformationNoteL( 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 ) && ( iCertOwnerType == EPeerCertificate ) ||
+if ( ( tokenuid == KTrustedServerTokenUid ) &&
+( iCertOwnerType == EPeerCertificate ) ||
 ( tokenuid == KFileTokensUid ) && ( iCertOwnerType == ECACertificate ) ||
 ( tokenuid == KFileTokensUid ) && ( iCertOwnerType == EUserCertificate ) )
 {
 certstoreIndex = i;
 break;
 }
 if ( certstoreIndex < 0 )
 {
 // Couldn't find certificate storage
-ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowInformationNoteL( 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.
-ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowInformationNoteL( 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 )
 {
-CAknTextQueryDialog* dialog = CAknTextQueryDialog::NewL( aLabel );
+HBufC* labelprompt =  CEikonEnv::Static()->AllocReadResourceLC( R_CERTSAVER_ENTER_LABEL );
-if ( !dialog->ExecuteLD( R_CERTSAVER_LABEL_QUERY ) )
+CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
+TInt queryAccepted = SecQueryUi->SecQueryDialog(labelprompt->Des(), aLabel,
+1,KMaxCertLabelLength,
+ESecUiAlphaSupported |
+ESecUiCancelSupported |
+ESecUiEmergencyNotSupported);
+CleanupStack::PopAndDestroy( labelprompt );
+delete SecQueryUi;
+SecQueryUi=NULL;
+if ( queryAccepted!=KErrNone )
 {
 // cancel
-ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
+ShowInformationNoteL(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:
 {
-ShowConfirmationNoteL( R_CERTSAVER_ERROR_SAVEOK );
+ShowInformationNoteL(R_CERTSAVER_ERROR_SAVEOK);
 break;
 }
 case KErrNotSupported:
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_UNSUPPORTED_CERT );
+ShowInformationNoteL(R_CERTSAVER_ERROR_UNSUPPORTED_CERT);
 break;
 }
 case KErrBadName:
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_LABEL_ALREADY_EXISTS );
+ShowInformationNoteL(R_CERTSAVER_ERROR_LABEL_ALREADY_EXISTS);
 break;
 }
 case KErrAlreadyExists:
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_ALREADY_EXISTS );
+ShowInformationNoteL(R_CERTSAVER_ERROR_ALREADY_EXISTS);
 break;
 }
 case KErrArgument:
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_CACERTS_DB_CORRUPTED );
+ShowInformationNoteL(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
+CleanupStack::PopAndDestroy(dateFormatString); // 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() )
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_CERT_NOT_VALID );
+ShowInformationNoteL(R_CERTSAVER_ERROR_CERT_NOT_VALID);
 return ETrue;
 }
 else if ( CertNotValidYet() )
 {
-ShowErrorNoteL( R_CERTSAVER_ERROR_CERT_NOT_VALID_YET );
+ShowInformationNoteL(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 );
-CAknInformationNote* note = new (ELeave) CAknInformationNote( ETrue );
+CHbDeviceMessageBoxSymbian* iMessageBox = CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EInformation);
-note->ExecuteLD( buffer->Des() );
+CleanupStack::PushL(iMessageBox);
-CleanupStack::PopAndDestroy( buffer );
+iMessageBox->SetTextL(buffer->Des());
-}
+iMessageBox->SetTimeout(6000);
-// ----------------------------------------------------------
+iMessageBox->ExecL();
-// CCertSaverModel::ShowConfirmationNoteL() const
+CleanupStack::PopAndDestroy(iMessageBox);
-// Creates and shows a confirmation note.
+CleanupStack::PopAndDestroy( buffer );
-// ----------------------------------------------------------
-//
-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 );
-CAknListQueryDialog* dlg = new (ELeave) CAknListQueryDialog( selectionArray );
+HBufC* title = CEikonEnv::Static()->AllocReadResourceLC( R_CERTSAVER_SELECT_TRUSTED_APPS);
-CleanupStack::PushL( dlg );
-dlg->PrepareLC( R_CERTSAVER_TRUST_SETTINGS_QUERY );
+RBuf rBuf;     // buffer for items with big enough space
-dlg->SetItemTextArray( itemsArray );
+rBuf.CreateL(KMaxLengthTextMeassageBody);
-dlg->SetOwnershipType( ELbmDoesNotOwnItemArray );
+CleanupClosePushL(rBuf);
-if ( dlg->RunLD() )
+for(TInt i = 0; i<itemsArray->Count(); i++)
-{
+rBuf.Append( (*itemsArray)[i] );
-aUids.Reset();
-for ( TInt i = 0; i < selectionArray->Count(); ++i )
+CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
-{
+TInt saved = SecQueryUi->SecQueryDialog(*title, rBuf,1,KTokenLength,
-TInt ii = (*selectionArray)[ i ];
+ESecUiAlphaSupported | ESecUiCancelSupported |
-aUids.Append( appsInItemArray[ ii ].Id() );
+ESecUiBasicTypeMultiCheck |
-}
+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
 {
-ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
+ShowInformationNoteL(R_CERTSAVER_CERT_DISCARDED);
 ret = KErrCancel;
 }
-CleanupStack::Pop( dlg );
-CleanupStack::PopAndDestroy( 4, selectionArray );
+rBuf.Close();
+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 =
-CAknMessageQueryDialog* note = CAknMessageQueryDialog::NewL( *prompt );
+CHbDeviceMessageBoxSymbian::QuestionL(prompt->Des(), KNullDesC, KNullDesC);
+if ( selection == CHbDeviceMessageBoxSymbian::EAcceptButton)
-note->PrepareLC( R_CERTSAVER_TRUSTED_SITE_QUERY );
-note->SetPromptL( *prompt );
-if ( note->RunLD() )
 {
 ret = KErrNone;
 }
 else
 {
-ShowConfirmationNoteL( R_CERTSAVER_CERT_DISCARDED );
+ShowInformationNoteL(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(
-R_MESSAGE_QUERY_DOSAVE, R_CERTSAVER_HEADER_PKCS12_FILE_CONTAINS,
+//TODO: Should be in loc file but hardcoded now
-*message );
+_LIT(KCheckBoxCaption,"Protect with Password|1");
-CleanupStack::PopAndDestroy( message );
+TBuf<KMaxLengthTextCheckBoxData> CheckeBoxData(KCheckBoxCaption);
+CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
+TInt save = SecQueryUi->SecQueryDialog(*message, CheckeBoxData,1,1,
+ESecUiAlphaSupported | ESecUiCancelSupported |
+ESecUiBasicTypeCheck | ESecUiEmergencyNotSupported);
+CleanupStack::Pop(message);
 message = NULL;
-if ( !save )
+delete SecQueryUi;
+SecQueryUi=NULL;
+if ( save!=KErrNone )
 {
 ShowInformationNoteL( R_CERTSAVER_PKCS12_DISCARDED );
 User::Leave( KErrExitApp );
 }
 TInt status = KErrNone;
 // save private keys
-TRAP( status, SavePrivateKeyL() );
+if(CheckeBoxData.Compare(_L("1"))==0)
+{
+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 )
 {
-message = HBufC::NewLC( KMaxLengthTextMeassageBody );
+// show how many have been saved
-TPtr msgPtr2 = message->Des();
+HBufC* p = StringLoader::LoadLC( R_CERTSAVER_HEADER_SAVED );
-ConstructPKCS12QueryMsgL(
+message = HBufC::NewLC( KMaxLengthTextMeassageBody );
+message->Des().Append(p->Des());
+TPtr msgPtr2 = message->Des();
+ConstructPKCS12QueryMsgL(
 msgPtr2, iSavedKeysCount, iSavedUserCertsCount, iSavedCACertsCount );
-DoMessageQueryL(
+CHbDeviceMessageBoxSymbian::InformationL(message->Des());
-R_MESSAGE_QUERY_SAVED, R_CERTSAVER_HEADER_SAVED, *message );
+CleanupStack::PopAndDestroy( message );
+CleanupStack::PopAndDestroy( p );
+}
+else
+{
+// the contents could not be saved is dropped
+ShowInformationNoteL( R_QTN_CM_PKCS12_SAVING_FAILED );
 CleanupStack::PopAndDestroy( message );
 }
-else
+*/
-{
-ShowInformationNoteL( R_QTN_CM_PKCS12_SAVING_FAILED );
-}
-}
-// ----------------------------------------------------------
-// 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 49	09b1ac925e3f
parent 16	9971b621ef6c
child 50	03674e5abf46