FCL/sf/mw/securitysrv: comparison securitydialogs/SecUi/Src/SecUiSecurityHandler.cpp

equal deleted inserted replaced

-:b63e8c2d8cff
+:604cd42065d1
 *
 * Description:  Provides api for handling security events.
 *
 *
 */
+#include <e32notif.h>
 #include <aknnotedialog.h>
 #include <etelmm.h>
-#include <SecUi.rsg>
+// #include <SecUi.rsg>
 #include <exterror.h>
 #include <textresolver.h>
 #ifdef __COVER_DISPLAY
 #include <aknmediatorfacade.h>
 // #include <secondarydisplay/SecondaryDisplayStartupAPI.h>
 #endif //__COVER_DISPLAY
 #include <centralrepository.h>
 #include <starterclient.h>     //used for RemoveSplashScreen
 #include <e32property.h>
 #include <PSVariables.h>   // Property values
 #include <coreapplicationuisdomainpskeys.h>
 #include <startupdomainpskeys.h>
 #include <uikon/eiksrvui.h>
 #include <settingsinternalcrkeys.h>
 #include <AknNotiferAppServerApplication.h>
 #include <SCPClient.h>
 #include <securitynotification.h>
 #include "secui.hrh"
+#include "SecUi.h"
 #include "secuisecurityhandler.h"
 #include "secuicodequerydialog.h"
 #include "secuisecuritysettings.h"
 #include "SecUiWait.h"
-#include "SecUiLockObserver.h"
+// #include "SecUiLockObserver.h"
-#ifdef RD_REMOTELOCK
 #include <RemoteLockSettings.h>
-#endif // RD_REMOTELOCK
 #include <StringLoader.h>
 #include <featmgr.h>
 #include "SecQueryUi.h"
 //  LOCAL CONSTANTS AND MACROS
 const TInt KMaxNumberOfPUKAttempts(10);
 const TInt KMaxNumberOfPINAttempts(3);
-const TInt KLastRemainingInputAttempt(1);
+// not used
+// const TInt KLastRemainingInputAttempt(1);
 const TInt KTriesToConnectServer(2);
 const TInt KTimeBeforeRetryingRequest(50000);
 // ================= MEMBER FUNCTIONS =======================
 if (iDestroyedPtr)
 {
 *iDestroyedPtr = ETrue;
 iDestroyedPtr = NULL;
 }
-CancelSecCodeQuery();
+RDEBUG("calling CancelOpenQuery", 0);
+TInt err = CancelOpenQuery(-1);
+RDEBUG("err", err);
 iCustomPhone.Close();
 FeatureManager::UnInitializeLib();
+	RDEBUG("1", 1);
 }
 //
 // ----------------------------------------------------------
 // CSecurityHandler::HandleEventL()
 // Handles different security events
 RDEBUG("aEvent", aEvent);
 switch (aEvent)
 {
 case RMobilePhone::EPin1Required:
-#if defined(_DEBUG)
+						RDEBUG("RMobilePhone::EPin1Required", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() Pin1Required"));
-#endif
 aResult = Pin1RequiredL();
 break;
 case RMobilePhone::EPuk1Required:
-#if defined(_DEBUG)
+						RDEBUG("RMobilePhone::EPuk1Required", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::HandleEventL() PUK1Required"));
-#endif
 Puk1RequiredL();
 break;
 case RMobilePhone::EPin2Required:
 Pin2RequiredL();
 break;
 break;
 case RMobilePhone::EICCTerminated:
 SimLockEventL();
 break;
 default:
+		RDEBUG("default", aEvent);
 break;
 }
 RDEBUG("aResult", aResult);
 }
 //
 {
 /*****************************************************
 *    Series 60 Customer / ETel
 *    Series 60  ETel API
 *****************************************************/
-#if defined(_DEBUG)
+		RDEBUG("0", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeL()"));
-#endif
 /* if code is still not initialized, then there's no need to ask it. This fixes the error when the RFS requests the code */
 const TUid KCRUidSCPLockCode =
 {
 0x2002677B
 // code is the default one; no need to request it.
 return ETrue;
 }
 /* end check for default code */
-iQueryCanceled = EFalse;
 RMobilePhone::TMobilePassword required_fourth;
 TInt ret = KErrNone;
 TInt status = KErrNone;
 /* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+				iQueryCanceled = EFalse;
 lAlphaSupported = ESecUiAlphaSupported;
 lCancelSupported = ESecUiCancelSupported;
 TBuf<0x100> title;
 title.Zero();
 title.Append(_L("AskSecCodeL"));
 queryAccepted
 = iSecQueryUi->SecQueryDialog(title, iSecUi_password,
 SEC_C_SECURITY_CODE_MIN_LENGTH,
 SEC_C_SECURITY_CODE_MAX_LENGTH, ESecUiSecretSupported
 | lAlphaSupported | lCancelSupported
-| secCodeType /*aMode*/);
+| secCodeType );
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
 RDEBUG("delete", 0);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 /* end request PIN using QT */
 if (queryAccepted != KErrNone)
 {
 CleanupStack::PopAndDestroy(); //scpClient
 queryAccepted = KErrNone;
 }
-iQueryCanceled = ETrue; // TODO
+iQueryCanceled = ETrue;
 return ETrue;
 }
 case KErrGsmSSPasswordAttemptsViolation:
 case KErrLocked:
 {
 iQueryCanceled = ETrue;
 return ret;
 }
 //
 // ----------------------------------------------------------
+// Cancels all security code queries
+// aStatus = -1		from destructor
+// aStatus =  1		from API. Will kill all dialogs through signal P&S
+// ----------------------------------------------------------
+// qtdone
+TInt CSecurityHandler::CancelOpenQuery(TInt aStatus)
+{
+		RDEBUG("aStatus", aStatus);
+		RDEBUG("iQueryCanceled", iQueryCanceled);
+		TInt res = 0;
+		if(aStatus==1)	// also signal all other dialogs
+				{
+				RDEBUG("set KSecurityUIsDismissDialog to ESecurityUIsDismissDialogOn", ESecurityUIsDismissDialogOn);
+		    TInt err = RProperty::Set(KPSUidSecurityUIs, KSecurityUIsDismissDialog, ESecurityUIsDismissDialogOn );
+		    RDEBUG("err", err);
+		    res += 1;
+			  }
+if (!iQueryCanceled)
+{
+				// notify all dialogs, in particular SecUiNotificationDialog::subscriberKSecurityUIsDismissDialogChanged
+				// this will cancel only the dialog which was opened by same client.
+		res += 0x10;
+iQueryCanceled = ETrue;
+if (iSecurityDlg != NULL)
+{
+RDEBUG("deleting iSecurityDlg", 0);
+		    		res += 0x100;
+delete iSecurityDlg;
+}
+if (iNoteDlg != NULL)
+{
+RDEBUG("deleting iNoteDlg", 0);
+		    		res += 0x1000;
+delete iNoteDlg;
+}
+iNoteDlg = NULL;
+iSecurityDlg = NULL;
+}
+		res += 0x10000;
+		RDEBUG("res", res);
+		return res;
+		}
+//
+// ----------------------------------------------------------
 // CSecurityHandler::CancelSecCodeQuery()
 // Cancels PIN2 and security code queries
-// TODO is this used?
+// this is used by rfsHandler
 // ----------------------------------------------------------
 // qtdone
 EXPORT_C void CSecurityHandler::CancelSecCodeQuery()
 {
-#if defined(_DEBUG)
+		RDEBUG("0", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::CancelSecCodeQuery()"));
-#endif
+		TInt err = CancelOpenQuery(1);
-if (!iQueryCanceled)
-{
+		RDEBUG("err", err);
-iQueryCanceled = ETrue;
-if (iSecurityDlg != NULL)
-{
-delete iSecurityDlg;
-}
-if (iNoteDlg != NULL)
-{
-delete iNoteDlg;
-}
-iNoteDlg = NULL;
-iSecurityDlg = NULL;
-}
 }
 //
 // ----------------------------------------------------------
 // CSecurityHandler::AskSecCodeInAutoLock()
 // for asking security code in autolock
 *    Series 60 Customer / ETel
 *    Series 60  ETel API
 *****************************************************/
 RDEBUG("0", 0);
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL()"));
-#endif
 TInt res;
 CWait* wait;
 RMobilePhone::TMobilePhoneLockSetting lockChange(
 RMobilePhone::ELockSetDisabled);
 RMobilePhone::TMobilePhoneLock lockType = RMobilePhone::ELockPhoneDevice;
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() get autolock period"));
-#endif
 // get autolock period from Central Repository.
 CRepository* repository = CRepository::NewL(KCRUidSecuritySettings);
 TInt period = 0;
 res = repository->Get(KSettingsAutoLockTime, period);
 delete repository;
 RDEBUG("res", res);
+RDEBUG("period", period);
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() autolock period:%d"), res);
-#endif
 if (res == KErrNone)
 {
 // disable autolock in Domestic OS side too if autolock period is 0.
-RDEBUG("period", period);
 if (period == 0)
 {
-#if defined(_DEBUG)
+						RDEBUG("period", period);
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Call SetLockSetting"));
-#endif
-#ifdef RD_REMOTELOCK
 // If remote lock is enabled, don't disable the domestic OS device lock
 // since that would render the RemoteLock useless.
 // Instead just re-set the DOS lock to enabled which as a side effect
 // requests the security code from the user.
 {
 RDEBUG( "0", 0 );
 if ( remoteLockStatus )
 {
 // Remote lock is enabled
-#ifdef _DEBUG
-RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - RemoteLock is enabled: lockChange = RMobilePhone::ELockSetEnabled" ) );
-#endif // _DEBUG
 lockChange = RMobilePhone::ELockSetEnabled;
+RDEBUG("lockChange", lockChange);
 }
 else
 {
 // Remote lock is disabled
-#ifdef _DEBUG
-RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - RemoteLock is disabled: lockChange = RMobilePhone::ELockSetDisabled" ) );
-#endif // _DEBUG
 lockChange = RMobilePhone::ELockSetDisabled;
+RDEBUG("lockChange", lockChange);
 }
 }
 else
 {
 // Failed to get remote lock status
-#ifdef _DEBUG
+								RDEBUG("Failed", lockChange);
-RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - Failed to get RemoteLock status" ) );
-#endif // _DEBUG
 }
 delete remoteLockSettings;
 remoteLockSettings = NULL;
-#else // not defined RD_REMOTELOCK
-lockChange = RMobilePhone::ELockSetDisabled;
-#endif // RD_REMOTELOCK
 RDEBUG("lockChange", lockChange);
 wait = CWait::NewL();
 RDEBUG("0", 0);
 // this also calls PassPhraseRequiredL ???
 RDEBUG("SetLockSetting", 1);
 res = KErrNone;
 RDEBUG("WaitForRequestL", 0);
 res = wait->WaitForRequestL();
 RDEBUG("res", res);
 delete wait;
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() SetLockSetting RESULT:%d"), res);
-#endif
 } // from   period == 0
 else
 { // ask security code
-#if defined(_DEBUG)
+RDEBUG("codeQueryNotifier 0", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Ask sec code via notifier"));
-#endif
-RDEBUG("0", 0);
 RNotifier codeQueryNotifier;
 User::LeaveIfError(codeQueryNotifier.Connect());
 CWait* wait = CWait::NewL();
 CleanupStack::PushL(wait);
 TInt queryResponse = 0;
 RDEBUG("0", 0);
 TSecurityNotificationPckg params;
 params().iEvent
 = static_cast<TInt> (RMobilePhone::EPhonePasswordRequired);
 params().iStartup = EFalse;
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() Start Notifier"));
-#endif
-RDEBUG("0", 0);
 RDEBUG("StartNotifierAndGetResponse", 0);
 codeQueryNotifier.StartNotifierAndGetResponse(wait->iStatus,
 KSecurityNotifierUid, params, response);
 // this will eventually call PassPhraseRequiredL
 RDEBUG("WaitForRequestL", 0);
 }
 else
 { // can't read repository for KSettingsAutoLockTime
 RDEBUG("KERRSOMETHING:Call SetLockSetting", 0);
-#ifdef RD_REMOTELOCK
 // If remote lock is enabled, don't disable the domestic OS device lock
 // since that would render the RemoteLock useless.
 // Instead just re-set the DOS lock to enabled which as a side effect
 // requests the security code from the user.
 if ( remoteLockSettings->GetEnabled( remoteLockStatus ) )
 {
 if ( remoteLockStatus )
 {
 // Remote lock is enabled
-#ifdef _DEBUG
-RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - Failed to get AutoLock status and RemoteLock is enabled: lockChange = RMobilePhone::ELockSetEnabled" ) );
-#endif // _DEBUG
 lockChange = RMobilePhone::ELockSetEnabled;
+RDEBUG("lockChange", lockChange);
 }
 else
 {
 // Remote lock is disabled
-#ifdef _DEBUG
-RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - Failed to get AutoLock status and RemoteLock is disabled: lockChange = RMobilePhone::ELockSetDisabled" ) );
-#endif // _DEBUG
 lockChange = RMobilePhone::ELockSetDisabled;
+RDEBUG("lockChange", lockChange);
 }
 }
 else
 {
 // Failed to get remote lock status
-#ifdef _DEBUG
+RDEBUG("Failed", lockChange);
-RDebug::Print( _L( "(SecUi)CSecurityHandler::AskSecCodeInAutoLockL() - Failed to get AutoLock status and failed to get RemoteLock status" ) );
-#endif // _DEBUG
 }
 delete remoteLockSettings;
 remoteLockSettings = NULL;
-#else // not defined RD_REMOTELOCK
-// could not get the current autolock time... disable autolock in Domestic OS side.
-lockChange = RMobilePhone::ELockSetDisabled;
-#endif // RD_REMOTELOCK
 RDEBUG("0", 0);
 wait = CWait::NewL();
 RDEBUG("SetLockSetting", 0);
 iPhone.SetLockSetting(wait->iStatus, lockType, lockChange);
 RDEBUG("WaitForRequestL", 0);
 res = wait->WaitForRequestL();
-RDEBUG("WaitForRequestL", 1);
+RDEBUG("WaitForRequestL res", res);
 delete wait;
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::AskSecCodeInAutoLockL() KES: SetLockSetting RESULT:%d"), res);
-#endif
 }
 RDEBUG("res", res);
 switch (res)
 {
 case KErrAccessDenied:
 {
 RDEBUG("KErrAccessDenied", KErrAccessDenied);
 return AskSecCodeInAutoLockL();
 }
+case KErrInUse:
+{
+		RDEBUG("KErrInUse", KErrInUse);
+		return EFalse;
+}
+case KErrDied :
+{
+		RDEBUG("KErrDied ", KErrDied );
+		return EFalse;
+}
+case KErrServerTerminated :
+{
+		RDEBUG("KErrServerTerminated ", KErrServerTerminated );
+		return EFalse;
+}
+case KErrServerBusy :
+{
+		RDEBUG("KErrServerBusy ", KErrServerBusy );
+		return EFalse;
+}
 case KErrAbort:
+{
+		RDEBUG("KErrAbort", KErrAbort);
+		return EFalse;
+}
 case KErrCancel:
+{
+		RDEBUG("KErrCancel", KErrCancel);
 // user pressed "cancel"
 return EFalse;
+}
 default:
 {
 RDEBUG("default", res);
 return AskSecCodeInAutoLockL();
 }
 err = RProperty::Get(KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus,
 autolockState);
 RDEBUG("StartUp", StartUp);
 RDEBUG("err", err);
 if (!StartUp)
+		{
+		RDebug::Printf( "%s %s (%u) might leave if StartUp=0 and err=%x", __FILE__, __PRETTY_FUNCTION__, __LINE__, err );
 User::LeaveIfError(err);
+	}
 TBool isConditionSatisfied = EFalse;
 TInt tarmFlag = 0;
 if (FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw ))
 {
 TInt tRet = RProperty::Get(KSCPSIDAutolock, SCP_TARM_ADMIN_FLAG_UID,
 tarmFlag);
 if (tRet != KErrNone)
 {
-#if defined(_DEBUG)
+RDEBUG("Warning: failed to get TARM Admin Flag state", tRet);
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL():\
-Warning: failed to get TARM Admin Flag state"));
-#endif
 }
 else
 {
-#if defined(_DEBUG)
+RDEBUG("TARM flag", tarmFlag);
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL(): TARM flag: %d"), tarmFlag );
-#endif
 }
 if ((StartUp) || (tarmFlag & KSCPFlagResyncQuery))
 isConditionSatisfied = ETrue;
 }
 else
 {
 if (StartUp)
 isConditionSatisfied = ETrue;
 }
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL() Dialog 1"));
-#endif
 // Security code at bootup: No "cancel" softkey; Emergency calls enabled.
-RMobilePhone::TMobilePhoneSecurityCode secCodeTypeToAsk =
+RMobilePhone::TMobilePhoneSecurityCode secCodeTypeToAsk = RMobilePhone::ESecurityCodePhonePassword;
-RMobilePhone::ESecurityCodePhonePassword; // for starters
 RDEBUG("isConditionSatisfied", isConditionSatisfied);
 if (isConditionSatisfied)
 {
 // starter or special TARM. NoCancel+Emergency
 lCancelSupported = ESecUiCancelNotSupported;
 lEmergencySupported = ESecUiEmergencyNotSupported;
 }
 CSecQueryUi *iSecQueryUi;
 iSecQueryUi = CSecQueryUi::NewL();
+		iQueryCanceled = EFalse;
 TInt lType = ESecUiSecretSupported | ESecUiAlphaSupported
 | lCancelSupported | lEmergencySupported | secCodeTypeToAsk;
 RDEBUG("lType", lType);
-iSecUi_password.Copy(_L("12345"));
 queryAccepted = iSecQueryUi->SecQueryDialog(_L("PassPhraseRequiredL"),
 iSecUi_password, SEC_C_SECURITY_CODE_MIN_LENGTH,
 SEC_C_SECURITY_CODE_MAX_LENGTH, lType);
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
 RDEBUG("queryAccepted", queryAccepted);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 TBool wasCancelledOrEmergency = EFalse;
 RDEBUG("KFeatureIdSapDeviceLockEnhancements",
 KFeatureIdSapDeviceLockEnhancements);
 == KErrCancel))
 wasCancelledOrEmergency = ETrue;
 RDEBUG("wasCancelledOrEmergency", wasCancelledOrEmergency);
 if (wasCancelledOrEmergency)
 {
-#if defined(_DEBUG)
+				RDEBUG("StartUp", StartUp);
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL() DIALOG ERROR"));
-#endif
 if (!StartUp)
 {
 RDEBUG("AbortSecurityCode", 0);
 iPhone.AbortSecurityCode(RMobilePhone::ESecurityCodePhonePassword);
 RDEBUG("AbortSecurityCode", 1);
 RMobilePhone::TMobilePhoneSecurityCode secCodeType =
 RMobilePhone::ESecurityCodePhonePassword;
 CWait* wait = NULL;
 TInt status = KErrNone;
-;
 wait = CWait::NewL();
 RDEBUG("VerifySecurityCode", 0);
 iPhone.VerifySecurityCode(wait->iStatus, secCodeType, iSecUi_password,
 required_fourth);
 RDEBUG("WaitForRequestL", 0);
 #endif
 TInt returnValue = status;
 RDEBUG("tarmFlag", tarmFlag);
 RDEBUG("StartUp", StartUp);
+RDEBUG("status", status);
 switch (status)
 {
 case KErrNone:
-#if defined(_DEBUG)
+// code approved
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL() KErrNone"));
+RDEBUG( "KErrNone", KErrNone );
-#endif
-// code approved
 CSecuritySettings::ShowResultNoteL(R_CONFIRMATION_NOTE,
 CAknNoteDialog::EConfirmationTone);
 RDEBUG("R_CONFIRMATION_NOTE", R_CONFIRMATION_NOTE);
 if (FeatureManager::FeatureSupported(KFeatureIdSapTerminalControlFw))
 {
 SCP_TARM_ADMIN_FLAG_UID, tarmFlag);
 }
 if (tRet != KErrNone)
 {
-#if defined(_DEBUG)
+RDEBUG( "FAILED to unset TARM Admin Flag tRet=", tRet );
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL():\
-FAILED to unset TARM Admin Flag"));
-#endif
 }
 }
 if (!FeatureManager::FeatureSupported(
 KFeatureIdSapDeviceLockEnhancements))
 {
 RDEBUG("KFeatureIdSapDeviceLockEnhancements",
 KFeatureIdSapDeviceLockEnhancements);
 RSCPClient scpClient;
 RDEBUG("scpClient.Connect", 0);
-User::LeaveIfError(scpClient.Connect());
+TInt tRet = scpClient.Connect();
+RDEBUG("tRet", tRet);
+User::LeaveIfError(tRet);
 RDEBUG("scpClient.Connect", 1);
 CleanupClosePushL(scpClient);
 TSCPSecCode newCode;
 newCode.Copy(iSecUi_password);
 scpClient.StoreCode(newCode);
 }
 RDEBUG("StartUp", StartUp);
 if (StartUp)
 {
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL()KErrNone: Startup; get autolock period."));
-#endif
 // get autolock period from Central Repository.
 CRepository* repository = CRepository::NewL(
 KCRUidSecuritySettings);
 TInt period = 0;
 TInt res = repository->Get(KSettingsAutoLockTime, period);
 delete repository;
+RDEBUG("res", res);
+RDEBUG("period", period);
 _LIT_SECURITY_POLICY_PASS( KReadPolicy);
 _LIT_SECURITY_POLICY_C1(KWritePolicy,
 ECapabilityWriteDeviceData);
 RProperty::Define(KPSUidCoreApplicationUIs,
 KCoreAppUIsAutolockStatus, RProperty::EInt,
 KReadPolicy, KWritePolicy);
 RProperty::Set(KPSUidCoreApplicationUIs,
 KCoreAppUIsAutolockStatus, EAutolockOff);
-#if defined(_DEBUG)
+RDEBUG("KCoreAppUIsAutolockStatus", KCoreAppUIsAutolockStatus);
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL() EAutolockOff"));
-#endif
 if (res == KErrNone)
 {
 // disable autolock in Domestic OS side too if autolock period is 0.
 if (period == 0)
 {
-#ifdef RD_REMOTELOCK
+// Don't disable the domestic OS device lock
-// If remote lock is enabled, don't disable the domestic OS device lock
 // since that would render the RemoteLock useless.
 TBool remoteLockStatus( EFalse );
 CRemoteLockSettings* remoteLockSettings = CRemoteLockSettings::NewL();
 if ( remoteLockSettings->GetEnabled( remoteLockStatus ) )
 {
 if ( !remoteLockStatus )
 {
 // Remote lock is disabled
-#ifdef _DEBUG
+RDEBUG("Autolock and RemoteLock are disabled -> disable DOS device lock", 0);
-RDebug::Print( _L( "(SecUi)CSecurityHandler::PassPhraseRequiredL() - Autolock and RemoteLock are disabled -> disable DOS device lock" ) );
-#endif // _DEBUG
 // Disable DOS device lock setting
 RDEBUG( "iCustomPhone.DisablePhoneLock", 0 );
 wait = CWait::NewL();
 iCustomPhone.DisablePhoneLock(wait->iStatus,iSecUi_password);
-wait->WaitForRequestL();
+RDEBUG( "WaitForRequestL", 0 );
-RDEBUG( "iCustomPhone.DisablePhoneLock", 1 );
+status = wait->WaitForRequestL();
+RDEBUG( "WaitForRequestL", status );
 delete wait;
 }
 }
 else
 {
 // Failed to get remote lock status
-#ifdef _DEBUG
+RDEBUG( "Autolock is disabled, but failed to get RemoteLock status, so do nothing", 0 );
-RDebug::Print( _L( "(SecUi)CSecurityHandler::PassPhraseRequiredL() - Autolock is disabled, but failed to get RemoteLock status, so do nothing." ) );
-#endif // _DEBUG
 }
 delete remoteLockSettings;
 remoteLockSettings = NULL;
-#else // not defined RD_REMOTELOCK
-RDEBUG("iCustomPhone.DisablePhoneLock", 0);
-wait = CWait::NewL();
-iCustomPhone.DisablePhoneLock(wait->iStatus,
-iSecUi_password);
-wait->WaitForRequestL();
-RDEBUG("iCustomPhone.DisablePhoneLock", 1);
-delete wait;
-#endif // RD_REMOTELOCK
 }
 }
 else // error getting repository
 {
 RDEBUG("error getting repository", 0);
-#ifdef RD_REMOTELOCK
+// Don't disable the domestic OS device lock
-// If remote lock is enabled, don't disable the domestic OS device lock
 // since that would render the RemoteLock useless.
 TBool remoteLockStatus( EFalse );
 CRemoteLockSettings* remoteLockSettings = CRemoteLockSettings::NewL();
 {
 // Remote lock is disabled
 RDEBUG( "iCustomPhone.DisablePhoneLock", 0 );
 wait = CWait::NewL();
 iCustomPhone.DisablePhoneLock(wait->iStatus,iSecUi_password);
-wait->WaitForRequestL();
+		                        RDEBUG( "WaitForRequestL", 0 );
-RDEBUG( "iCustomPhone.DisablePhoneLock", 1 );
+		                        status = wait->WaitForRequestL();
+		                        RDEBUG( "WaitForRequestL status", status );
 delete wait;
 }
 }
 else
 {
 // Failed to get remote lock status
-#ifdef _DEBUG
+RDEBUG( "Failed to get Autolock period and RemoteLock status, so do nothing", 0 );
-RDebug::Print( _L( "(SecUi)CSecurityHandler::PassPhraseRequiredL() - Failed to get Autolock period and RemoteLock status, so do nothing." ) );
-#endif // _DEBUG
 }
 delete remoteLockSettings;
 remoteLockSettings = NULL;
-#else // not defined RD_REMOTELOCK
-// could not get the current autolock time... disable autolock in Domestic OS side.
-RDEBUG("iCustomPhone.DisablePhoneLock", 0);
-wait = CWait::NewL();
-iCustomPhone.DisablePhoneLock(wait->iStatus,
-iSecUi_password);
-wait->WaitForRequestL();
-RDEBUG("iCustomPhone.DisablePhoneLock", 1);
-delete wait;
-#endif // RD_REMOTELOCK
 }
 } // no Startup
 break;
 case KErrGsmSSPasswordAttemptsViolation:
 case KErrLocked:
 // security code blocked!
-#if defined(_DEBUG)
+						RDEBUG("KErrLocked", KErrLocked);
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL() ErrGsmSSPasswordAttemptsViolation"));
-#endif
 CSecuritySettings::ShowResultNoteL(R_SEC_BLOCKED,
 CAknNoteDialog::EErrorTone);
 break;
 case KErrGsm0707IncorrectPassword:
 case KErrAccessDenied:
 RDEBUG("KErrAccessDenied", KErrAccessDenied);
-// TODO should this try again? It seems that it's not asked again.
+// The Settings caller might retry
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::PassPhraseRequiredL() KErrGsm0707IncorrectPassword"));
-#endif
 CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
 CAknNoteDialog::EErrorTone);
 break;
 default:
 RDEBUG("default", status);
 CSecuritySettings::ShowErrorNoteL(status);
-// TODO should this try again? It seems that it's not asked again.
+// The Settings caller might retry
 break;
 }
 RDEBUG("returnValue", returnValue);
 return returnValue;
 }
 if (!StartUp)
 {
 // read a flag to see whether the query is SecUi originated. For example, from CSecuritySettings::ChangePinRequestParamsL
 err = RProperty::Get(KPSUidSecurityUIs,
 KSecurityUIsSecUIOriginatedQuery, secUiOriginatedQuery);
 if (err != KErrNone)
 {
-#if defined(_DEBUG)
+						RDEBUG("FAILED to get the SECUI query Flag err", err);
-RDebug::Print(_L("(SECUI)CSecurityHandler::Pin1RequiredL():\
+}
-FAILED to get the SECUI query Flag: %d"), err);
+}
-#endif
+RDEBUG("err", err);
-}
-else
-{
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::Pin1RequiredL():\
-SECUI query Flag: %d"), secUiOriginatedQuery);
-#endif
-}
-}
-#if defined(_DEBUG)
-RDebug::Print(_L("CSecurityHandler::Pin1RequiredL() Execute dlg"));
-#endif
-RDEBUG("StartUp", StartUp);
 RDEBUG("secUiOriginatedQuery", secUiOriginatedQuery);
 RDEBUG("ESecurityUIsSecUIOriginated", ESecurityUIsSecUIOriginated);
-RDEBUG("err", err);
 if (StartUp || (secUiOriginatedQuery != ESecurityUIsSecUIOriginated)
 || (err != KErrNone))
 {
 RDEBUG("0", 0);
 lCancelSupported = ESecUiCancelNotSupported;
 #ifdef __WINS__
 RDEBUG( "emulator can't read PIN attempts", res );
 res=KErrNone;
 codeInfo.iRemainingEntryAttempts=3;
 #endif
 User::LeaveIfError(res);
 RDEBUG("codeInfo.iRemainingEntryAttempts",
 codeInfo.iRemainingEntryAttempts);
 if (codeInfo.iRemainingEntryAttempts == KMaxNumberOfPINAttempts)
 /* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+		iQueryCanceled = EFalse;
 RDEBUG("SecQueryDialog", 1);
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
+// ESecUiCodeEtelReqest/ESecUiNone might be useful
-// TODO also support Emergency
 lAlphaSupported = ESecUiAlphaNotSupported;
 TBuf<0x100> title;
 title.Zero();
 title.Append(_L("Pin1RequiredL"));
 title.Append(_L("#"));
 RDEBUG("amode", amode);
 queryAccepted = iSecQueryUi->SecQueryDialog(title, iSecUi_password,
 SEC_C_PIN_CODE_MIN_LENGTH, SEC_C_PIN_CODE_MAX_LENGTH, amode);
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
-// TODO handle emergency
 /* end request PIN using QT */
 if (queryAccepted == KErrAbort) // emergency call
 {
-#if defined(_DEBUG)
+				RDEBUG("queryAccepted", queryAccepted);
-RDebug::Print(_L("CSecurityHandler::Pin1RequiredL() R_PIN_REQUEST_QUERY CANCEL!"));
-#endif
 CleanupStack::PopAndDestroy(wait); // this is needed
 return KErrCancel;
 }
 if (lCancelSupported && (queryAccepted == KErrCancel))
 {
 TInt returnValue = res;
 switch (res)
 {
 case KErrNone:
 // code approved
-#if defined(_DEBUG)
+RDEBUG("code approved", res);
-RDebug::Print(_L("CSecurityHandler::Pin1RequiredL()code approved "));
+if(lCancelSupported == ESecUiCancelNotSupported)
-#endif
+	{	// OK note is not displayed in boot-up, to make things faster
-CSecuritySettings::ShowResultNoteL(R_CONFIRMATION_NOTE,
+	            CSecuritySettings::ShowResultNoteL(R_CONFIRMATION_NOTE,
 CAknNoteDialog::EConfirmationTone);
+}
 break;
 case KErrGsm0707IncorrectPassword:
 case KErrAccessDenied:
 // code was entered erroneously
 CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
 }
 break;
 case KErrGsmSSPasswordAttemptsViolation:
 case KErrLocked:
 // code blocked; show error note and terminate.
-// TODO what if not during Startup? Probably it's Ok since the SIM would had also failed at StartUp
+// what if not during Startup? Probably it's Ok since the SIM would had also failed at StartUp
 if (StartUp)
 CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
 CAknNoteDialog::EErrorTone);
 break;
 case KErrGsm0707SimWrong:
 // sim lock active
-// TODO no error? This is strange
+// no error? This is strange
 break;
 default:
 CSecuritySettings::ShowErrorNoteL(res);
 if (StartUp)
 {
 }
 //
 // ----------------------------------------------------------
 // CSecurityHandler::Puk1Required()
 // Handles Puk1Required event
+// First asks the PUK1, then verifies, then the newPIN + re-type , and then writes . This is odd, but the API needs the PUK and newPIN in same step.
+// Afterwards, the PIN1 might be asked (because the initial program still needs it)
 // ----------------------------------------------------------
 // qtdone
 TInt CSecurityHandler::Puk1RequiredL()
 {
 /*****************************************************
 *    Series 60 Customer / ETel
 *    Series 60  ETel API
 *****************************************************/
-#if defined(_DEBUG)
+		RDEBUG("0", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::Puk1RequiredL()"));
-#endif
 TInt queryAccepted = KErrCancel;
-RMobilePhone::TMobilePassword iSecUi_password;
+RMobilePhone::TMobilePassword puk1_password;
-RMobilePhone::TMobilePassword aNewPassword;
+RMobilePhone::TMobilePassword aNewPinPassword;
 RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfo;
 RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg codeInfoPkg(codeInfo);
 RMobilePhone::TMobilePhoneSecurityCode blockCodeType;
 blockCodeType = RMobilePhone::ESecurityCodePuk1;
 CWait* wait = CWait::NewL();
 CleanupStack::PushL(wait);
 TBool StartUp(ETrue);
 StartUp = iStartup;
-TInt res(KErrNone);
+TInt res(KErrCancel);	// for the first try
 wait->SetRequestType(EMobilePhoneGetSecurityCodeInfo);
 TInt thisTry = 0;
 // If there was a problem (as there might be in case we're dropping off SIM Access Profile); try again a couple of times.
 iPhone.GetSecurityCodeInfo(wait->iStatus, blockCodeType, codeInfoPkg);
 RDEBUG("WaitForRequestL", 0);
 res = wait->WaitForRequestL();
 RDEBUG("WaitForRequestL res", res);
 }
-#if defined(_DEBUG)
+		RDEBUG("res", res);
-RDebug::Print(_L("(SECUI)CSecurityHandler::Puk1RequiredL(): Get Code info result: %d"), res);
+// If there's still an error we're doomed. Bail out.
-#endif
-//If there's still an error we're doomed. Bail out.
 User::LeaveIfError(res);
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::Puk1RequiredL(): Show last note"));
-#endif
 RDEBUG("StartUp", StartUp);
 RDEBUG("codeInfo.iRemainingEntryAttempts",
 codeInfo.iRemainingEntryAttempts);
-//show the last "Code Error" note of PIN verify result here so it won't be left under the PUK1 dialog
+	TInt attempts(codeInfo.iRemainingEntryAttempts);
-if (!StartUp && (codeInfo.iRemainingEntryAttempts
+	RDEBUG( "attempts", attempts );
+// show the last "Code Error" note of PIN verify result here so it won't be left under the PUK1 dialog
+if (!StartUp && (attempts
 == KMaxNumberOfPUKAttempts))
 CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
 CAknNoteDialog::EErrorTone);
-RDEBUG("codeInfo.iRemainingEntryAttempts",
+if (attempts == KMaxNumberOfPINAttempts)
-codeInfo.iRemainingEntryAttempts);
+attempts = -1;
-if (codeInfo.iRemainingEntryAttempts == KMaxNumberOfPINAttempts)
-codeInfo.iRemainingEntryAttempts = -1;
-// ask PUK code
-/* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+		iQueryCanceled = EFalse;
 RDEBUG("SecQueryDialog", 1);
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
+// ESecUiCodeEtelReqest/ESecUiNone might be useful
-// TODO also support Emergency
 TBuf<0x100> title;
 title.Zero();
 title.Append(_L("Puk1RequiredL"));
 title.Append(_L("#"));
-title.AppendNum(codeInfo.iRemainingEntryAttempts);
+title.AppendNum(attempts);
-queryAccepted = iSecQueryUi->SecQueryDialog(title, iSecUi_password,
+TInt lSecUiCancelSupported = ESecUiCancelSupported | ESecUiEmergencyNotSupported;
+if(StartUp)		// how to know whether PUK comes from failing at Starter, or failing at any other PIN (i.e. changing PIN, or changing PIN-request) ???
+	lSecUiCancelSupported = ESecUiCancelNotSupported | ESecUiEmergencySupported;
+queryAccepted = iSecQueryUi->SecQueryDialog(title, puk1_password,
 SEC_C_PUK_CODE_MIN_LENGTH, SEC_C_PUK_CODE_MAX_LENGTH,
 ESecUiSecretNotSupported | ESecUiAlphaNotSupported
-| ESecUiCancelSupported | ESecUiPukRequired);
+| lSecUiCancelSupported | ESecUiPukRequired);
-RDEBUG("iSecUi_password", 0);
+RDEBUG("puk1_password", 0);
-RDebug::Print(iSecUi_password);
+RDebug::Print(puk1_password);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 if ((queryAccepted == KErrAbort) || (queryAccepted == KErrCancel))
 {
-CleanupStack::PopAndDestroy(wait); // TODO this is needed ???
+CleanupStack::PopAndDestroy(wait); // this is needed
 return KErrCancel;
 }
-{
-// new pin code query
-CSecQueryUi * iSecQueryUi;
-RDEBUG("CSecQueryUi", 0);
-iSecQueryUi = CSecQueryUi::NewL();
-RDEBUG("SecQueryDialog", 1);
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
-// TODO also support Emergency
-queryAccepted = iSecQueryUi->SecQueryDialog(
-_L("Puk1-New|Puk1-Verif"), aNewPassword,
-SEC_C_PUK_CODE_MIN_LENGTH, SEC_C_PUK_CODE_MAX_LENGTH,
-ESecUiAlphaNotSupported | ESecUiCancelSupported
-| ESecUiPukRequired);
-RDEBUG("aNewPassword", 0);
-RDebug::Print(aNewPassword);
-delete iSecQueryUi;
-RDEBUG("queryAccepted", queryAccepted);
-}
-if ((queryAccepted == KErrAbort) || (queryAccepted == KErrCancel))
-{
-CleanupStack::PopAndDestroy(wait);
-return KErrCancel;
-}
 // send code
+// first we verify the puk. For this, we reset the PIN to the same as the PUK
+// Hopefully this will never fail in the case "new PIN too long"
 RDEBUG("VerifySecurityCode", 0);
-iPhone.VerifySecurityCode(wait->iStatus, blockCodeType, aNewPassword,
+iPhone.VerifySecurityCode(wait->iStatus, blockCodeType, puk1_password, puk1_password);
-iSecUi_password);
 RDEBUG("WaitForRequestL", 0);
 res = wait->WaitForRequestL();
 RDEBUG("WaitForRequestL res", res);
-CleanupStack::PopAndDestroy(wait);
+		CleanupStack::PopAndDestroy(wait);
 TInt returnValue = res;
 switch (res)
 {
 case KErrNone:
-// code approved -> note
+// code approved -> note . The process continue and new-pin is requested
-CSecuritySettings::ShowResultNoteL(R_PIN_CODE_CHANGED_NOTE,
+CSecuritySettings::ShowResultNoteL(res,
 CAknNoteDialog::EConfirmationTone);
 break;
 case KErrGsm0707IncorrectPassword:
 case KErrAccessDenied:
 // wrong PUK code -> note -> ask PUK code again
 CAknNoteDialog::EErrorTone);
 returnValue = Puk1RequiredL();
 break;
 case KErrGsm0707SimWrong:
 // sim lock active
-// TODO no message ?
+// no message ?
 break;
 case KErrGsmSSPasswordAttemptsViolation:
 case KErrLocked:
 // sim card rejected.
 break;
 CSecuritySettings::ShowErrorNoteL(res);
 returnValue = Puk1RequiredL();
 break;
 }
+		// Now the PUK1 is validated. It's time for asking the new PIN1
+		RDEBUG("new wait", 0);
+		wait = CWait::NewL();
+		CleanupStack::PushL(wait);
+{
+// new-pin query
+CSecQueryUi * iSecQueryUi;
+RDEBUG("CSecQueryUi", 0);
+iSecQueryUi = CSecQueryUi::NewL();
+				iQueryCanceled = EFalse;
+RDEBUG("SecQueryDialog", 1);
+queryAccepted = iSecQueryUi->SecQueryDialog(
+_L("PIN1-New|PIN1-Verif"), aNewPinPassword,
+SEC_C_PIN_CODE_MIN_LENGTH, SEC_C_PIN_CODE_MAX_LENGTH,
+ESecUiAlphaNotSupported | ESecUiCancelSupported
+| ESecUiPukRequired);
+RDEBUG("aNewPinPassword", 0);
+RDebug::Print(aNewPinPassword);
+iQueryCanceled = ETrue;
+delete iSecQueryUi;
+RDEBUG("queryAccepted", queryAccepted);
+}
+if ((queryAccepted == KErrAbort) || (queryAccepted == KErrCancel))
+{
+CleanupStack::PopAndDestroy(wait);
+return KErrCancel;
+}
+// send code again, now with the user pin
+RDEBUG("VerifySecurityCode", 0);
+iPhone.VerifySecurityCode(wait->iStatus, blockCodeType, aNewPinPassword,
+puk1_password);
+RDEBUG("WaitForRequestL", 0);
+res = wait->WaitForRequestL();
+RDEBUG("WaitForRequestL res", res);
+CleanupStack::PopAndDestroy(wait);
+returnValue = res;
+switch (res)
+{
+case KErrNone:
+// code approved -> note
+CSecuritySettings::ShowResultNoteL(R_PIN_CODE_CHANGED_NOTE,
+CAknNoteDialog::EConfirmationTone);
+break;
+case KErrGsm0707IncorrectPassword:
+case KErrAccessDenied:
+// wrong PUK code -> note -> ask PUK code again
+CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
+CAknNoteDialog::EErrorTone);
+returnValue = Puk1RequiredL();
+break;
+case KErrGsm0707SimWrong:
+// sim lock active
+// no message ?
+break;
+case KErrGsmSSPasswordAttemptsViolation:
+case KErrLocked:
+// sim card rejected.
+break;
+default:
+CSecuritySettings::ShowErrorNoteL(res);
+returnValue = Puk1RequiredL();
+break;
+}
+		RDEBUG("returnValue", returnValue);
 return returnValue;
 }
 //
 // ----------------------------------------------------------
 // CSecurityHandler::Pin2Required()
 /*****************************************************
 *    Series 60 Customer / ETel
 *    Series 60  ETel API
 *****************************************************/
-#if defined(_DEBUG)
+		RDEBUG("0", 0);
-RDebug::Print(_L("(SECUI)CSecurityHandler::Pin2RequiredL() BEGIN"));
-#endif
 TInt queryAccepted = KErrCancel;
 RMobilePhone::TMobilePassword iSecUi_password;
 RMobilePhone::TMobilePassword required_fourth;
 RMobilePhone::TMobilePhoneSecurityCode secCodeType(
 RMobilePhone::ESecurityCodePin2);
 RDEBUG("GetSecurityCodeInfo", 0);
 iPhone.GetSecurityCodeInfo(wait->iStatus, secCodeType, codeInfoPkg);
 RDEBUG("WaitForRequestL", 0);
 TInt ret = wait->WaitForRequestL();
 RDEBUG("WaitForRequestL ret", ret);
 User::LeaveIfError(ret);
 RDEBUG("codeInfo.iRemainingEntryAttempts",
 codeInfo.iRemainingEntryAttempts);
-if (codeInfo.iRemainingEntryAttempts == KMaxNumberOfPINAttempts) // TODO this might be 10 ?
+if (codeInfo.iRemainingEntryAttempts == KMaxNumberOfPINAttempts)
 codeInfo.iRemainingEntryAttempts = -1;
 /* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+		iQueryCanceled = EFalse;
 RDEBUG("SecQueryDialog", 1);
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful against KLastRemainingInputAttempt
+// ESecUiCodeEtelReqest/ESecUiNone might be useful against KLastRemainingInputAttempt
-// TODO also support Emergency
 TBuf<0x100> title;
 title.Zero();
 title.Append(_L("Pin2RequiredL"));
 title.Append(_L("#"));
 ESecUiSecretNotSupported | ESecUiAlphaNotSupported
 | ESecUiCancelSupported | secCodeType);
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
 RDEBUG("queryAccepted", queryAccepted);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 // If failed or device became locked, any pending request should be cancelled.
 if (queryAccepted != KErrNone)
 {
 break;
 default:
 CSecuritySettings::ShowErrorNoteL(status);
 break;
 }
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::Pin2RequiredL(): END"));
-#endif
 }
 //
 // ----------------------------------------------------------
 // CSecurityHandler::Puk2Required()
 // Handles Puk2Required event
 {
 /*****************************************************
 *    Series 60 Customer / ETel
 *    Series 60  ETel API
 *****************************************************/
+		RDEBUG("0", 0);
 TInt queryAccepted = KErrCancel;
 RMobilePhone::TMobilePassword iSecUi_password;
 RMobilePhone::TMobilePassword aNewPassword;
 RMobilePhone::TMobilePassword verifcationPassword;
 RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfo;
 RMobilePhone::TMobilePhoneSecurityCode secCodeType =
 RMobilePhone::ESecurityCodePuk2;
 CWait* wait = CWait::NewL();
 CleanupStack::PushL(wait);
-#if defined(_DEBUG)
-RDebug::Print(_L("(SECUI)CSecurityHandler::Puk2RequiredL()"));
-#endif
 // ask PUK2
 TInt ret(KErrNone);
 wait->SetRequestType(EMobilePhoneGetSecurityCodeInfo);
 RDEBUG("GetSecurityCodeInfo", 0);
 /* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+		iQueryCanceled = EFalse;
 RDEBUG("SecQueryDialog", 1);
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
+// ESecUiCodeEtelReqest/ESecUiNone might be useful
-// TODO also support Emergency
 RDEBUG("codeInfo.iRemainingEntryAttempts",
 codeInfo.iRemainingEntryAttempts);
 if (codeInfo.iRemainingEntryAttempts == KMaxNumberOfPINAttempts) // TODO this might be 10 ?
 codeInfo.iRemainingEntryAttempts = -1;
 title.Append(_L("#"));
 title.AppendNum(codeInfo.iRemainingEntryAttempts);
 queryAccepted = iSecQueryUi->SecQueryDialog(title, iSecUi_password,
 SEC_C_PUK2_CODE_MIN_LENGTH, SEC_C_PUK2_CODE_MAX_LENGTH,
 ESecUiSecretNotSupported | ESecUiAlphaNotSupported
-| ESecUiCancelSupported | secCodeType /*aMode*/);
+| ESecUiCancelSupported | secCodeType );
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 if (queryAccepted != KErrNone)
 {
 RDEBUG("AbortSecurityCode", 1);
 CleanupStack::PopAndDestroy(1); //wait
 return;
 }
-{
+RDEBUG("VerifySecurityCode", 0);
-// new pin code query
+iPhone.VerifySecurityCode(wait->iStatus, secCodeType, iSecUi_password, iSecUi_password);
+// this writes the newPIN2 with the value of PUK2. It's ok, since the user forgot it
+RDEBUG("WaitForRequestL", 0);
+TInt res = wait->WaitForRequestL();
+RDEBUG("WaitForRequestL res", res);
+CleanupStack::PopAndDestroy(wait);
+switch (res)
+{
+case KErrNone:
+// code approved -> note
+CSecuritySettings::ShowResultNoteL(res,
+CAknNoteDialog::EConfirmationTone);
+break;
+case KErrGsm0707IncorrectPassword:
+case KErrAccessDenied:
+// wrong PUK2 code -> note -> ask PUK2 code again
+CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
+CAknNoteDialog::EErrorTone);
+Puk2RequiredL();
+break;
+case KErrGsmSSPasswordAttemptsViolation:
+case KErrLocked:
+// Pin2 features blocked permanently!
+CSecuritySettings::ShowResultNoteL(R_PIN2_REJECTED,
+CAknNoteDialog::EConfirmationTone);
+break;
+default:
+CSecuritySettings::ShowErrorNoteL(res);
+Puk2RequiredL();
+break;
+}
+		// now the PUK2 is valid. Time to get the new PIN2
+		wait = CWait::NewL();
+CleanupStack::PushL(wait);
+	  {
+// new pin2 code query
 CSecQueryUi * iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
+				iQueryCanceled = EFalse;
-// TODO also support Emergency
+// ESecUiCodeEtelReqest/ESecUiNone might be useful
 queryAccepted
-= iSecQueryUi->SecQueryDialog(_L("Puk2-New|Puk2-Verif"),
+= iSecQueryUi->SecQueryDialog(_L("PIN2-New|PIN2-Verif"),
-aNewPassword, SEC_C_PUK2_CODE_MIN_LENGTH,
+aNewPassword, SEC_C_PIN2_CODE_MIN_LENGTH,
-SEC_C_PUK2_CODE_MAX_LENGTH, ESecUiAlphaNotSupported
+SEC_C_PIN2_CODE_MAX_LENGTH, ESecUiAlphaNotSupported
 | ESecUiCancelSupported | secCodeType);
 RDEBUG("aNewPassword", 0);
 RDebug::Print(aNewPassword);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 if (queryAccepted != KErrNone)
 {
 // cancel "get security unblock code" request
 RDEBUG("AbortSecurityCode", 1);
 CleanupStack::PopAndDestroy(1); //wait
 return;
 }
 }
-// send code
+// send code. The code was temporarilly changed before. Thus, this really done to set the new-new one
-// TODO the current code should be verified before
 RDEBUG("VerifySecurityCode", 0);
 iPhone.VerifySecurityCode(wait->iStatus, secCodeType, aNewPassword,
 iSecUi_password);
 RDEBUG("WaitForRequestL", 0);
-TInt res = wait->WaitForRequestL();
+res = wait->WaitForRequestL();
 RDEBUG("WaitForRequestL res", res);
 CleanupStack::PopAndDestroy(wait);
 switch (res)
 {
 *    Series 60  ETel API
 *****************************************************/
 TBool wcdmaSupported(
 FeatureManager::FeatureSupported( KFeatureIdProtocolWcdma));
 TBool upinSupported(FeatureManager::FeatureSupported( KFeatureIdUpin));
+	RDEBUG("wcdmaSupported", wcdmaSupported);
+	RDEBUG("upinSupported", upinSupported);
 if (wcdmaSupported || upinSupported)
 {
 TInt queryAccepted = KErrCancel;
 TInt lCancelSupported = ESecUiCancelNotSupported;
 RMobilePhone::TMobilePassword iSecUi_password;
 /* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
-// TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
+				iQueryCanceled = EFalse;
+// ESecUiCodeEtelReqest/ESecUiNone might be useful
 // TODO also support Emergency
 if (StartUp || (secUiOriginatedQuery != ESecurityUIsSecUIOriginated)
 || (err != KErrNone))
 lCancelSupported = ESecUiCancelNotSupported;
 else
 SEC_C_PIN_CODE_MIN_LENGTH, SEC_C_PIN_CODE_MAX_LENGTH,
 ESecUiSecretSupported | ESecUiAlphaNotSupported
 | lCancelSupported | ESecUiCodeEtelReqest);
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 if (queryAccepted != KErrNone)
 {
 CleanupStack::PopAndDestroy(wait);
 TInt returnValue = res;
 switch (res)
 {
 case KErrNone:
 // code approved
-#if defined(_DEBUG)
+RDEBUG("code approved ", 0);
-RDebug::Print(_L("CSecurityHandler::UPinRequiredL()code approved "));
-#endif
 CSecuritySettings::ShowResultNoteL(R_CONFIRMATION_NOTE,
 CAknNoteDialog::EConfirmationTone);
 break;
 case KErrGsm0707IncorrectPassword:
 case KErrAccessDenied:
 break;
 case KErrGsmSSPasswordAttemptsViolation:
 case KErrLocked:
 // code blocked; show error note and terminate.
 if (StartUp)
-CSecuritySettings::ShowResultNoteL(R_CODE_ERROR,
+CSecuritySettings::ShowResultNoteL(res,
 CAknNoteDialog::EErrorTone);
 break;
 case KErrGsm0707SimWrong:
 // sim lock active
 break;
-default:
+default:	// for example, KErrArgument
 CSecuritySettings::ShowErrorNoteL(res);
 if (StartUp)
 {
 returnValue = UPinRequiredL();
 }
 /* request PIN using QT */
 {
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+						iQueryCanceled = EFalse;
 // TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
 // TODO also support Emergency
 TBuf<0x100> title;
 title.Zero();
 iSecUi_password, SEC_C_PUK_CODE_MIN_LENGTH,
 SEC_C_PUK_CODE_MAX_LENGTH, ESecUiAlphaNotSupported
 | ESecUiCancelSupported | ESecUiPukRequired);
 RDEBUG("iSecUi_password", 0);
 RDebug::Print(iSecUi_password);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 if (queryAccepted != KErrNone)
 {
 {
 /* request PIN using QT */
 CSecQueryUi *iSecQueryUi;
 RDEBUG("CSecQueryUi", 0);
 iSecQueryUi = CSecQueryUi::NewL();
+						iQueryCanceled = EFalse;
 // TODO ESecUiCodeEtelReqest/ESecUiNone might be useful
 // TODO also support Emergency
 queryAccepted = iSecQueryUi->SecQueryDialog(_L(
 "UPuk-New|UPuk-Verif"), aNewPassword,
 SEC_C_PUK_CODE_MIN_LENGTH, SEC_C_PUK_CODE_MAX_LENGTH,
 ESecUiAlphaNotSupported | ESecUiCancelSupported
 | ESecUiPukRequired);
 RDEBUG("aNewPassword", 0);
 RDebug::Print(aNewPassword);
+iQueryCanceled = ETrue;
 delete iSecQueryUi;
 RDEBUG("queryAccepted", queryAccepted);
 if (queryAccepted != KErrNone)
 {
 CleanupStack::PopAndDestroy(wait);
 {
 // Let's create TextResolver instance for error resolving...
 RDEBUG("aStatus", aStatus);
 RDEBUG("!!!!! this should never be called !!!!", 0);
-CTextResolver* textresolver = CTextResolver::NewLC();
+CSecuritySettings::ShowResultNoteL(aStatus, CAknNoteDialog::EErrorTone);
-// Resolve the error
-TPtrC errorstring;
-errorstring.Set(textresolver->ResolveErrorString(aStatus));
-iNoteDlg = new (ELeave) CAknNoteDialog(REINTERPRET_CAST(CEikDialog**,&iNoteDlg));
-iNoteDlg->PrepareLC(R_CODE_ERROR);
-iNoteDlg->SetTextL((TDesC&) errorstring);
-iNoteDlg->RunDlgLD(CAknNoteDialog::ELongTimeout,
-CAknNoteDialog::EErrorTone);
-CleanupStack::PopAndDestroy(textresolver);
 }
 // End of file

branch	GCC_SURGE
changeset 40	604cd42065d1
parent 38	e0432375ea67
child 45	5d3e34b7618a