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

equal deleted inserted replaced

-:b63e8c2d8cff
+:604cd42065d1
 #include "CTPinQueryDialog.h"
 #include "CTSignTextDialog.h"
 #include "CTSelectCertificateDialog.h"
 #include "CTQueryDialog.h"
 #include "CTPinPinQueryDialog.h"
-#include "CTNoTrustQuery.h"
+#include "CTUntrustedCertQuery.h"
 #include "CTInvalidCertNote.h"
 #include <PKIDlg.h>
 #include <badesca.h>
 #include <StringLoader.h>
 #include <aknnotewrappers.h>
 #include <hash.h>
 #include <x509certext.h>
 #include <TrustedSitesStore.h>
 #include <mctwritablecertstore.h>
+#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( KKeyStoreCreatePwLabel, "New key store passphrase" );
 _LIT( KKeyStoreImportKeyLabel, "Passphrase of the imported key file" );
 _LIT( KKeyStoreExportKeyLabel, "Passphrase of the exported key file" );
 _LIT( KPKCS12TokenLabel, "PKCS12");
+// TODO: replace with OST tracing
+#ifdef _DEBUG
+#include <e32debug.h>
+#define TRACE(x)        RDebug::Printf(x)
+#define TRACE1(x,y)     RDebug::Printf(x,y)
+#else
+#define TRACE(x)
+#define TRACE1(x,y)
+#endif
 // ============================ MEMBER FUNCTIONS ===============================
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::CCTSecurityDialogsAO
 // C++ default constructor can NOT contain any code, that
 // -----------------------------------------------------------------------------
 //
 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 )
 {
 // 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 );
 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 )
 {
 HBufC* dlgText2 = NULL;
 CCTPinPinQueryDialog* dlg = NULL;
 TDialogType dlgType = ( TDialogType )aDlgType;
 if ( EEnterNewKeyStorePw == dlgType )
 {
-dlgText1 = iNotifier->LoadResourceStringLC( dlgType, KNullDesC );
+/*
+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
+*/
+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 );
 {
 User::Panic(_L("CSecDlgNotifier"), 0);
 }
 }
 iPinQueryDialogDeleted = EFalse;
-CCTPinQueryDialog::RunDlgLD( iStatus,
+if(aDlgType!=EEnterKeyStorePw) {
-*dlgText,
+CCTPinQueryDialog::RunDlgLD( iStatus,
-*pinValue,
+*dlgText,
-aMinLength,
+*pinValue,
-aMaxLength,
+aMinLength,
-iRetValue,
+aMaxLength,
-resource,
+iRetValue,
-iPinQueryDialog,
+resource,
-iPinQueryDialogDeleted );
+iPinQueryDialog,
+iPinQueryDialogDeleted );
+			    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;
 }
 }
+if ( dlg && aDlgType!=EEnterKeyStorePw)
-if ( dlg )
+{
-{
 dlg->ExecuteLD( *dlgText );
 dlg = NULL;
 }
 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 );
 }
 }
 // CCTSecurityDialogsAO::ShowNoTrustDialogL()
 // -----------------------------------------------------------------------------
 //
 void CCTSecurityDialogsAO::ShowNoTrustDialogL()
 {
-CX509Certificate* cert = CX509Certificate::NewLC( iCertBuf->Des() );
+TRACE( "CCTSecurityDialogsAO::ShowNoTrustDialogL, begin" );
-TInt resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
-TBool showPermAccept = ETrue;
+// If trusted site certstore open has failed, then it is not possible to save
+// the host name for permanent use. Hence, choice for permanent accept is not
-if( iAuthFailReason == ESignatureInvalid || iAuthFailReason == ECertificateRevoked )
+// displayed if trusted site certstore open has failed. Other restrictions for
-{
+// permanent accept are defined in device dialog (UntrustedCertificateWidget).
-// Invalid or revoked certificate
+TBool isTrustedSiteCertStoreOpened = ( iTrustedSiteCertStore != NULL );
-CCTInvalidCertificateNote* note =
+CCTUntrustedCertQuery *untrustedCertDlg = CCTUntrustedCertQuery::NewLC(
-new( ELeave ) CCTInvalidCertificateNote( *this, iStatus );
+iAuthFailReason, *iCertBuf, *iServerName, isTrustedSiteCertStoreOpened );
-note->ExecuteLD( R_WIM_INVALID_CERTIFICATE_INFORMATION_NOTE );
-iRetValue = EServerCertNotAccepted;
+CCTUntrustedCertQuery::TResponse response = CCTUntrustedCertQuery::EQueryRejected;
-}
+untrustedCertDlg->ShowQueryAndWaitForResponseL( response );
-else
+switch( response )
 {
-if( iAuthFailReason == EValidatedOK || iAuthFailReason == EDateOutOfRange )
+case CCTUntrustedCertQuery::EQueryAccepted:
-{
+iRetValue = EServerCertAcceptedTemporarily;
-// Trusted certificate, but problems with CN or date
+break;
+case CCTUntrustedCertQuery::EQueryAcceptedPermanently:
-// Retrieve subject name
+// TODO: show confirmation note, qtn_httpsec_query_perm_accept_text
-const CX500DistinguishedName& dName = cert->SubjectName();
+// "Connection to site %U will be made in future without any warnings. Continue?""
+iRetValue = EServerCertAcceptedPermanently;
-// Retrieve common name
+break;
-HBufC* cn = dName.ExtractFieldL( KX520CommonName );
+case CCTUntrustedCertQuery::EQueryRejected:
+default:
-// Check common name first and then date
+iRetValue = EServerCertNotAccepted;
-if( !cn )
+break;
-{
+}
-// Couldn't retrieve CN from certificate
+CleanupStack::PopAndDestroy( untrustedCertDlg );
-resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
+TRACE1( "CCTSecurityDialogsAO::ShowNoTrustDialogL, iRetValue=%d", iRetValue );
-}
-else if( iServerName->Des() != cn->Des() )
-{
-// Domain name doesn't match with CN
-resourceid = R_WIM_NO_TRUST_QUERY_SITE;
-}
-else if( iAuthFailReason == EDateOutOfRange )
-{
-// Certificate is out of date
-resourceid = R_WIM_NO_TRUST_QUERY_OOD;
-showPermAccept = EFalse;
-}
-else
-{
-// Otherwise show general untrusted note
-resourceid = R_WIM_NO_TRUST_QUERY_UNTRUSTED;
-}
-}
-else
-{
-// Untrusted certificate
-resourceid = R_WIM_NO_TRUST_QUERY_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;
-}
-iQueryDialog = new( ELeave ) CCTNoTrustQuery( *this, iRetValue, iStatus, iServerName,
-showPermAccept, iQueryDialogDeleted );
-iQueryDialog->ExecuteLD( resourceid );
-}
-CleanupStack::PopAndDestroy( cert );
 iNextStep = EServerCertCheckUserResp;
 iStatus = KRequestPending;
+TRequestStatus* status = &iStatus;
+User::RequestComplete( status, KErrNone );
 SetActive();
 }
 // -----------------------------------------------------------------------------
 // CCTSecurityDialogsAO::ShowCSRDialogL()
 // -----------------------------------------------------------------------------
 // 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:
 {
 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" );
+if( !iPinQueryDialogDeleted )
-// Note that iQueryDialog may point to already deleted memory.
-// 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;
 // 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	GCC_SURGE
changeset 40	604cd42065d1
parent 38	e0432375ea67
child 45	5d3e34b7618a