diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstatereferenceplugins/custcmd/src/cmdsimsecuritycheck.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstatereferenceplugins/custcmd/src/cmdsimsecuritycheck.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,869 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// Name : strtsecuritychecktask.cpp +// Part of : System Startup / Starter +// Implementation of CStrtSecurityCheckTask class +// Version : %version: ou1s60rt#7.1.1 % +// This material, including documentation and any related computer +// programs, is protected by copyright controlled by Nokia. All +// rights are reserved. Copying, including reproducing, storing, +// adapting or translating, any or all of this material requires the +// prior written consent of Nokia. This material also contains +// confidential information which may not be disclosed to others +// without the prior written consent of Nokia. +// Template version: 4.1 +// Nokia Core OS * +// File renamed from strtsecuritychecktask.cpp to cmdsimsecuritycheck.cpp as part of Core OS transfer. +// + + + + +/** + @file + @internalComponent + @released +*/ + +#include "ssmsecuritychecknotifier.h" +#include "cmdsimsecuritycheck.h" +#include "ssmrefcustomcmdcommon.h" +#include "ssmdebug.h" + +#include +#include +#include +#include +#include +#include +#include + +//Ordinal postion of the security event observer NewL in the plugin dll +const TInt KSecurityEventObserverNewLOridinal = 1; + +//Utility plugin name used for starting security note event observer +_LIT(KSusUtilityPlugin, "ssmclayersup.dll"); + +/* + * Function to check whether Invalid Sim feature is enabled or not + */ +TUint32 IsSsmInvalidSimOn() + { + TUint32 retVal = 0; + +#ifdef __WINS__ + // KSsmInvalidSim is a ROM patchable constant, so need an emulator equivalent + // if WINS then read value from epoc.ini, requires licencees to set property in epoc.ini. This value is 0xFFFFFFFF if feature is enabled. + // Usage: In epoc.ini patchdata_KSsmInvalidSim 0xFFFFFFFF (Can be any non-zero value) + TUint32 readValueOfInvalidSim = 0; + if( UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty, (TAny*)"patchdata_KSsmInvalidSim", &readValueOfInvalidSim) == KErrNone ) + { + retVal = readValueOfInvalidSim; + } +#else + retVal = KSsmInvalidSim; + +#endif // __WINS__ + return retVal; + } + +CCustomCmdSimSecurityCheck* CCustomCmdSimSecurityCheck::NewL() + { + CCustomCmdSimSecurityCheck* self = new (ELeave) CCustomCmdSimSecurityCheck(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CCustomCmdSimSecurityCheck::ConstructL() + { + User::LeaveIfError(iSsmMiscAdaptation.Connect()); + User::LeaveIfError(iSsmStateManager.Connect()); + User::LeaveIfError(iSsmSusCli.Connect()); + + iStartupPSUid = CSsmUiSpecific::StartupPSUid(); + __ASSERT_ALWAYS(0 != iStartupPSUid.iUid, PanicNow(KPanicCustomCmdSimSecurityCheck, EInvalidUid)); + iSecurityStateInfoResult = new (ELeave) TPckg(iSecurityStateInfo); + iSsmUiSpecific = CSsmUiSpecific::InstanceL(); + + iSimStatusPSObserver = CSsmSimStatusPSObserver::NewL(iStartupPSUid, iSsmUiSpecific->SimStatusPropertyKey()); + //Add active object to active scheduler + CActiveScheduler::Add(this); + } + +CCustomCmdSimSecurityCheck::CCustomCmdSimSecurityCheck() + : CActive( EPriorityStandard) + { + } + +CCustomCmdSimSecurityCheck::~CCustomCmdSimSecurityCheck() + { + ExecuteCancel(); + iSsmMiscAdaptation.Close(); + iSsmStateManager.Close(); + iSsmSusCli.Close(); + + if(iSsmUiSpecific) + { + //Will be deleted after last dereference + iSsmUiSpecific->Release(); + } + + delete iSsmSecurityCheckNotifier; + delete iSecurityNoteObserver; + delete iSecurityStateInfoResult; + delete iSimStatusPSObserver; + } + +TInt CCustomCmdSimSecurityCheck::Initialize(CSsmCustomCommandEnv* /*aCmdEnv*/) + { + return KErrNone; + } + +void CCustomCmdSimSecurityCheck::Close() + { + } + +void CCustomCmdSimSecurityCheck::Release() + { + delete this; + } + +void CCustomCmdSimSecurityCheck::Execute(const TDesC8& /*aParams*/, TRequestStatus& aStatus) + { + //Load the security event observer + TSsmSupInfo observerPlugin(KSusUtilityPlugin, KSecurityEventObserverNewLOridinal); + TInt retLoadSecEventObserver = iSsmSusCli.RequestLoadSup(observerPlugin); + + if(KErrNone != retLoadSecEventObserver) + { + DEBUGPRINT2A("Load security event observer SUP failed with error code : %d", retLoadSecEventObserver); + } + + //Set the user request to pending + aStatus = KRequestPending; + iExecuteRequest = &aStatus; + + //Start the state change + StartStateChange(StartupAdaptation::ESIMPresent); + } + +/** +@panic EInternalStateError if the active object is running or the state change is pending +*/ +void CCustomCmdSimSecurityCheck::StartStateChange(const TSecurityState aState, const TStrtSecurityNoteType aNoteType) + { + __ASSERT_ALWAYS(!IsActive(), PanicNow(KPanicCustomCmdSimSecurityCheck, EInternalStateError)); + __ASSERT_ALWAYS(!iStateChangePending, PanicNow(KPanicCustomCmdSimSecurityCheck, EInternalStateError)); + + iSubState = ESecuritySubStateNone; + iStateChangePending = ETrue; + iNoteType = aNoteType; + iState = aState; + + //Request for security state change + iSsmMiscAdaptation.SecurityStateChange(iState, *iSecurityStateInfoResult, iStatus); + SetActive(); + } + +void CCustomCmdSimSecurityCheck::RunL() + { + if(iSubState != ESecuritySubStateNone) + { + //Execute sim operations + DoExtendedSimOperations(); + return; + } + + if (iStateChangePending) + { + //Start changing the state + StateChangeL(iStatus.Int()); + } + else + { + if (iStatus == KErrNone) + { + //Do further security check + DoSecurityCheck(); + } + else + { + //Complete client request with result code + CompleteClientRequest(iStatus.Int()); + } + } + } + +void CCustomCmdSimSecurityCheck::DoExtendedSimOperations() + { + if (KErrNone == iStatus.Int()) + { + switch (iSubState) + { + case ESecuritySubStateSimRemoved: + DoSimRemoved(); + break; + case ESecuritySubStateSimNotSupported: + DoSimNotSupported(); + break; + case ESecuritySubStateSimReadable: + DoSimReadable(); + break; + case ESecuritySubStateSimUsable: + DoSimUsable(); + break; + case ESecuritySubStateSimStatusPSObserver: + DoObserveSimStatusPS(); + break; + default: + __ASSERT_DEBUG(ESecuritySubStateNone == iSubState, PanicNow(KPanicCustomCmdSimSecurityCheck, EInvalidSecuritySubState)); + break; + } + } + else + { + //Complete client request with result code + CompleteClientRequest(iStatus.Int()); + } + } + +void CCustomCmdSimSecurityCheck::StateChangeL(const TInt aResultCode) + { + __ASSERT_ALWAYS(iStateChangePending, PanicNow(KPanicCustomCmdSimSecurityCheck, EInternalStateError)); + DEBUGPRINT2A("Sim security state change completed with error %d", aResultCode); + + iStateChangePending = EFalse; + if (aResultCode == KErrNone) + { + //Proceed with state change in case previous state completed with out any error + SecurityCheckL(); + } + else + { + //Complete client request with result code + CompleteClientRequest(aResultCode); + } + } + +void CCustomCmdSimSecurityCheck::CompleteClientRequest(TInt aReason) + { + //Complete client request with reason code + if (iExecuteRequest) + { + User::RequestComplete(iExecuteRequest, aReason); + } + } + +void CCustomCmdSimSecurityCheck::SecurityCheckL() + { + //Delete the security notifier + delete iSsmSecurityCheckNotifier; + iSsmSecurityCheckNotifier = NULL; + + TInt errorCode = KErrNone; + //Handle the state transition + switch (iState) + { + case StartupAdaptation::ESIMPresent: + HandleSIMPresent(); + break; + case StartupAdaptation::ESIMReadable: + SimReadable(); + break; + case StartupAdaptation::ESIMInvalid: + HandleSIMInvalid(); + break; + case StartupAdaptation::ESIMRejected: + HandleSIMRejected(); + break; + case StartupAdaptation::ESIMBlocked: + HandleSIMBlocked(); + break; + case StartupAdaptation::EPINRequired: + HandlePINRequired(); + break; + case StartupAdaptation::ESIMLessOfflineSupported: + HandleSIMLessOfflineSupported(); + break; + case StartupAdaptation::ESIMCodesOK: + StartStateChange( StartupAdaptation::ESIMLock ); + break; + case StartupAdaptation::ESecurityCheckOK: + errorCode = RProperty::Set(CSsmUiSpecific::StarterPSUid(), KStarterSecurityPhase, EStarterSecurityPhaseSimOk ); + if(KErrNone != errorCode) + { + DEBUGPRINT2A("Failed to set value of property CSsmUiSpecific::StarterPSUid() because of error %d", errorCode); + } + CompleteClientRequest(KErrNone); + break; + case StartupAdaptation::ESecurityCheckFailed: + errorCode = RProperty::Set(CSsmUiSpecific::StarterPSUid(), KStarterSecurityPhase, EStarterSecurityPhaseSimNok); + if(KErrNone != errorCode) + { + DEBUGPRINT2A("Failed to set value of property CSsmUiSpecific::StarterPSUid() because of error %d", errorCode); + } + CompleteClientRequest(KErrNone); + break; + case StartupAdaptation::ESIMLock: + if (iSecurityStateInfo == StartupAdaptation::ESimLockRestrictionOn) + { + StartSecurityNoteObserverL(); + iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(ESecInfoSimLockRestrOn); + iSsmSecurityCheckNotifier->ShowNoteL(iStatus); + SetActive(); + } + else + { + DoSecurityCheck(); + } + break; + case StartupAdaptation::EAskPIN: + case StartupAdaptation::EAskPUK: + StartSecurityNoteObserverL(); + iSsmSecurityCheckNotifier = CSsmSecurityCheckNotifier::NewL(iNoteType); + iSsmSecurityCheckNotifier->ShowNoteL(iStatus); + SetActive(); + break; + default: + CompleteClientRequest(KErrNotSupported); + break; + }; + } + +void CCustomCmdSimSecurityCheck::DoSecurityCheck() + { + //Handle pending state transition + switch (iState) + { + case StartupAdaptation::ESIMLock: + HandleSIMLock(); + break; + case StartupAdaptation::EAskPIN: + HandlePINAsked(); + break; + case StartupAdaptation::EAskPUK: + HandlePUKAsked(); + break; + default: + CompleteClientRequest(KErrNotSupported); + break; + }; + } + +void CCustomCmdSimSecurityCheck::HandleSIMPresent() + { + switch (iSecurityStateInfo) + { + case StartupAdaptation::EYes: + //Start sim readable state transition + StartStateChange(StartupAdaptation::ESIMReadable); + break; + case StartupAdaptation::ENo: + if (IsSimSupported()) + { + SimRemoved(); + } + else + { + SimNotSupported(); + } + break; + default: + DEBUGPRINT2A("Illegal security result in ESIMPresent state: %d", iSecurityStateInfo); + CompleteClientRequest(KErrGeneral); + break; + }; + } + +void CCustomCmdSimSecurityCheck::DoSimRemoved() + { + //Start sim less offline support state transition + StartStateChange(StartupAdaptation::ESIMLessOfflineSupported); + } + +void CCustomCmdSimSecurityCheck::DoSimNotSupported() + { + //Start sim less offline support state transition + StartStateChange(StartupAdaptation::ESIMLessOfflineSupported); + } + +void CCustomCmdSimSecurityCheck::DoSimReadable() + { + if(IsSsmInvalidSimOn()) + { + //Start sim invalid state transition + StartStateChange(StartupAdaptation::ESIMInvalid); + } + else + { + //Start sim rejected state transition + StartStateChange(StartupAdaptation::ESIMRejected); + } + } + +void CCustomCmdSimSecurityCheck::DoSimUsable() + { + TInt simStatus = ESimStatusUninitialized; + TInt errVal = (iSimStatusPSObserver->GetValue(simStatus)); + + if (KErrNone == errVal) + { + //Do not observe if SIM status has already changed to ESimUsable + if(simStatus == ESimUsable) + { + //Start security check ok state transition + StartStateChange(StartupAdaptation::ESecurityCheckOK); + } + else + { + //Wait till the SIM status changes to ESimUsable. + //Start observing for the P&S key change + iSimStatusPSObserver->StartObserving(iStatus); + iSubState = ESecuritySubStateSimStatusPSObserver; + SetActive(); + } + } + else + { + DEBUGPRINT2A("Error when getting SIM status value: %d", errVal); + CompleteClientRequest(errVal); + } + } + +void CCustomCmdSimSecurityCheck::DoObserveSimStatusPS() + { + //Start security check ok state transition + StartStateChange(StartupAdaptation::ESecurityCheckOK); + } + +void CCustomCmdSimSecurityCheck::SimRemoved() + { + TUint simStatusPropertyKey = iSsmUiSpecific->SimStatusPropertyKey(); + TSsmSwp swp(simStatusPropertyKey, ESimNotPresent); + iSsmStateManager.RequestSwpChange(swp, iStatus); + iSubState = ESecuritySubStateSimRemoved; + SetActive(); + } + +void CCustomCmdSimSecurityCheck::SimNotSupported() + { + TUint simStatusPropertyKey = iSsmUiSpecific->SimStatusPropertyKey(); + TSsmSwp swp(simStatusPropertyKey, ESimNotSupported); + iSsmStateManager.RequestSwpChange(swp, iStatus); + iSubState = ESecuritySubStateSimNotSupported; + SetActive(); + } + +void CCustomCmdSimSecurityCheck::SimReadable() + { + TUint simStatusPropertyKey = iSsmUiSpecific->SimStatusPropertyKey(); + TSsmSwp swp(simStatusPropertyKey, ESimReadable); + iSsmStateManager.RequestSwpChange(swp, iStatus); + iSubState = ESecuritySubStateSimReadable; + SetActive(); + } + +void CCustomCmdSimSecurityCheck::SimUsable() + { + TUint simStatusPropertyKey = iSsmUiSpecific->SimStatusPropertyKey(); + TSsmSwp swp(simStatusPropertyKey, ESimUsable); + iSsmStateManager.RequestSwpChange(swp, iStatus); + iSubState = ESecuritySubStateSimUsable; + SetActive(); + } + +void CCustomCmdSimSecurityCheck::HandleSIMInvalid() + { + switch (iSecurityStateInfo) + { + case StartupAdaptation::EYes: + + //Publish the Sim Security Status as ESimInvalid + RProperty::Set(iStartupPSUid, KStartupSimSecurityStatus, ESimInvalid); + + //Set the security state as failed + SetSecurityStatus(EStrtSecurityCheckFailed); + + //Start sim less offline support state transition + StartStateChange(StartupAdaptation::ESecurityCheckFailed); + break; + case StartupAdaptation::ENo: + //Start sim rejected state transition + StartStateChange(StartupAdaptation::ESIMRejected); + break; + default: + DEBUGPRINT2A("Illegal security result in ESIMInvalid state: %d", iSecurityStateInfo); + //Complete user request with KErrGeneral + CompleteClientRequest(KErrGeneral); + break; + }; + } + + +void CCustomCmdSimSecurityCheck::HandleSIMRejected() + { + switch (iSecurityStateInfo) + { + case StartupAdaptation::EYes: + RProperty::Set(iStartupPSUid, KStartupSimSecurityStatus, ESimRejected ); + + //Set the security state as failed + SetSecurityStatus(EStrtSecurityCheckFailed); + + //Start sim less offline support state transition + StartStateChange(StartupAdaptation::ESecurityCheckFailed); + break; + case StartupAdaptation::ENo: + //Start sim blocked state transition + StartStateChange(StartupAdaptation::ESIMBlocked); + break; + default: + DEBUGPRINT2A("Illegal security result in ESIMRejected state: %d", iSecurityStateInfo); + + //Complete user request with KErrGeneral + CompleteClientRequest(KErrGeneral); + break; + }; + } + +void CCustomCmdSimSecurityCheck::HandleSIMBlocked() + { + switch (iSecurityStateInfo) + { + case StartupAdaptation::EPUK1Required: + //Start PUK required state transition + StartStateChange(StartupAdaptation::EAskPUK, ESecCodePUK1); + break; + case StartupAdaptation::EUPUKRequired: + //Start UPUK required state transition + StartStateChange(StartupAdaptation::EAskPUK, ESecCodeUPUK); + break; + case StartupAdaptation::ENo: + //Start PIN required state transition + StartStateChange(StartupAdaptation::EPINRequired); + break; + default: + DEBUGPRINT2A("Illegal security result in ESIMBlocked state: %d", iSecurityStateInfo); + + //Complete user request with KErrGeneral + CompleteClientRequest(KErrGeneral); + break; + }; + } + +void CCustomCmdSimSecurityCheck::HandlePINRequired() + { + switch (iSecurityStateInfo) + { + case StartupAdaptation::EPIN1Required: + //Start PIN required state transition + StartStateChange(StartupAdaptation::EAskPIN, ESecCodePIN1); + break; + case StartupAdaptation::EUPINRequired: + //Start UPIN required state transition + StartStateChange(StartupAdaptation::EAskPIN, ESecCodeUPIN); + break; + case StartupAdaptation::ENo: + //Start SIM Codes OK state transition + StartStateChange(StartupAdaptation::ESIMCodesOK); + break; + default: + DEBUGPRINT2A( "Illegal security result in EPINRequired state: %d", iSecurityStateInfo ); + + //Complete user request with KErrGeneral + CompleteClientRequest(KErrGeneral); + break; + }; + } + +void CCustomCmdSimSecurityCheck::HandleSIMLessOfflineSupported() + { + if (IsSimSupported()) + { + if (iSsmUiSpecific->IsSimlessOfflineSupported()) + { + //SIMless offline is supported + + //Set the security state as Sim less offline + SetSecurityStatus(EStrtSimlessOffline); + StartStateChange(StartupAdaptation::ESIMLock); + } + else + { + //SIMless offline is not supported + + //Set the security state as failed + SetSecurityStatus(EStrtSecurityCheckFailed); + StartStateChange(StartupAdaptation::ESecurityCheckFailed); + } + } + else + { + //SIM not supported + SetSecurityStatus(EStrtSimlessOffline); + StartStateChange(StartupAdaptation::ESIMLock); + } + } + +TBool CCustomCmdSimSecurityCheck::IsSimSupported() + { + return iSsmUiSpecific->IsSimSupported(); + } + +void CCustomCmdSimSecurityCheck::HandleSIMLock() + { + switch(iSecurityStateInfo) + { + case StartupAdaptation::ESimLockRestricted: + //Set the sim lock status property to "Sim lock active" + RProperty::Set(iStartupPSUid, KStartupSimLockStatus, ESimLockActive ); + + //Set the sim security status property to "Sim unaccepted" + RProperty::Set(iStartupPSUid, KStartupSimSecurityStatus, ESimUnaccepted ); + + //Set the security state as failed + SetSecurityStatus(EStrtSecurityCheckFailed); + + //Start security check failed state transition + StartStateChange(StartupAdaptation::ESecurityCheckFailed); + break; + case StartupAdaptation::ESimLockOk: + //Set the sim lock status property to "Sim lock ok" + RProperty::Set(iStartupPSUid, KStartupSimLockStatus, ESimLockOk ); + SetSecurityCheckOK(); + break; + case StartupAdaptation::ESimLockRestrictionOn: + //Set the sim lock status property to "Sim lock restriction on" + RProperty::Set(iStartupPSUid, KStartupSimLockStatus, ESimLockRestrictionOn); + SetSecurityCheckOK(); + break; + case StartupAdaptation::ESimLockRestrictionPending: + //Set the sim lock status property to "Sim lock restriction pending" + RProperty::Set(iStartupPSUid, KStartupSimLockStatus, ESimLockRestrictionPending); + + //Set the sim security status property to "Sim unaccepted" + RProperty::Set(iStartupPSUid, KStartupSimSecurityStatus, ESimUnaccepted); + + //Set the security state as failed + SetSecurityStatus( EStrtSecurityCheckFailed); + + //Start security check failed state transition + StartStateChange(StartupAdaptation::ESecurityCheckFailed); + break; + default: + DEBUGPRINT2A("Illegal security result in ESIMLock state: %d", iSecurityStateInfo); + //Complete user request with KErrGeneral + CompleteClientRequest(KErrGeneral); + break; + } + + } + +void CCustomCmdSimSecurityCheck::SetSecurityCheckOK() + { + if (SecurityStatus() != EStrtSimlessOffline) + { + //Set the security state as passed + SetSecurityStatus( EStrtSecurityCheckPassed); + SimUsable(); + } + else + { + //Start security check ok state transition + StartStateChange(StartupAdaptation::ESecurityCheckOK); + } + } + + +void CCustomCmdSimSecurityCheck::HandlePINAsked() + { + __ASSERT_DEBUG(NULL != iSsmSecurityCheckNotifier, PanicNow(KPanicCustomCmdSimSecurityCheck, ECmdNullPtr)); + + const TBool isCodeAccepted = iSsmSecurityCheckNotifier->IsCodeAccepted(); + + //Try again until PIN is either accepted or blocked. + if (isCodeAccepted) + { + //Start SIM codes ok state transition + StartStateChange(StartupAdaptation::ESIMCodesOK); + } + else + { + switch(iNoteType) + { + case ESecCodePIN1: + //Start security code PUK1 state transition + StartStateChange(StartupAdaptation::EAskPUK, ESecCodePUK1); + break; + case ESecCodeUPIN: + //Start security code UPUK state transition + StartStateChange(StartupAdaptation::EAskPUK, ESecCodeUPUK); + break; + default: + DEBUGPRINT2A("Illegal code type in EAskPIN state: %d", iNoteType); + //Complete user request with KErrGeneral + CompleteClientRequest(KErrGeneral); + break; + } + } + } + +void CCustomCmdSimSecurityCheck::HandlePUKAsked() + { + __ASSERT_DEBUG(NULL != iSsmSecurityCheckNotifier, PanicNow(KPanicCustomCmdSimSecurityCheck, ECmdNullPtr)); + + //Is the entered code correct + const TBool isCodeAccepted = iSsmSecurityCheckNotifier->IsCodeAccepted(); + + if (isCodeAccepted) + { + //Start SIM code ok state transition + StartStateChange(StartupAdaptation::ESIMCodesOK); + } + else + { + //Set the Sim security status property to "Sim rejected" + RProperty::Set(iStartupPSUid, KStartupSimSecurityStatus, ESimRejected); + + //Set the security state as failed + SetSecurityStatus(EStrtSecurityCheckFailed); + + //Start security check failed state transition + StartStateChange(StartupAdaptation::ESecurityCheckFailed); + } + } + +void CCustomCmdSimSecurityCheck::SetSecurityStatus(const TStrtSecurityStatus& aSecurityStatus) + { + iSsmUiSpecific->SetSecurityStatus(aSecurityStatus); + } + +TStrtSecurityStatus CCustomCmdSimSecurityCheck::SecurityStatus() const + { + return iSsmUiSpecific->SecurityStatus(); + } + +void CCustomCmdSimSecurityCheck::StartSecurityNoteObserverL() + { + if(!iSecurityNoteObserver) + { + iSecurityNoteObserver = CSecurityNoteObserver::NewL(); + } + } + +TInt CCustomCmdSimSecurityCheck::RunError(TInt aError) + { + //Do the final cleanup incase of error + Cleanup(aError); + return KErrNone; + } + +void CCustomCmdSimSecurityCheck::DoCancel() + { + // Cancel all possible requests that could be outstanding on iStatus + if(iSsmSecurityCheckNotifier) + { + iSsmSecurityCheckNotifier->Cancel(); + } + if(iSecurityNoteObserver) + { + iSecurityNoteObserver->Cancel(); + } + iSsmMiscAdaptation.Cancel(); + iSsmStateManager.RequestSwpChangeCancel(); + iSimStatusPSObserver->Cancel(); + } + +void CCustomCmdSimSecurityCheck::ExecuteCancel() + { + //Call cancel method of CActive + Cancel(); + + //Do the final cleanup before cancelling + Cleanup(KErrCancel); + } + +void CCustomCmdSimSecurityCheck::Cleanup(TInt aError) + { + if (iExecuteRequest) + { + //Complete the user request with the given error code + User::RequestComplete(iExecuteRequest, aError); + } + } + +// CSsmSimStatusPSObserver +// Active Object Class that observes for SIM status P&S key change +CSsmSimStatusPSObserver* CSsmSimStatusPSObserver::NewL(TUid aCategory, TUint aKey) + { + CSsmSimStatusPSObserver* self = new (ELeave) CSsmSimStatusPSObserver(aCategory, aKey); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CSsmSimStatusPSObserver::ConstructL() + { + User::LeaveIfError(iProperty.Attach(iCategory, iKey)); + } + +CSsmSimStatusPSObserver::CSsmSimStatusPSObserver(TUid aCategory, TUint aKey) + : CActive(EPriorityStandard), iCategory(aCategory), iKey(aKey) + { + CActiveScheduler::Add(this); + } + +CSsmSimStatusPSObserver::~CSsmSimStatusPSObserver() + { + Cancel(); + iProperty.Close(); + } + +void CSsmSimStatusPSObserver::StartObserving(TRequestStatus& aStatus) + { + __ASSERT_DEBUG(!(IsActive()), PanicNow(KPanicCustomCmdSimSecurityCheck, EInternalStateError)); + aStatus = KRequestPending; + iClientStatus = &aStatus; + iProperty.Subscribe(iStatus); + SetActive(); + } + +TInt CSsmSimStatusPSObserver::GetValue(TInt& aValue) + { + TInt errVal = (iProperty.Get(aValue)); + return errVal; + } + +void CSsmSimStatusPSObserver::DoCancel() + { + iProperty.Cancel(); + Complete(KErrCancel); + } + +void CSsmSimStatusPSObserver::RunL() + { + Complete(iStatus.Int()); + } + +void CSsmSimStatusPSObserver::Complete(const TInt aErrorCode) + { + if (iClientStatus) + { + User::RequestComplete(iClientStatus, aErrorCode); + iClientStatus = NULL; + } + }