FCL/sf/app/jrt: comparison javaextensions/satsa/pki/src.s60/cstssignatureservice.cpp

equal deleted inserted replaced

-:35baca0e7a2e
+:023eef975703
 *
 * Description:
 *
 */
-// INCLUDE FILES
 #include "cstssignatureservice.h"
 #include "tstsdistinguishednameconverter.h"
 #include "secdlg.h"
 #include <unifiedcertstore.h>
 #include <asn1enc.h>
 #include <asymmetric.h>
 #include <CCMSX509Certificate.h>
 #include <CCMSSignerInfo.h>
 #include <CCMSEncapsulatedContentInfo.h>
 #include <CCMSSignedData.h>
-#include <PKIDlg.h>
 #include "cstsseprompt.h"
 #include <hash.h>
 #include "fs_methodcall.h"
 #include <jutils.h>
 #include "satsajnitools.h"
 #include "logger.h"
 #include "jstringutils.h"
-// CONSTANTS
+#include <hbdevicemessageboxsymbian.h>
+#include <hbpopup.h>
 const TInt KDefaultGranularity = 1;
 const TInt KOptionIncludeContent = 1;
 const TInt KOptionIncludeCertificate = 2;
 {
 if (iDialog)
 {
 iDialog->Release(); // Release deletes the object
 }
-if (iPKIDialog)
-{
-iPKIDialog->Release();
-}
 iCertificateArray.Close();
 iCertInfos.Close();
 delete iFilter;
 iDERNamesHBufC.ResetAndDestroy();
 iDERNames.Close();
 //
 HBufC8* CSTSSignatureService::AuthenticateL(const TDesC8& abytesToAuthenticate,
 TInt aOptions, const CDesCArray& aCaNames,
 const TDesC& asecurityElementPrompt, TBool aShowData)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::AuthenticateL");
 if (iState != EReady)
 {
 ELOG(ESATSA, "CSTSSignatureService::AuthenticateL: Not Ready");
 User::Leave(KErrNotReady);
 }
-LOG(ESATSA, EInfo, "CSTSSignatureService::AuthenticateL:After convertions");
 // First we need to convert the data to unicode, if we have to display it
 HBufC* textToDisplay = NULL;
 if (aShowData)
 {
 textToDisplay = ConvertUTF8ToUnicodeL(abytesToAuthenticate);
 iMessage.Set(abytesToAuthenticate);
 iOptions = aOptions;
 iShowNotes = EFalse;
-LOG(ESATSA, EInfo, "CSTSSignatureService::AuthenticateL:Going to call CreateSignatureL");
 // get handles to applicable certificates
 HBufC8* retVal = CreateSignatureL(aCaNames, EX509UsageDigitalSignature,
 asecurityElementPrompt);
-LOG(ESATSA, EInfo, "CSTSSignatureService::AuthenticateL:After call to CreateSignatureL");
-LOG(ESATSA, EInfo, "-- CSTSSignatureService::AuthenticateL");
 return retVal;
 }
 TInt CSTSSignatureService::StaticAuthenticateL(JNIEnv* aJniEnv,
 CSTSSignatureService* service, jbyteArray aByteArrayToAuthenticate,
 jint aOptions, jobjectArray aCaNames, jstring aSecurityElementPrompt,
 jboolean aShowData, HBufC8** aRetVal)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::StaticAuthenticateL");
 const TInt byteArrayLength = aJniEnv->GetArrayLength(
 aByteArrayToAuthenticate);
 jbyte* bytesToAuthenticate = aJniEnv->GetByteArrayElements(
 aByteArrayToAuthenticate, NULL);
 byteArrayLength);
 CDesCArrayFlat* nativeCaNames = STSCreateNativeStringArrayL(aJniEnv,
 aCaNames);
-LOG(ESATSA, EInfo,  "CSTSSignatureService::StaticAuthenticateL: prepare se prompt");
 const JStringUtils securityElementPrompt(*aJniEnv, aSecurityElementPrompt);
-LOG(ESATSA, EInfo,  "CSTSSignatureService::StaticAuthenticateL: start convertions to TInt");
 TBool ShowData = static_cast<TBool>(aShowData);
 const TDesC* sec = static_cast<const TDesC*>(&securityElementPrompt);
-LOG(ESATSA, EInfo, "CSTSSignatureService::StaticAuthenticateL: After convertions,going to call CallMethodL");
 TRAPD(err, CallMethodL(*aRetVal, service,
 &CSTSSignatureService::AuthenticateL, desToAuthenticate, aOptions,
 *nativeCaNames, *sec, ShowData, service));
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::StaticAuthenticateL:After CallmethodL");
-LOG(ESATSA, EInfo, "-- return CSTSSignatureService::StaticAuthenticateL");
 return err;
 }
 // -----------------------------------------------------------------------------
 // -----------------------------------------------------------------------------
 HBufC8* CSTSSignatureService::SignL(const TDesC8& aBytesToSign, TInt aOptions,
 const CDesCArray& aCaNames, const TDesC& aSecurityElementPrompt)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::SignL");
 if (iState != EReady)
 {
 ELOG(ESATSA, "CSTSSignatureService::SignL: Not Ready");
 User::Leave(KErrNotReady);
 }
-LOG(ESATSA, EInfo, "CSTSSignatureService::SignL: start convertions!");
-LOG(ESATSA, EInfo, "CSTSSignatureService::SignL: After convertions");
 // convert text from UTF8
 HBufC* textToDisplay = ConvertUTF8ToUnicodeL(aBytesToSign);
 delete iTextToDisplay;
 iTextToDisplay = textToDisplay;
 iOptions = aOptions;
 iShowNotes = ETrue;
-LOG(ESATSA, EInfo, "CSTSSignatureService::SignL: Before call to CreateSignatureL");
 // get handles to applicable certificates
 HBufC8* retVal = CreateSignatureL(aCaNames, EX509UsageNonRepudiation,
 aSecurityElementPrompt);
-LOG(ESATSA, EInfo, "-- return CSTSSignatureService::SignL");
 return retVal;
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::StaticSignL
 //
 TInt CSTSSignatureService::StaticSignL(JNIEnv* aJniEnv,
 CSTSSignatureService* service, jbyteArray aBytesToSign, jint aOptions,
 jobjectArray aCaNames, jstring aSecurityElementPrompt, HBufC8** aRetVal)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::StaticSignL");
 const TInt byteArrayLength = aJniEnv->GetArrayLength(aBytesToSign);
 jbyte* bytesToSign = aJniEnv->GetByteArrayElements(aBytesToSign, NULL);
 if (!bytesToSign)
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::StaticSignL: No memory");
+ELOG(ESATSA, "CSTSSignatureService::StaticSignL: No memory");
 return NULL;
 }
 TPtrC8 desToSign(reinterpret_cast<TUint8*>(bytesToSign), byteArrayLength);
 CDesCArrayFlat* nativeCaNames = STSCreateNativeStringArrayL(aJniEnv,
 aCaNames);
 const JStringUtils securityElementPrompt(*aJniEnv, aSecurityElementPrompt);
-LOG(ESATSA, EInfo, "CSTSSignatureService::StaticSignL: Start convertions");
-LOG(ESATSA, EInfo, "CSTSSignatureService::StaticSignL: Before callmethodl");
 const TDesC* sec = static_cast<const TDesC*>(&securityElementPrompt);
 TRAPD(err, CallMethodL(*aRetVal, service, &CSTSSignatureService::SignL,
 desToSign, aOptions, *nativeCaNames, *sec, service));
-LOG(ESATSA, EInfo, "-- ret CSTSSignatureService::StaticSignL");
 return err;
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::RunL
 // CActive callback
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::RunL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::RunL");
 if (iStatus == KErrCancel)
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: KErrCancel");
 if (iShowNotes)
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: ShowNote");
 iState = EFinalNote;
 iStatus = KErrNone;
-iPKIDialog->Note(MPKIDialog::ESigningCancelled, iStatus);
+// Using Orbit API
+CHbDeviceMessageBoxSymbian* messageBox
+= CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EWarning);
+CleanupStack::PushL(messageBox);
+_LIT(KQuestion, "Do you want to sign the data?");
+messageBox->SetTextL(KQuestion);
+messageBox->SetTimeout(HbPopup::NoTimeout);
+// Read localised versions instead of hard coded values.
+_LIT(KAllowButtonText, "Allow");
+_LIT(KDenyButtonText, "Deny");
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::EAcceptButton, KAllowButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::EAcceptButton, ETrue);
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::ERejectButton, KDenyButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::ERejectButton, ETrue);
+// by default the answer is Allow
+if (messageBox->ExecL() == CHbDeviceMessageBoxSymbian::ERejectButton)
+{
+}
+messageBox->Close();
+CleanupStack::PopAndDestroy(messageBox);
 SetActive();
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: Done ShowNote");
+}
-}
 else
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: Complete");
+Complete(KErrNone);
-Complete(KErrNone);
 }
 }
 else if (iStatus != KErrNone)
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: Error occured");
+ELOG(ESATSA, "CSTSSignatureService::RunL: Error occured");
 // Error has occured; inform java
 Complete(iStatus.Int());
 }
 else
 {
 switch (iState)
 {
 case EInitialising:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EInitialising");
 iState = EKeyStoreInit;
 iKeyStore->Initialize(iStatus);
 SetActive();
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: over case EInitialising");
 break;
 }
 case EKeyStoreInit:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EKeyStoreInit");
 Complete(KErrNone);
 break;
 }
 case EListing:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EListing");
 HandlesFromCertInfosL();
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: over case EListing");
 break;
 }
 case EDialog:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EDialog");
 iState = EGetCert;
 if (iCertificate)
 {
 iCertificate->Release();
 iCertificate = NULL;
 iCertificateHandle = iCertificateArray[0];
 }
 iCertStore->GetCert(iCertificate, iCertificateHandle, iStatus);
 SetActive();
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: over case EDialog");
 break;
 }
 case EGetCert:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EGetCert");
 if (iX509Certificate)
 {
 delete iX509Certificate;
 iX509Certificate = NULL;
 }
 iState = ERetrieveCert;
 iCertStore->Retrieve(*iCertificate, iX509Certificate, iStatus);
 SetActive();
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: over case EGetCert");
 break;
 }
 case ERetrieveCert:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case ERetrieveCert");
 FindKeyL();
 break;
 }
 case EFindKey:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EFindKey");
 OpenSignerL();
 break;
 }
 case EOpenSigner:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EOpenSigner");
 SignL();
 break;
 }
 case ESign:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case ESign");
 CreateSignedDataL();
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: over case ESign");
 break;
 }
 case EFinalNote:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case EFinalNote");
 Complete(KErrNone);
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: over case EFinalNote");
 break;
 }
 default:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::RunL: case default");
 Complete(KErrGeneral);
 }
 }
 }
 }
 // CActive error callback
 // -----------------------------------------------------------------------------
 //
 TInt CSTSSignatureService::RunError(TInt aError)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::RunError");
 Complete(aError);
 return KErrNone;
 }
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::ConstructL()
 {
 User::LeaveIfError(iFileServer.Connect());
 iDialog = SecurityDialogFactory::CreateL();
-iPKIDialog = PKIDialogFactory::CreateNoteL();
 iFilter = CCertAttributeFilter::NewL();
 iWait = new(ELeave) CActiveSchedulerWait;
 iCertStore = CUnifiedCertStore::NewL(iFileServer, ETrue);
 iKeyStore = CUnifiedKeyStore::NewL(iFileServer);
 // Completes the operation
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::Complete(TInt aError)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::Complete");
 if (KErrNone == aError)
 {
 iState = EReady;
 }
 else
 {
 iState = EERROR;
 iError = aError;
 }
 iWait->AsyncStop();
-LOG(ESATSA, EInfo, "-- ret CSTSSignatureService::Complete");
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::WaitForCompletionL()
 // Wait for completion, leave on error
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::WaitForCompletionL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::WaitForCompletionL");
 SetActive();
 iWait->Start();
 if (iState != EReady)
 {
 // we need to be ready for the next request
 iState = EReady;
 User::Leave(iError);
 }
-LOG(ESATSA, EInfo, "- ret CSTSSignatureService::WaitForCompletionL");
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::CreateSignatureL()
 // Creates the signature
 // -----------------------------------------------------------------------------
 //
 HBufC8* CSTSSignatureService::CreateSignatureL(const CDesCArray& aCaNames,
 const TKeyUsageX509 aUsage, const TDesC& aSecurityElementPrompt)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::CreateSignatureL");
 HBufC* sePrompt = NULL;
 if (aSecurityElementPrompt != KNullDesC())
 {
 sePrompt = aSecurityElementPrompt.AllocL();
 }
 delete iSecurityElementPrompt;
 iSecurityElementPrompt = sePrompt;
-LOG(ESATSA, EInfo, "CSTSSignatureService::CreateSignatureL: call findcertificates");
 FindCertificatesL(aCaNames, aUsage);
-LOG(ESATSA, EInfo, "CSTSSignatureService::CreateSignatureL: After call to findcertificates");
 WaitForCompletionL();
-LOG(ESATSA, EInfo, "CSTSSignatureService::CreateSignatureL: call WaitForCompletion");
 HBufC8* retVal = iSignature;
 iSignature = NULL;
-LOG(ESATSA, EInfo, "-- ret CSTSSignatureService::CreateSignatureL");
 return retVal;
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::FindCertificatesL()
 // Find applicable certificates
 //
 void CSTSSignatureService::FindCertificatesL(const CDesCArray& aCaNames,
 const TKeyUsageX509 aUsage)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::FindCertificatesL");
 iFilter->SetKeyUsage(aUsage);
 iFilter->SetOwnerType(EUserCertificate);
 iFilter->SetFormat(EX509Certificate);
 iCertInfos.Close();
 }
 iState = EListing;
 iCertStore->List(iCertInfos, *iFilter, iDERNames, iStatus);
 }
-LOG(ESATSA, EInfo, "-- ret CSTSSignatureService::FindCertificatesL");
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::HandlesFromCertInfosL()
 // Fills iCertificateArray from iCertInfos.
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::HandlesFromCertInfosL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::HandlesFromCertInfosL");
 TInt certificateCount = iCertInfos.Count();
 if (certificateCount == 0)
 {
 ELOG(ESATSA, "CSTSSignatureService::HandlesFromCertInfosL, KErrNotFound");
 User::Leave(KErrNotFound);
 }
 iCertificateArray.Reset();
 for (TInt i = 0; i < certificateCount; i++)
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::HandlesFromCertInfosL: No Certificates");
 User::LeaveIfError(iCertificateArray.Append(iCertInfos[i]->Handle()));
 }
 // next is a dialog shown depending on the authentication type
 switch (iAuthType)
 {
 case EAuthWithoutText:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::HandlesFromCertInfosL: case EAuthWithoutText");
+// Use Orbit API
-iPKIDialog->UserAuthentication(iCertificateArray, iCertificateHandle,
+CHbDeviceMessageBoxSymbian* messageBox
-iStatus);
+= CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EWarning);
-LOG(ESATSA, EInfo, "CSTSSignatureService::HandlesFromCertInfosL: over case EAuthWithoutText");
+CleanupStack::PushL(messageBox);
+_LIT(KQuestion, "Do you want to sign the data?");
+messageBox->SetTextL(KQuestion);
+messageBox->SetTimeout(HbPopup::NoTimeout);
+// Read localised versions instead of hard coded values.
+_LIT(KAllowButtonText, "Allow");
+_LIT(KDenyButtonText, "Deny");
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::EAcceptButton, KAllowButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::EAcceptButton, ETrue);
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::ERejectButton, KDenyButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::ERejectButton, ETrue);
+// by default the answer is Allow
+if (messageBox->ExecL() == CHbDeviceMessageBoxSymbian::ERejectButton)
+{
+}
+messageBox->Close();
+CleanupStack::PopAndDestroy(messageBox);
 break;
 }
 case EAuthWithText:
 {
-LOG(ESATSA, EInfo, "CSTSSignatureService::HandlesFromCertInfosL: case EAuthWithText");
+// Use Orbit API
-iPKIDialog->UserAuthenticationText(*iTextToDisplay, iCertificateArray,
+CHbDeviceMessageBoxSymbian* messageBox
-iCertificateHandle, iStatus);
+= CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EWarning);
-LOG(ESATSA, EInfo, "CSTSSignatureService::HandlesFromCertInfosL: over case EAuthWithText");
+CleanupStack::PushL(messageBox);
+_LIT(KQuestion, "Do you want to sign the data?");
+messageBox->SetTextL(KQuestion);
+messageBox->SetTimeout(HbPopup::NoTimeout);
+// Read localised versions instead of hard coded values.
+_LIT(KAllowButtonText, "Allow");
+_LIT(KDenyButtonText, "Deny");
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::EAcceptButton, KAllowButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::EAcceptButton, ETrue);
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::ERejectButton, KDenyButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::ERejectButton, ETrue);
+// by default the answer is Allow
+if (messageBox->ExecL() == CHbDeviceMessageBoxSymbian::ERejectButton)
+{
+}
+messageBox->Close();
+CleanupStack::PopAndDestroy(messageBox);
 break;
 }
 case ESignWithText:
 {
 iDialog->SignText(*iTextToDisplay, iCertificateArray,
 // Finds the key used in iCertificate.
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::FindKeyL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::FindKeyL");
 iKeyFilter.iKeyAlgorithm = CKeyInfoBase::EInvalidAlgorithm;
 iKeyFilter.iKeyId = iCertificate->SubjectKeyId();
 iKeyFilter.iUsage = EPKCS15UsageAll;
 iKeys.Close();
 // Opens a signer for the key in iKeys.
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::OpenSignerL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::OpenSignerL");
 // if key is not found, display security element prompt and search again
 if (iKeys.Count() == 0)
 {
 if (iSecurityElementPrompt)
 {
 // Signs the message
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::SignL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::SignL");
 // first we create a digest of the message
 CSHA1* sha = CSHA1::NewL();
 CleanupStack::PushL(sha);
 TPtrC8 hash = sha->Hash(iMessage);
 // Creates signed data
 // -----------------------------------------------------------------------------
 //
 void CSTSSignatureService::CreateSignedDataL()
 {
-LOG(ESATSA, EInfo, "+ CSTSSignatureService::CreateSignedDataL");
 CCTKeyInfo* keyInfo = iKeys[0];
 HBufC8* signature = NULL;
 switch (keyInfo->Algorithm())
 {
 CleanupStack::PopAndDestroy(8);
 if (iShowNotes)
 {
 iState = EFinalNote;
-iPKIDialog->Note(MPKIDialog::ESignatureDone, iStatus);
+//proper string for user prompt
+CHbDeviceMessageBoxSymbian* messageBox
+= CHbDeviceMessageBoxSymbian::NewL(CHbDeviceMessageBoxSymbian::EWarning);
+CleanupStack::PushL(messageBox);
+_LIT(KQuestion, "Do you want to sign the data?");
+messageBox->SetTextL(KQuestion);
+messageBox->SetTimeout(HbPopup::NoTimeout);
+// Read localised versions instead of hard coded values.
+_LIT(KAllowButtonText, "Allow");
+_LIT(KDenyButtonText, "Deny");
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::EAcceptButton, KAllowButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::EAcceptButton, ETrue);
+messageBox->SetButtonTextL(CHbDeviceMessageBoxSymbian::ERejectButton, KDenyButtonText);
+messageBox->SetButton(CHbDeviceMessageBoxSymbian::ERejectButton, ETrue);
+// by default the answer is Allow
+if (messageBox->ExecL() == CHbDeviceMessageBoxSymbian::ERejectButton)
+{
+}
+messageBox->Close();
+CleanupStack::PopAndDestroy(messageBox);
 SetActive();
 }
 else
 {
 Complete(KErrNone);
 }
-LOG(ESATSA, EInfo, "-- ret CSTSSignatureService::CreateSignedDataL");
 }
 // -----------------------------------------------------------------------------
 // CSTSSignatureService::ConvertUTF8ToUnicodeLC()
 // Converts UTF8 data to Unicode

changeset 50	023eef975703
parent 21	2a9601315dfc
child 56	abc41079b313