MCL/sf/mw/securitysrv: comparison pkiutilities/CTSecurityDialogs/NotifSrc/CTSecurityDialogsAO.cpp

equal deleted inserted replaced

-:63339781d179
+:09b1ac925e3f
 // INCLUDE FILES
 #include "CTSecurityDialogsAO.h"
 #include "CTSecurityDialogNotifier.h"
-#include "CTPinQueryDialog.h"
+//#include "CTPinQueryDialog.h"
-#include "CTSignTextDialog.h"
+//#include "CTSignTextDialog.h"
-#include "CTSelectCertificateDialog.h"
+//#include "CTSelectCertificateDialog.h"
-#include "CTQueryDialog.h"
+//#include "CTQueryDialog.h"
-#include "CTPinPinQueryDialog.h"
+//#include "CTPinPinQueryDialog.h"
-#include "CTNoTrustQuery.h"
+#include "CTUntrustedCertQuery.h"
-#include "CTInvalidCertNote.h"
+//#include "CTInvalidCertNote.h"
 #include <PKIDlg.h>
 #include <badesca.h>
 #include <StringLoader.h>
-#include <aknnotewrappers.h>
+//#include <aknnotewrappers.h>
 #include <unifiedcertstore.h>
 #include <unifiedkeystore.h>
 #include <mctkeystore.h>
 #include <cctcertinfo.h>
 #include <DocumentHandler.h>
 #include <apmstd.h>
 #include <DigSigningNote.h>
-#include <certmanui.rsg>
+//#include <certmanui.rsg>
 #include <X509CertNameParser.h>
 #include <x509cert.h>
 #include <x500dn.h>
 #include <hash.h>
 #include <x509certext.h>
 #include <TrustedSitesStore.h>
 #include <mctwritablecertstore.h>
-#include <coreapplicationuisdomainpskeys.h>			// KCoreAppUIsAutolockStatus
+#include <eikenv.h>                         // CEikonEnv
+#include <AknUtils.h>                       // AknTextUtils
+#include "SecQueryUi.h"                   // needed for password dialog
+#include <hbdevicemessageboxsymbian.h>    // needed for Note dialogs
+#include <hbdevicenotificationdialogsymbian.h>
 // LOCAL CONSTANTS AND MACROS
 const TInt KCertArrayGranularity = 3;
 const TInt KMaxLengthTextDetailsBody = 5000;
 // CertLabel, Issuer, Owner max visible length
 const TInt KMaxLengthTextCertLabelVisible = 200;
 // "dd/mm/yyyy0"
 const TInt KMaxLengthTextDateString = 20;
-// HH0
-const TInt KMaxLengthTextSerialNumberFormatting = 3;
 // Maximum length of a certificate
 const TInt KMaxCertificateLength = 5000;
 // Maximum length of key store password
 const TInt KMaxKeystorePwLength = 6;
 const TInt KMinImportKeyPwLen = 1;
-const TInt KMaxCNLength = 64;
+const TInt KMaxCommonNameLength = 64;
-_LIT(KCertManUIDetailsViewHexFormat, "%02X");
-const TInt KFileCertStoreUid( 0x101F501A );
-const TInt KWIMCertStoreUid ( 0x101F79D9 );
 const TUid KTrustedServerTokenUid = { 0x101FB66F };
 const TUid KDeviceCertStoreTokenUid = { 0x101FB668 };
 _LIT( KBlockSeparator, " " );
 _LIT( KEnter, "\n" );
 _LIT( KKeyStoreImportKeyLabel, "Passphrase of the imported key file" );
 _LIT( KKeyStoreExportKeyLabel, "Passphrase of the exported key file" );
 _LIT( KPKCS12TokenLabel, "PKCS12");
-// ============================ LOCAL FUNCTIONS ===============================
+// TODO: replace with OST tracing
+#ifdef _DEBUG
-TInt AlgorithmNameResourceId( TAlgorithmId aAlgorithmId )
+#include <e32debug.h>
-{
+#define TRACE(x)        RDebug::Printf(x)
-TInt resourceId = 0;
+#define TRACE1(x,y)     RDebug::Printf(x,y)
-switch( aAlgorithmId )
+#else
-{
+#define TRACE(x)
-case ERSA:
+#define TRACE1(x,y)
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_RSA;
+#endif
-break;
-case EDSA:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DSA;
-break;
-case EDH:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DH;
-break;
-case EMD2:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_MD2;
-break;
-case EMD5:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_MD5;
-break;
-case ESHA1:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_SHA1;
-break;
-case ESHA224:
-case ESHA256:
-case ESHA384:
-case ESHA512:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_SHA2;
-break;
-default:
-resourceId = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN;
-break;
-}
-return resourceId;
-}
 // ============================ MEMBER FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::ConstructL()
 {
 iDeleted = EFalse;
-iQueryDialog = NULL;
-iQueryDialogDeleted = ETrue;
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::NewL
 // Two-phased constructor.
 iRetry = *reinterpret_cast<const TInt *>( aBuffer.Ptr() ) & EPINValueIncorrect;
 iReplySlot = aReplySlot;
 iMessagePtr = aMessage;
 WIMSECURITYDIALOGS_WRITE_FORMAT( "CCTSecurityDialogsAO::StartLD iOperation=%d", iOperation );
+TRACE1( "CCTSecurityDialogsAO::StartLD iOperation=%d", iOperation );
 MapTlsProviderOperation( iOperation );
 switch ( iOperation )
 {
 TPtrC8 pinLabelPtr = aBuffer.Mid( sizeof(TInt) + 1 );
 TPINLabel pinLabel;
 pinLabel.Copy( pinLabelPtr );
 HBufC* text = iNotifier->LoadResourceStringLC( iOperation, pinLabel );
-CCTSignTextDialog::RunDlgLD( R_WIM_UNBLOCK_INFO_DIALOG, *text, iStatus, iRetValue );
+// TODO
+//CCTSignTextDialog::RunDlgLD( R_WIM_UNBLOCK_INFO_DIALOG, *text, iStatus, iRetValue );
+User::Leave( KErrGeneral );
 CleanupStack::PopAndDestroy( text );
 iStatus = KRequestPending;
 SetActive();
 break;
 }
 // CCTSecurityDialogsAO::DoHandleServerAuthFailL(const TDesC8& aBuffer)
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::DoHandleServerAuthFailL( const TDesC8& aBuffer )
 {
+TRACE( "CCTSecurityDialogsAO::DoHandleServerAuthFailL" );
 CServerAuthenticationFailureInput* srvAuthFail =
 CServerAuthenticationFailureInput::NewLC( aBuffer );
 TPtrC8 cert;
 TPtrC8 serverName;
 iAuthFailReason = srvAuthFail->FailureReason();
 CleanupStack::PopAndDestroy( srvAuthFail );
 iServerName = HBufC::NewL( serverName.Length() );
 iServerName->Des().Copy( serverName );
-HBufC* cn = NULL;
 iCertLabel = NULL;
 // Site will be checked later. For now it is not trusted
 iTrustedSite = EFalse;
 CX509Certificate* serverCert = CX509Certificate::NewLC( cert );
-// Retrieve subject name
 const CX500DistinguishedName& dName = serverCert->SubjectName();
-// Retrieve CN
-cn = dName.ExtractFieldL( KX520CommonName );
+HBufC* commonName = dName.ExtractFieldL( KX520CommonName );
-if ( cn != NULL )
+CleanupStack::PushL( commonName );
-{
+if( commonName != NULL )
-// commonName exist in the certificate.
+{
 // Check the length of CN. RFC 3280 states
 // that max length of CN is 64.
-if ( cn->Length() <= KMaxCNLength )
+if( commonName->Length() <= KMaxCommonNameLength )
 {
-iCertLabel = HBufC::NewL( cn->Length() );
+iCertLabel = HBufC::NewL( commonName->Length() );
-iCertLabel->Des().Append( cn->Des() );
+iCertLabel->Des().Append( commonName->Des() );
 }
 }
+CleanupStack::PopAndDestroy( commonName );
-if ( iCertLabel == NULL )
-{
+if( iCertLabel == NULL )
-// No or invalid commonName. Use domain name as label
+{
+// No or invalid commonName. Use domain name as label.
 iCertLabel = HBufC::NewL( iServerName->Length() );
 iCertLabel->Des().Append( iServerName->Des() );
 }
 CleanupStack::PopAndDestroy( serverCert );
 }
 switch( iOperation )
 {
 case EUserAuthenticationText:
 {
-CCTSignTextDialog::RunDlgLD( R_WIM_USERAUTHTEXT_DIALOG,
+// TODO
-*textToSign, iStatus, iRetValue );
+//CCTSignTextDialog::RunDlgLD( R_WIM_USERAUTHTEXT_DIALOG,
+//    *textToSign, iStatus, iRetValue );
+User::Leave( KErrGeneral );
 break;
 }
 case EUserAuthentication:
 {
+DoHandleMessageL( EUserAuthentication, KNullDesC, KNullDesC, 1, KMaxTInt );
 break;
 }
 case ESignText:
 {
-CCTSignTextDialog::RunDlgLD( R_WIM_SIGNTEXT_DIALOG,*textToSign, iStatus, iRetValue );
+// TODO
+//CCTSignTextDialog::RunDlgLD( R_WIM_SIGNTEXT_DIALOG,*textToSign, iStatus, iRetValue );
+User::Leave( KErrGeneral );
 break;
 }
 default:
 {
 __ASSERT_DEBUG( EFalse,
 void CCTSecurityDialogsAO::DoHandlePinOperationL()
 {
 if ( iRetry ) // Is this new try?
 {
 // Previous attempt was failed
+// incorrect pin code
 DoHandleMessageL( EErrorPinCodeIncorrect, KNullDesC, KNullDesC, 0, 0 );
 }
 // Ask the PIN code or PUK code
 if ( iPIN.iPINLabel == KKeyStoreEnterPwLabel )
 {
 HBufC* header = StringLoader::LoadLC(
 R_QTN_CM_HEADING_PHONE_KEYSTORE, CEikonEnv::Static() );
-iPIN.iMinLength = KMaxKeystorePwLength;
+		iPIN.iMinLength = KMaxKeystorePwLength;
 DoHandleMessageL( EEnterKeyStorePw, KNullDesC, *header,
 iPIN.iMinLength, iPIN.iMaxLength );
 iMultiLineDlgType = EEnterNewKeyStorePw;
 CleanupStack::PopAndDestroy( header );
+RunL();
 }
 else if ( iPIN.iPINLabel == KKeyStoreImportKeyLabel )
 {
 iPIN.iMinLength = KMaxKeystorePwLength;
 DoHandleMessageL( EImportKeyPw, KNullDesC, KNullDesC,
 iNextStep = EVerifyPINs;
 }
 else if ( iPIN.iPINLabel == KKeyStoreCreatePwLabel )
 {
 iPIN.iMinLength = KMaxKeystorePwLength;
-DoHandleMessageL( EInfoPwCreating, KNullDesC, KNullDesC, 0, 0 );
+ShowInformationNoteL(R_QTN_CM_CREATING_KEYSTORE);
 DoHandleMultilinePinQueryL( EEnterNewKeyStorePw );
 iNextStep = EVerifyPINs;
 }
 else if ( iPIN.iTokenLabel == KPKCS12TokenLabel )
 {
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::DoHandleMultilinePinQueryL()
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::DoHandleMultilinePinQueryL( const TInt& aDlgType )
+void CCTSecurityDialogsAO::DoHandleMultilinePinQueryL( const TInt& /*aDlgType*/ )
 {
+// TODO
+#if 0
 iMultiLineDlgType = aDlgType;
 HBufC* dlgText1 = NULL;
 HBufC* dlgText2 = NULL;
 CCTPinPinQueryDialog* dlg = NULL;
 TDialogType dlgType = ( TDialogType )aDlgType;
 if ( EEnterNewKeyStorePw == dlgType )
 {
+/*
+dlgText1 = iNotifier->LoadResourceStringLC( dlgType, KNullDesC );
+dlgText2 = iNotifier->LoadResourceStringLC( EVerifyKeyStorePw, KNullDesC );
+dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2,
+iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue );16:19:13.812 xti1:MCU_ASCII_PRINTF; channel:0xE0; msg:*PlatSec* ERROR - Capability check failed - Process #tlstest[e8dc94b1]0001 was checked by Thread c32exe.exe[101f7989]0001::ESock_IP and was found to be missing the capabilities: NetworkControl .
+dlg->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG );
+CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2
+*/
+dlgText1 =  StringLoader::LoadLC( R_QTN_SN_NEW_PHONE_KEYSTORE );
+dlgText2 = StringLoader::LoadLC( R_QTN_WIM_VERIFY_PIN );
+HBufC* message = HBufC::NewLC( KMaxLengthTextCertLabelVisible );
+message->Des().Append(dlgText1->Des());
+message->Des().Append(_L("|"));
+message->Des().Append(dlgText2->Des());
+CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
+TInt queryAccepted = SecQueryUi->SecQueryDialog(message->Des(), iPINValueVerify,
+iPIN.iMinLength,iPIN.iMaxLength,
+ESecUiAlphaSupported |
+ESecUiCancelSupported |
+ESecUiSecretSupported |
+ESecUiEmergencyNotSupported);
+iRetValue=(queryAccepted==KErrNone);
+if(iRetValue)
+iPINValue2.Copy(iPINValueVerify); // dialog already does not OK with different pin codes
+delete SecQueryUi;
+SecQueryUi=NULL;
+CleanupStack::PopAndDestroy( message );
+CleanupStack::PopAndDestroy( dlgText2 );
+CleanupStack::PopAndDestroy( dlgText1 );
+RunL(); // had to call it this way
+}
+else if ( EExportKeyPw == dlgType )
+{
 dlgText1 = iNotifier->LoadResourceStringLC( dlgType, KNullDesC );
 dlgText2 = iNotifier->LoadResourceStringLC( EVerifyKeyStorePw, KNullDesC );
 dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2,
 iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue );
 dlg->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG );
 CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2
 }
-else if ( EExportKeyPw == dlgType )
-{
-dlgText1 = iNotifier->LoadResourceStringLC( dlgType, KNullDesC );
-dlgText2 = iNotifier->LoadResourceStringLC( EVerifyKeyStorePw, KNullDesC );
-dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2,
-iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue );
-dlg->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG );
-CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2
-}
 else // Enter new PIN
 {
 dlgText1 = iNotifier->LoadResourceStringLC( dlgType, iPIN.iPINLabel );
 dlgText2 = iNotifier->LoadResourceStringLC( EVerifyPinNR, iPIN.iPINLabel );
 dlg = CCTPinPinQueryDialog::NewL( *dlgText1, *dlgText2, iPINValue2,
 iPINValueVerify, iPIN.iMinLength, iPIN.iMaxLength, iRetValue );
 dlg->RunDlgLD( iStatus, R_WIM_PINPIN_QUERY_DIALOG );
 CleanupStack::PopAndDestroy( 2, dlgText1 ); // dlgText1, dlgText2
 }
+#endif
+User::Leave( KErrGeneral );
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::DoHandleMessageL()
 // -----------------------------------------------------------------------------
 HBufC* dlgText = iNotifier->LoadResourceStringLC( dlgType, aDynamicText, aPinQueryHeading );
 TDialogTypeItem item = iNotifier->GetDialogTypeItem( dlgType );
-CAknResourceNoteDialog* dlg = NULL;
+//CAknResourceNoteDialog* dlg = NULL;
 TInt resource = 0;
 switch ( item.iNoteType )
 {
 case EInfoNote:
 {
-dlg = new ( ELeave ) CAknInformationNote( ETrue );
+// TODO
+//dlg = new ( ELeave ) CAknInformationNote( ETrue );
+User::Leave( KErrGeneral );
 break;
 }
 case EErrorNote:
 {
-dlg = new ( ELeave ) CAknErrorNote( ETrue );
+// TODO
+//dlg = new ( ELeave ) CAknErrorNote( ETrue );
+User::Leave( KErrGeneral );
 break;
 }
 case EConfirmationNote:
 {
-dlg = new ( ELeave ) CAknConfirmationNote( ETrue );
+// TODO
+//dlg = new ( ELeave ) CAknConfirmationNote( ETrue );
+User::Leave( KErrGeneral );
 break;
 }
 case EInfoDialog:
 {
+// TODO
+/*
 CCTQueryDialog::RunDlgLD( iStatus,
 iRetValue,
 *dlgText, item.iSoftKeyResource,
 ECTInfoDialog );
 iStatus = KRequestPending;
 SetActive();
+*/
+User::Leave( KErrGeneral );
 break;
 }
 case EEnterPwPwDialog:
 {
+// TODO
+/*
 CCTPinPinQueryDialog* dialog =
 CCTPinPinQueryDialog::NewL( *dlgText, *dlgText,
 iPINValue2, iPINValueVerify, aMinLength, aMaxLength, iRetValue );
 dialog->RunDlgLD( iStatus, R_WIM_PWPW_QUERY_DIALOG );
+*/
+User::Leave( KErrGeneral );
 break;
 }
 case EEnterPinPinCodeDialog:
 {
+// TODO
+/*
 CCTPinPinQueryDialog* dialog =
 CCTPinPinQueryDialog::NewL( *dlgText, *dlgText,
 iPINValue2, iPINValueVerify, aMinLength, aMaxLength, iRetValue );
 dialog->RunDlgLD( iStatus, R_WIM_PINPIN_QUERY_DIALOG );
+*/
+User::Leave( KErrGeneral );
 break;
 }
 case EEnterPwDialog:
 case EEnterPinNRCodeDialog:
 case EVerifyPinNRCodeDialog:
 default:
 {
 User::Panic(_L("CSecDlgNotifier"), 0);
 }
 }
-iPinQueryDialogDeleted = EFalse;
+//iPinQueryDialogDeleted = EFalse;
-CCTPinQueryDialog::RunDlgLD( iStatus,
+if(aDlgType!=EEnterKeyStorePw) {
-*dlgText,
+// TODO
-*pinValue,
+/*
-aMinLength,
+CCTPinQueryDialog::RunDlgLD( iStatus,
-aMaxLength,
+*dlgText,
-iRetValue,
+*pinValue,
-resource,
+aMinLength,
-iPinQueryDialog,
+aMaxLength,
-iPinQueryDialogDeleted );
+iRetValue,
+resource,
+iPinQueryDialog,
+iPinQueryDialogDeleted );
+*/
+User::Leave( KErrGeneral );
+resource = resource;     // avoids compiler warning
+break;
+}
+else
+{
+iPIN.iMinLength = KMaxKeystorePwLength;
+CSecQueryUi* SecQueryUi = CSecQueryUi::NewL();
+HBufC* header =StringLoader::LoadLC( R_QTN_SN_ENTER_PHONE_KEYSTORE);
+TInt queryAccepted = SecQueryUi->SecQueryDialog(header->Des(), *pinValue,
+aMinLength,aMaxLength,
+ESecUiAlphaSupported |
+ESecUiCancelSupported |
+ESecUiSecretSupported |
+ESecUiEmergencyNotSupported);
+delete SecQueryUi;
+SecQueryUi=NULL;
+iRetValue=(queryAccepted==KErrNone);
+CleanupStack::PopAndDestroy( header );
 break;
+}
 }
 default:
 {
 break;
 }
 }
+// TODO
-if ( dlg )
+/*
+if ( dlg && aDlgType!=EEnterKeyStorePw)
 {
 dlg->ExecuteLD( *dlgText );
 dlg = NULL;
 }
+*/
+User::Leave( KErrGeneral );
 CleanupStack::PopAndDestroy( dlgText ); // dlgText
 }
 // -----------------------------------------------------------------------------
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::InitCertStoreL()
 {
+TRACE( "CCTSecurityDialogsAO::InitCertStoreL" );
 switch(iOperation)
 {
 case ESignText:
 case EUserAuthenticationText:
 case EUserAuthentication:
 //
 void CCTSecurityDialogsAO::RunL()
 {
 WIMSECURITYDIALOGS_WRITE_FORMAT( "CCTSecurityDialogsAO::RunL, iStatus %d", iStatus.Int() );
 WIMSECURITYDIALOGS_WRITE_FORMAT( "  iNextStep %d", iNextStep );
+TRACE1( "CCTSecurityDialogsAO::RunL, iStatus.Int()=%d", iStatus.Int() );
-if ( iStatus != KErrNone )
+if( iStatus != KErrNone )
 {
 User::Leave( iStatus.Int() );
-} // if
+}
-switch ( iNextStep )
+TRACE1( "CCTSecurityDialogsAO::RunL, iNextStep=%d", iNextStep );
+switch( iNextStep )
 {
 case EOperationCompleted:
 {
 WIMSECURITYDIALOGS_WRITE( "EOperationCompleted" );
 HandleResponseAndCompleteL();
 break;
 }
 case ECheckServerCerts:
 {
 WIMSECURITYDIALOGS_WRITE( "ECheckServerCerts" );
 TBool foundCert( EFalse );
-if ( iServerCerts.Count() )
+if( iServerCerts.Count() )
 {
 // Found certificates in the trusted site certificate storage.
 // Compare them with the one received from TlsProvider
 iCertPtr.Set( iCertBuf->Des() );
 CX509Certificate* serverCert = CX509Certificate::NewLC( iCertPtr );
-for (TInt i=0; i<iServerCerts.Count(); i++ )
+for( TInt i = 0; i < iServerCerts.Count(); i++ )
 {
 TPtr8 certPtr( iServerCerts[i]->Des() );
 CX509Certificate* cert = CX509Certificate::NewLC( certPtr );
+if( cert->Fingerprint() == serverCert->Fingerprint() )
-// Compare fingerprints
-if ( cert->Fingerprint() == serverCert->Fingerprint() )
 {
-// Fingerprints match
 foundCert = ETrue;
 }
 CleanupStack::PopAndDestroy( cert );
 }
 CleanupStack::PopAndDestroy( serverCert );
-if ( foundCert )
+if( foundCert )
 {
 // Found matching certificate. Complete the operation
 iRetValue = EServerCertAcceptedPermanently;
 iNextStep = EOperationCompleted;
 HandleResponseAndCompleteL();
 }
 }
 if ( !foundCert )
 {
 // Couldn't find matching certificate. Prompt user
 ShowNoTrustDialogL();
 }
 break;
 }
 case EProcessTrustedSite:
 {
 WIMSECURITYDIALOGS_WRITE( "EProcessTrustedSite" );
+TRACE( "CCTSecurityDialogsAO::RunL, EProcessTrustedSite" );
 TInt count = iCertStore->WritableCertStoreCount();
-for ( TInt i = 0; i < count; i++ )
+for( TInt i = 0; i < count; i++ )
 {
 MCTWritableCertStore *certstore = &iCertStore->WritableCertStore( i );
 MCTToken& token = certstore->Token();
 TUid tokenuid = token.Handle().iTokenTypeUid;
-if ( tokenuid == KTrustedServerTokenUid )
+if( tokenuid == KTrustedServerTokenUid )
 {
 iTrustedSiteCertStore = certstore;
 }
 }
 CleanupStack::PushL( trustedSitesStore );
 // Find out whether or not site associated with certificate is trusted
 iTrustedSite = trustedSitesStore->IsTrustedSiteL( *iCertBuf, *iServerName );
-if ( iTrustedSite )
+if( iTrustedSite )
 {
 TBool allowOutOfDate = trustedSitesStore->IsOutOfDateAllowedL(*iCertBuf, *iServerName);
-if (!allowOutOfDate)
+if( !allowOutOfDate )
 {
 CX509Certificate* cert = CX509Certificate::NewLC( iCertBuf->Des() );
 const CValidityPeriod& validityPeriod = cert->ValidityPeriod();
 const TTime& startValue = validityPeriod.Start();
 CleanupStack::PopAndDestroy( cert );
 }
 }
 CleanupStack::PopAndDestroy( trustedSitesStore );
-if ( iTrustedSite )
+if( iTrustedSite )
 {
 // Site is trusted. Next step is to check that server
 // certificate is in the trusted site certificate storage
 iNextStep = ERetrieveServerCerts;
 iStatus = KRequestPending;
 TRequestStatus* status = &iStatus;
 User::RequestComplete( status, KErrNone );
 }
 break;
 }
 case EAddTrustedSite:
 {
-if ( iStatus.Int() == KErrNone )
+TRACE( "CCTSecurityDialogsAO::RunL, EAddTrustedSite" );
+if( iStatus.Int() == KErrNone )
 {
 //Added server certificate succesfully
 CTrustSitesStore* trustedSitesStore = CTrustSitesStore::NewL();
 CleanupStack::PushL( trustedSitesStore );
 TInt status = trustedSitesStore->AddL( *iCertBuf, *iServerName );
 CleanupStack::PopAndDestroy( trustedSitesStore );
-if ( status  == KErrNone )
+if( status  == KErrNone )
 {
 iRetValue = EServerCertAcceptedPermanently;
 }
 else
 {
 HandleResponseAndCompleteL();
 }
 else
 {
 //Adding server certificate failed
+// TODO: unreached code?
 iNextStep = EOperationCompleted;
 iRetValue = EServerCertNotAccepted;
 HandleResponseAndCompleteL();
 }
 break;
 }
 case ESaveServerCert:
 {
 WIMSECURITYDIALOGS_WRITE( "ESaveServerCert" );
+TRACE( "CCTSecurityDialogsAO::RunL, ESaveServerCert" );
 DoHandleSaveServerCertL();
 break;
 }
 case EServerCertCheckUserResp:
 {
 WIMSECURITYDIALOGS_WRITE( "EServerCertCheckUserResp" );
-if ( iRetValue == EServerCertAcceptedPermanently )
+TRACE( "CCTSecurityDialogsAO::RunL, EServerCertCheckUserResp" );
+if( iRetValue == EServerCertAcceptedPermanently )
 {
 // User accepted to select certificate permanently.
 // First add server certificate
 iNextStep = ESaveServerCert;
 iStatus = KRequestPending;
 // User declined or temporarily accepted server certificate
 HandleResponseAndCompleteL();
 }
 break;
 }
 case EOperationSignTextShown:
 {
 if ( iRetValue || iOperation == EUserAuthentication )
 {
 iNextStep = EOperationInitCertStore;
 SetActive();
 TRequestStatus* status = &iStatus;
 User::RequestComplete( status, KErrNone );
 break;
 }
 case EOperationInitCertStore:
 {
 TInt err = KErrNone;
 err = iFs.Connect();
 if( err != KErrNone && err != KErrAlreadyExists )
 iStatus = KRequestPending;
 SetActive();
 iNextStep = EOperationRetrieveCertInfos;
 break;
 }
 case EOperationRetrieveCertInfos:
 {
 if ( iCertInfo )
 {
 iCertArray->AppendL( iCertInfo->Label() );
 TRequestStatus* status = &iStatus;
 User::RequestComplete( status, KErrNone );
 }
 break;
 }
 case EOperationSelectCert:
 {
 DoHandleSelectCertificateL();
 break;
 }
 case EGetCertInfo:
 {
 iStatus = KRequestPending;
 iCertInfo = NULL;
 iCertStore->GetCert( iCertInfo, iTokenHandle, iStatus );
 iNextStep = EGetCertificate;
 SetActive();
 break;
 }
 case EGetCertificate:
 {
 iStatus = KRequestPending;
 if ( iCertInfo )
 {
 User::RequestComplete( status, KErrNone );
 }
 iNextStep = EInitKeyStore;
 break;
 }
 case EInitKeyStore:
 {
 InitKeyStoreL();
 iNextStep = EGetKeyInfos;
 break;
 }
 case EGetKeyInfos:
 {
 GetKeyInfosL();
 iNextStep = EShowCertDialog;
 break;
 }
 case EGetKeyInfoByHandle:
 {
 GetKeyInfoByHandleL();
 iNextStep = EShowCSRDialog;
 break;
 }
 case EShowCSRDialog:
 {
 ShowCSRDialogL();
 iNextStep = EOperationCompleted;
 break;
 }
 case EShowCertDialog:
 {
 ShowCertDialogL();
 iNextStep = EOperationCompleted;
 break;
 }
 /////////////
 // PIN steps
 /////////////
 case EEnterNewPIN:
 {
 iPINValue2 = KNullDesC;
 HandleResponseAndCompleteL();
 }
 break;
 }
 case EVerifyPINs:
 {
 VerifyPinsL();
 break;
 }
 default:
 {
 User::Panic( _L("CTestSecDlgNotifier"), 0 );
 }
 }
 if ( !foundDevCert )
 {
 // No certificate from Device Certificate Store. Prompt user
 // for certificate selection
+/*
 CCTSelectCertificateDialog::RunDlgLD(
 iCertArray, iCertHandleList, iTokenHandle,
 iStatus, iRetValue ); // Takes ownerhip of array
 iNextStep = EOperationCompleted;
 iStatus = KRequestPending;
 SetActive();
+*/
+User::Leave( KErrGeneral );     // TODO: to be implemented
 }
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::ShowNoTrustDialogL()
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::ShowNoTrustDialogL()
 {
-// Cannot display untrusted certificate dialog if device is locked. Untrusted
+TRACE( "CCTSecurityDialogsAO::ShowNoTrustDialogL, begin" );
-// certificate dialog would be displayed on top of possible lock code query.
-TInt value = 0;
+// If trusted site certstore open has failed, then it is not possible to save
-TInt err = RProperty::Get( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus, value );
+// the host name for permanent use. Hence, choice for permanent accept is not
-if( !err && value != EAutolockOff )
+// displayed if trusted site certstore open has failed. Other restrictions for
-{
+// permanent accept are defined in device dialog (UntrustedCertificateWidget).
-iRetValue = EServerCertNotAccepted;
+TBool isTrustedSiteCertStoreOpened = ( iTrustedSiteCertStore != NULL );
-iStatus = KRequestPending;
+CCTUntrustedCertQuery *untrustedCertDlg = CCTUntrustedCertQuery::NewLC(
-TRequestStatus* status( &iStatus );
+iAuthFailReason, *iCertBuf, *iServerName, isTrustedSiteCertStoreOpened );
-User::RequestComplete( status, KErrNone );
-}
+CCTUntrustedCertQuery::TResponse response = CCTUntrustedCertQuery::EQueryRejected;
-else
+untrustedCertDlg->ShowQueryAndWaitForResponseL( response );
-{
+switch( response )
-CX509Certificate* cert = CX509Certificate::NewLC( iCertBuf->Des() );
+{
-TInt dialogResourceId = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
+case CCTUntrustedCertQuery::EQueryAccepted:
-TInt promptResourceId = R_QTN_ICS_SSL_CONF_Q_ACCEPT_UNTRUSTED;
+iRetValue = EServerCertAcceptedTemporarily;
-TBool showPermAccept = ETrue;
+break;
+case CCTUntrustedCertQuery::EQueryAcceptedPermanently:
-if( iAuthFailReason == ESignatureInvalid || iAuthFailReason == ECertificateRevoked )
+// TODO: show confirmation note, qtn_httpsec_query_perm_accept_text
-{
+// "Connection to site %U will be made in future without any warnings. Continue?""
-// Invalid or revoked certificate
+iRetValue = EServerCertAcceptedPermanently;
-CCTInvalidCertificateNote* note =
+break;
-new( ELeave ) CCTInvalidCertificateNote( *this, iStatus );
+case CCTUntrustedCertQuery::EQueryRejected:
-note->ExecuteLD( R_WIM_INVALID_CERTIFICATE_INFORMATION_NOTE );
+default:
 iRetValue = EServerCertNotAccepted;
+break;
-// CCTNoTrustQuery below self-completes this active object. It is necessary to
+}
-// complete it here too, in order to run the next step EServerCertCheckUserResp.
+CleanupStack::PopAndDestroy( untrustedCertDlg );
-iStatus = KRequestPending;
+TRACE1( "CCTSecurityDialogsAO::ShowNoTrustDialogL, iRetValue=%d", iRetValue );
-TRequestStatus* status( &iStatus );
-User::RequestComplete( status, KErrNone );
-}
-else
-{
-if( iAuthFailReason == EValidatedOK || iAuthFailReason == EDateOutOfRange )
-{
-// Trusted certificate, but problems with CN or date
-// Retrieve subject name
-const CX500DistinguishedName& dName = cert->SubjectName();
-// Retrieve common name
-HBufC* cn = dName.ExtractFieldL( KX520CommonName );
-// Check common name first and then date
-if( !cn )
-{
-// Couldn't retrieve CN from certificate
-dialogResourceId = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
-promptResourceId = R_QTN_ICS_SSL_CONF_Q_ACCEPT_UNTRUSTED;
-}
-else if( iServerName->Des() != cn->Des() )
-{
-// Domain name doesn't match with CN
-dialogResourceId = R_WIM_NO_TRUST_QUERY_SITE;
-promptResourceId = R_QTN_ICS_SSL_CONF_Q_ACCEPT_SITE;
-}
-else if( iAuthFailReason == EDateOutOfRange )
-{
-// Certificate is out of date
-dialogResourceId = R_WIM_NO_TRUST_QUERY_OOD;
-promptResourceId = R_QTN_ICS_SSL_CONF_Q_ACCEPT_OOD;
-showPermAccept = EFalse;
-}
-else
-{
-// Otherwise show general untrusted note
-dialogResourceId = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
-promptResourceId = R_QTN_ICS_SSL_CONF_Q_ACCEPT_UNTRUSTED;
-}
-}
-else
-{
-// Untrusted certificate
-dialogResourceId = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
-promptResourceId = R_QTN_ICS_SSL_CONF_Q_ACCEPT_UNTRUSTED;
-}
-// No "Accept Permanently" option if certificate is out of date, or
-// if domain name is not defined, or if trusted site store failed to
-// open (and it's not possible to save the server certificate).
-const CValidityPeriod& validityPeriod = cert->ValidityPeriod();
-const TTime& startValue = validityPeriod.Start();
-const TTime& finishValue = validityPeriod.Finish();
-TTime current;
-current.UniversalTime();
-if( (( startValue > current ) || ( finishValue < current )) ||
-( iServerName->Des().Length() == 0 ) ||
-( !iTrustedSiteCertStore ) )
-{
-showPermAccept = EFalse;
-}
-// CCTNoTrustQuery completes iStatus asynchronously when ready. Note that
-// it happens after ExecuteLD() and also this function have returned.
-iStatus = KRequestPending;
-iQueryDialog = new( ELeave ) CCTNoTrustQuery( *this, iRetValue, iStatus,
-iServerName, showPermAccept, iQueryDialogDeleted );
-HBufC* prompt = StringLoader::LoadLC( promptResourceId, *iServerName );
-iQueryDialog->ExecuteLD( dialogResourceId, *prompt );
-CleanupStack::PopAndDestroy( prompt );
-}
-CleanupStack::PopAndDestroy( cert );
-}
 iNextStep = EServerCertCheckUserResp;
+iStatus = KRequestPending;
+TRequestStatus* status = &iStatus;
+User::RequestComplete( status, KErrNone );
 SetActive();
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::ShowCSRDialogL()
 DetailsResourceL( messagePtr, R_QTN_SN_CERT_SIGN_EXPLANATION );
 messagePtr.Append( KEnter );
-DetailsFieldDynamicL( messagePtr, *iText,
+//DetailsFieldDynamicL( messagePtr, *iText,
-R_TEXT_RESOURCE_DETAILS_VIEW_SUBJECT,
+//    R_TEXT_RESOURCE_DETAILS_VIEW_SUBJECT,
-R_TEXT_RESOURCE_VIEW_NO_SUBJECT_DETAILS );
+//    R_TEXT_RESOURCE_VIEW_NO_SUBJECT_DETAILS );
 AddKeyUsageL( messagePtr, iKeyInfo );
 AddKeyAlgorithmL( messagePtr, iKeyInfo );
 AddKeySizeL( messagePtr, iKeyInfo );
 AddKeyLocationL( messagePtr, iKeyInfo );
-CCTSignTextDialog::RunDlgLD( R_WIM_CSR_DIALOG, *message, iStatus, iRetValue );
+// TODO
+//CCTSignTextDialog::RunDlgLD( R_WIM_CSR_DIALOG, *message, iStatus, iRetValue );
+User::Leave( KErrGeneral );
 CleanupStack::PopAndDestroy( message );
 iStatus = KRequestPending;
 SetActive();
 }
 default:
 {
 User::Panic(_L("CTestSecDlgNotifier"), 0);
 }
 }
-CCTSignTextDialog::RunDlgLD( resource, *message, iStatus, iRetValue );
+// TODO
+//CCTSignTextDialog::RunDlgLD( resource, *message, iStatus, iRetValue );
+User::Leave( KErrGeneral );
+resource = resource;     // avoids compiler warning
 CleanupStack::PopAndDestroy( message );
 iStatus = KRequestPending;
 SetActive();
 }
 // Appends strings from both resources and CertManAPI to one
 // message body text and displays it.
 // ---------------------------------------------------------
 //
 HBufC* CCTSecurityDialogsAO::MessageQueryCertDetailsL(
-const TDesC8& aCert,
+const TDesC8& /*aCert*/,
-const CCTCertInfo* aCertInfo,
+const CCTCertInfo* /*aCertInfo*/,
-TCertificateFormat aCertFormat,
+TCertificateFormat /*aCertFormat*/,
-const CCTKeyInfo* aKeyInfo)
+const CCTKeyInfo* /*aKeyInfo*/)
 {
 // Create message buffer
 HBufC* message = HBufC::NewLC( KMaxLengthTextDetailsBody );
+/*
 TPtr messagePtr = message->Des();
 // Label
 if ( aCertInfo )
 {
 DetailsFieldDynamicL( messagePtr, aCertInfo->Label(),
 default:
 {
 User::Leave( KErrNotSupported );
 }
 }
+*/
 CleanupStack::Pop( message );
 return message;
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddIssuerAndSubjectL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddSiteL( TDes& aMessage )
+void CCTSecurityDialogsAO::AddSiteL( TDes& /*aMessage*/ )
 {
+/*
 if ( iServerName )
 {
 DetailsFieldDynamicL( aMessage, iServerName->Des(),
 R_QTN_CM_SITE,
 R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED );
 }
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddIssuerAndSubjectL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddIssuerAndSubjectL( TDes& aMessage, const CX509Certificate& aCert )
+void CCTSecurityDialogsAO::AddIssuerAndSubjectL( TDes& /*aMessage*/, const CX509Certificate& /*aCert*/ )
 {
+/*
 HBufC* issuer = NULL;
 HBufC* owner = NULL;
 X509CertNameParser::SubjectFullNameL( aCert, owner );
 CleanupStack::PushL( owner );
 X509CertNameParser::IssuerFullNameL( aCert, issuer );
 // certificate subject
 DetailsFieldDynamicL( aMessage, owner->Des(),
 R_TEXT_RESOURCE_DETAILS_VIEW_SUBJECT,
 R_TEXT_RESOURCE_VIEW_NO_SUBJECT_DETAILS );
 CleanupStack::PopAndDestroy( owner );   //owner
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddKeySizeL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddKeySizeL( TDes& aMessage, const CCTKeyInfo* aKeyInfo )
+void CCTSecurityDialogsAO::AddKeySizeL( TDes& /*aMessage*/, const CCTKeyInfo* /*aKeyInfo*/ )
 {
+/*
 TUint keySize = aKeyInfo->Size();
 TBuf<KMaxLengthTextDateString> sizeBuf;
 if ( 0 < keySize )
 {
 DetailsFieldDynamicL( aMessage, sizeBuf,
 R_QTN_SN_KEY_LENGTH_LABEL,
 R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED );
 aMessage.Append( KEnterEnter );
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddKeyUsageL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddKeyUsageL( TDes& aMessage, const CCTKeyInfo* aKeyInfo )
+void CCTSecurityDialogsAO::AddKeyUsageL( TDes& /*aMessage*/, const CCTKeyInfo* /*aKeyInfo*/ )
 {
+/*
 if ( aKeyInfo != NULL )
 {
 TKeyUsagePKCS15 keyUsage = aKeyInfo->Usage();
 TInt usage = 0;
 break;
 }
 DetailsFieldResourceL( aMessage,
 R_TEXT_RESOURCE_DETAILS_VIEW_KEY_USAGE, usage);
 }
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddKeyUsageL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddKeyUsageL( TDes& aMessage, const CX509Certificate& aCert )
+void CCTSecurityDialogsAO::AddKeyUsageL( TDes& /*aMessage*/, const CX509Certificate& /*aCert*/ )
 {
+/*
 TKeyUsageX509 x509Usage = EX509UsageNone;
 TKeyUsagePKCS15 pkcs15KeyUsage = EPKCS15UsageNone;
 const CX509CertExtension* ext = aCert.Extension(KKeyUsage);
 if ( ext )
 {
 }
 }
 DetailsFieldResourceL( aMessage,
 R_TEXT_RESOURCE_DETAILS_VIEW_KEY_USAGE, usage );
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddKeyAlgorithmL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddKeyAlgorithmL( TDes& aMessage, const CCTKeyInfo* aKeyInfo )
+void CCTSecurityDialogsAO::AddKeyAlgorithmL( TDes& /*aMessage*/, const CCTKeyInfo* /*aKeyInfo*/ )
 {
+/*
 TInt algRes = 0;
 switch( aKeyInfo->Algorithm())
 {
 case CKeyInfoBase::ERSA:
 {
 algRes = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN;
 }
 }
 DetailsFieldResourceL( aMessage,
 R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM, algRes);
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddCertLocationL(...)
 // -----------------------------------------------------------------------------
 //                                               TUid* aLocUid)
 // Adds certificate/private key's location info to certificate details
 // ---------------------------------------------------------
 //
 void CCTSecurityDialogsAO::AddLocationInfoL(
-TDes& aMessage, TUid aUid, TBool aCertificate )
+TDes& /*aMessage*/, TUid /*aUid*/, TBool /*aCertificate*/ )
 {
+/*
 TInt location = 0;
 TInt locationRes =0;
 switch ( aUid.iUid )
 {
 {
 locationRes = R_TEXT_RESOURCE_DETAILS_VIEW_PRIVATE_KEY_LOCATION;
 }
 DetailsFieldResourceL( aMessage, locationRes, location );
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddValidityPeriodL(...)
 // -----------------------------------------------------------------------------
 void CCTSecurityDialogsAO::AddValidityPeriodL(
 TDes& aMessage, const CX509Certificate& aCert )
 {
 TLocale locale;
 TTimeIntervalSeconds offSet = locale.UniversalTimeOffset();
-DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_VALID_FROM );
+//DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_VALID_FROM );
 const CValidityPeriod& validityPeriod = aCert.ValidityPeriod();
 TTime startValue = validityPeriod.Start();
 startValue += offSet;
 TBuf<KMaxLengthTextDateString> startString;
 // read format string from AVKON resource
 AknTextUtils::DisplayTextLanguageSpecificNumberConversion( startString );
 CleanupStack::PopAndDestroy(); // dateFormatString
 aMessage.Append( startString );
 aMessage.Append( KEnterEnter );
-DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_VALID_UNTIL );
+//DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_VALID_UNTIL );
 TTime finishValue = validityPeriod.Finish();
 finishValue += offSet;
 TBuf<KMaxLengthTextDateString> finishString;
 // read format string from AVKON resource
 dateFormatString = CEikonEnv::Static()->AllocReadResourceLC(
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddCertFormatL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddCertFormatL( TDes& aMessage, TCertificateFormat aCertFormat)
+void CCTSecurityDialogsAO::AddCertFormatL( TDes& /*aMessage*/, TCertificateFormat aCertFormat)
 {
-TInt fieldType = 0;
+//TInt fieldType = 0;
 switch ( aCertFormat )
 {
 case EX509CertificateUrl:
 case EX509Certificate:
 {
-fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_CERT_FORMAT_X509;
+//fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_CERT_FORMAT_X509;
 break;
 }
 default:
 {
-fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED;
+//fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_NOT_DEFINED;
 break;
 }
 }
-DetailsFieldResourceL( aMessage,
+//DetailsFieldResourceL( aMessage,
-R_TEXT_RESOURCE_DETAILS_VIEW_CERT_FORMAT, fieldType );
+//    R_TEXT_RESOURCE_DETAILS_VIEW_CERT_FORMAT, fieldType );
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddCertAlgorithmsL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddCertAlgorithmsL( TDes& aMessage, const CX509Certificate& aCert )
+void CCTSecurityDialogsAO::AddCertAlgorithmsL( TDes& /*aMessage*/, const CX509Certificate& /*aCert*/ )
 {
+/*
 TInt fieldType = 0;
 TInt fieldType2 = 0;
 // digest algorithm
-TAlgorithmId algorithmId = aCert.SigningAlgorithm().DigestAlgorithm().Algorithm();
+TAlgorithmId algorithmId =
-fieldType = AlgorithmNameResourceId( algorithmId );
+aCert.SigningAlgorithm().DigestAlgorithm().Algorithm();
+switch ( algorithmId )
+{
+case EMD2:
+{
+fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_MD2;
+break;
+}
+case EMD5:
+{
+fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_MD5;
+break;
+}
+case ESHA1:
+{
+fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_SHA1;
+break;
+}
+default:
+{
+fieldType = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN;
+break;
+}
+}
 // public-key algorithm
-algorithmId = aCert.SigningAlgorithm().AsymmetricAlgorithm().Algorithm();
+algorithmId =
-fieldType2 = AlgorithmNameResourceId( algorithmId );
+aCert.SigningAlgorithm().AsymmetricAlgorithm().Algorithm();
+switch ( algorithmId )
+{
+case ERSA:
+{
+fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_RSA;
+break;
+}
+case EDSA:
+{
+fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DSA;
+break;
+}
+case EDH:
+{
+fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM_DH;
+break;
+}
+default:
+{
+fieldType2 = R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN;
+}
+}
 // If other algorithm is unknown
-if( fieldType == R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN ||
+if ( fieldType == R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN ||
 fieldType2 == R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN )
 {
 DetailsFieldResourceL( aMessage,
 R_TEXT_RESOURCE_DETAILS_VIEW_ALGORITHM, R_TEXT_RESOURCE_DETAILS_VIEW_UNKNOWN );
 }
 stringHolder = StringLoader::LoadLC( fieldType2 );
 aMessage.Append( stringHolder->Des() );
 CleanupStack::PopAndDestroy();  // stringHolder
 aMessage.Append( KEnterEnter );
 }
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddCertSerialNumberL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddCertSerialNumberL( TDes& aMessage, const CX509Certificate& aCert )
+void CCTSecurityDialogsAO::AddCertSerialNumberL( TDes& /*aMessage*/, const CX509Certificate& /*aCert*/ )
 {
+/*
 // certificate serial number
 DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_SERIAL_NUMBER );
 TPtrC8 serialNumber = aCert.SerialNumber();
 TBuf<KMaxLengthTextSerialNumberFormatting> buf2;
 buf2.Format( KCertManUIDetailsViewHexFormat, serialNumber[i] );
 aMessage.Append( buf2 );
 }
 aMessage.Append( KEnterEnter );
+*/
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::AddCertFingerprintsL(...)
 // -----------------------------------------------------------------------------
 //
-void CCTSecurityDialogsAO::AddCertFingerprintsL( TDes& aMessage, const CX509Certificate& aCert )
+void CCTSecurityDialogsAO::AddCertFingerprintsL( TDes& /*aMessage*/, const CX509Certificate& /*aCert*/ )
 {
+/*
 // certificate fingerprint SHA-1
 DetailsResourceL( aMessage, R_TEXT_RESOURCE_DETAILS_VIEW_FINGERPRINT );
 TPtrC8 sha1_fingerprint = aCert.Fingerprint();
 DevideToBlocks( sha1_fingerprint, aMessage );
 CleanupStack::PushL( md5 );
 TBuf8<20> fingerprint = md5->Hash( aCert.Encoding() );
 CleanupStack::PopAndDestroy( md5 );
 DevideToBlocks( fingerprint, aMessage );
+*/
 }
 // ---------------------------------------------------------
 // CCTSecurityDialogsAO::DevideToBlocks
 // ---------------------------------------------------------
 pinValueBufPtr = iPINValue1;
 }
 iMessagePtr.WriteL( iReplySlot, pinValueBufPtr );
 break;
 }
 case EChangePIN:
 case EUnblockPIN:
 {
 TTwoPINOutput twoPINOutput;
 twoPINOutput.iPINValueToCheck = iPINValue1;
 twoPINOutput.iNewPINValue = iPINValue2;
 TTwoPINOutputBuf twoPINOutputBuf( twoPINOutput );
 iMessagePtr.WriteL( iReplySlot, twoPINOutputBuf );
 break;
 }
 case ESignText: // flow thru
 case EUserAuthenticationText: // flow thru
 case EUserAuthentication:
 {
 TCTTokenObjectHandleBuf tokenObjectHandleBuf( iTokenHandle );
 iMessagePtr.WriteL( iReplySlot, tokenObjectHandleBuf );
 break;
 }
 case EServerAuthenticationFailure:
 {
 TServerAuthenticationFailureDialogResult result = EStop;
-if ( iRetValue != EServerCertAcceptedPermanently )
+if( iRetValue != EServerCertAcceptedPermanently )
 {
-if ( iRetValue == EServerCertAcceptedTemporarily )
+if( iRetValue == EServerCertAcceptedTemporarily )
 {
 result = EContinue;
 }
 else
 {
 iMessagePtr.WriteL( iReplySlot, output );
 iMessagePtr.Complete( KErrNone );
 break;
 }
 case EPINBlocked:
 case EUnblockPINInClear:
 {
 User::Leave( KErrNotSupported );
 break;
 }
 case ECreateCSR:
 case ECertDetails:
 case ESaveCert:
 case EDeleteCert:
 case ESaveReceipt:
 case MDigSigningNote::ENoSecurityModule:
 case MDigSigningNote::EInternalError:
 {
 break; // Complete is enough
 }
 default:
 User::Panic( _L("CTestSecDlgNotifier"), 0 );
 }
 if( iOperation != EServerAuthenticationFailure )
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::DoCancel()
 {
 WIMSECURITYDIALOGS_WRITE( "CCTSecurityDialogsAO::DoCancel" );
+/*
-// Note that iQueryDialog may point to already deleted memory.
+if( !iPinQueryDialogDeleted )
-// Dialogs need to set and reset iQueryDialogDeleted flag to
-// allow deleting the dialog from CCTSecurityDialogsAO.
-if( !iQueryDialogDeleted )
-{
-delete iQueryDialog;
-iQueryDialogDeleted = ETrue;
-}
-iQueryDialog = NULL;
-if ( !iPinQueryDialogDeleted )
 {
 delete iPinQueryDialog;
 iPinQueryDialogDeleted = ETrue;
 }
 iPinQueryDialog = NULL;
+*/
 // Complete message if it has not been completed earlier.
 if( !iMessagePtr.IsNull() )
 {
 iMessagePtr.Complete( KErrCancel );
 // CCTSecurityDialogsAO::DoHandleSaveServerCertL()
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::DoHandleSaveServerCertL()
 {
+TRACE( "CCTSecurityDialogsAO::DoHandleSaveServerCertL" );
 if ( iTrustedSiteCertStore )
 {
 iTrustedSiteCertStore->Add( *iCertLabel, EX509Certificate,
 EPeerCertificate, NULL, NULL, *iCertBuf, iStatus );
 // Next step is to update trust site db
 iNextStep = EAddTrustedSite;
 iStatus = KRequestPending;
 SetActive();
 default:
 break;
 }
 }
+void CCTSecurityDialogsAO::ShowInformationNoteL( TInt aResourceID ) const
+{
+HBufC* buffer = CEikonEnv::Static()->AllocReadResourceLC( aResourceID );
+CHbDeviceMessageBoxSymbian* iMessageBox = CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EInformation);
+CleanupStack::PushL(iMessageBox);
+iMessageBox->SetTextL(buffer->Des());
+iMessageBox->SetTimeout(6000);
+iMessageBox->ExecL();
+CleanupStack::PopAndDestroy(iMessageBox);
+CleanupStack::PopAndDestroy( buffer );
+}

branch	RCL_3
changeset 21	09b1ac925e3f
parent 20	63339781d179
child 22	03674e5abf46