--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/simtsy/src/CSimPhoneSecurity.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,1810 @@
+// Copyright (c) 2002-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:
+// Implements the Phone Security manipulation code.
+// 
+//
+
+/**
+ @file
+*/
+
+#include "CSimPhone.h"
+#include "Simlog.h"
+#include "utils.h"
+#include "CSimPhoneSecurity.h"
+#include <testconfigfileparser.h>
+#include "CSimTsyMode.h"
+#include <e32math.h>
+
+//
+// CSimPhoneSecurity
+//
+const TInt KICCProfileGranularity=5;		// < Granularity for Icc profile list array
+
+const TInt KDefaultPinEntryAttempts=3;		// < default number of PIN entry attempts if not defined in the config file
+const TInt KDefaultPukEntryAttempts=10;		// < default number of PUK entry attempts if not defined in the config file
+
+CSimPhoneSecurity* CSimPhoneSecurity::NewL(CSimPhone* aPhone)
+/**
+ * Standard two phase constructor.
+ * @param aPhone The phone object from which the PhoneSecurity was opened.
+ */
+	{
+	CSimPhoneSecurity* obj=new(ELeave) CSimPhoneSecurity(aPhone);
+	CleanupStack::PushL(obj);
+	obj->ConstructL();
+	CleanupStack::Pop();
+	return obj;
+	}
+
+CSimPhoneSecurity::CSimPhoneSecurity(CSimPhone* aPhone)
+		: iPhone(aPhone) 
+/**
+ * Trivial first phase constructor.
+ * @param aPhone	The phone object from which this phonebook was opened.
+ */
+	{}
+
+void CSimPhoneSecurity::Init()
+	{}
+
+void CSimPhoneSecurity::ConstructL()
+/** Change
+ * Second phase constructor that allocates memory for the phonebook, batch read buffer and
+ * a delayed completion timer.  The constructor also reads the individual and batch read
+ * delays from the configuration file.
+ */
+	{
+	LOGPHONE1("Starting to parse PhoneSecurity additional config parameters...");
+	
+	iNotifySettingsTimer = CIccTimer::NewL();
+	iNotifySecurityEventsTimer = CIccTimer::NewL();
+	
+	iNotifySettingsTimer->iTimer = CSimTimer::NewL(iPhone);
+	iNotifySecurityEventsTimer->iTimer = CSimTimer::NewL(iPhone);
+	const CTestConfigItem* item=NULL;
+	TInt ret=KErrNone;
+	TInt i;
+	iICCStatusProfile=new(ELeave) CArrayFixFlat<TICCStatusEntry>(KICCProfileGranularity);
+	iICCSettingProfile=new(ELeave) CArrayFixFlat<TICCSettingEntry>(KICCProfileGranularity);
+
+	item=CfgFile()->Item(KSecurityCodes);
+	if(item)
+		{
+		TPtrC8 temp;
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,0,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iPin1.Copy(temp);
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,1,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iPin2.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,2,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iPuk1.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,3,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iPuk2.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,4,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iPhonePassword.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,5,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iSPC.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,6,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iPhBkHiddenKey.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,7,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iUSimAppPin.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,8,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iSecondUSimAppPin.Copy(temp);
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,9,&KSecurityCodes);
+			}
+		else
+			iSecCodes.iUniversalPin.Copy(temp);
+		}
+	
+	
+	item=CfgFile()->Item(KSecurityCodeAttempts);
+	if(item)
+		{
+		TInt temp;
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR(&KSecurityCodeAttempts,ret,0,&KSecurityCodeAttempts);
+			}
+		else
+			{
+			if (temp <= 0)
+				{
+				LOGPARSERRANGE(&KSecurityCodeAttempts,temp,"> 0",0,&KSecurityCodeAttempts);
+				LOGCONFIG1("Using default value...");
+				temp = KDefaultPinEntryAttempts;
+				}
+			iSecurityCodeRemainigAttempts.iPin1=temp;
+			iSecurityCodeDefaultRemainigAttempts.iPin1=temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR(&KSecurityCodeAttempts,ret,1,&KSecurityCodeAttempts);
+			}
+		else
+			{
+			if (temp <= 0)
+				{
+				LOGPARSERRANGE(&KSecurityCodeAttempts,temp,"> 0",1,&KSecurityCodeAttempts);
+				LOGCONFIG1("Using default value...");
+				temp = KDefaultPinEntryAttempts;
+				}
+			iSecurityCodeRemainigAttempts.iPin2=temp;
+			iSecurityCodeDefaultRemainigAttempts.iPin2=temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR(&KSecurityCodeAttempts,ret,2,&KSecurityCodeAttempts);
+			}
+		else
+			{
+			if (temp <= 0)
+				{
+				LOGPARSERRANGE(&KSecurityCodeAttempts,temp,"> 0",2,&KSecurityCodeAttempts);
+				LOGCONFIG1("Using default value...");
+				temp = KDefaultPukEntryAttempts;
+				}
+			iSecurityCodeRemainigAttempts.iPuk1=temp;
+			iSecurityCodeDefaultRemainigAttempts.iPuk1=temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR(&KSecurityCodeAttempts,ret,3,&KSecurityCodeAttempts);
+			}
+		else
+			{
+			if (temp <= 0)
+				{
+				LOGPARSERRANGE(&KSecurityCodeAttempts,temp,"> 0",3,&KSecurityCodeAttempts);
+				LOGCONFIG1("Using default value...");
+				temp = KDefaultPukEntryAttempts;
+				}
+			iSecurityCodeRemainigAttempts.iPuk2=temp;
+			iSecurityCodeDefaultRemainigAttempts.iPuk2=temp;
+			}
+		}
+	else
+		{
+		LOGPHONE2("NOTE tag %S not defined, using default values",&KSecurityCodeAttempts);
+		iSecurityCodeDefaultRemainigAttempts.iPin1= KDefaultPinEntryAttempts;
+		iSecurityCodeRemainigAttempts.iPin1= iSecurityCodeDefaultRemainigAttempts.iPin1;
+		iSecurityCodeDefaultRemainigAttempts.iPin2= KDefaultPinEntryAttempts;
+		iSecurityCodeRemainigAttempts.iPin2= iSecurityCodeDefaultRemainigAttempts.iPin2;
+		iSecurityCodeDefaultRemainigAttempts.iPuk1= KDefaultPukEntryAttempts;
+		iSecurityCodeRemainigAttempts.iPuk1= iSecurityCodeDefaultRemainigAttempts.iPuk1;
+		iSecurityCodeDefaultRemainigAttempts.iPuk2= KDefaultPukEntryAttempts;
+		iSecurityCodeRemainigAttempts.iPuk2 = iSecurityCodeDefaultRemainigAttempts.iPuk2;
+		}
+	
+	item=CfgFile()->Item(KICCLockedAtStart);
+	if(item)
+		{
+		TInt temp;
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,0,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iPin1=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iPin1=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,1,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iPin2=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iPin2=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,2,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iPuk1=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iPuk1=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,3,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iPuk2=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iPuk2=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,4,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iPhonePassword=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iPhonePassword=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,5,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,5,&KICCLockedAtStart);
+			}
+		else
+			iSecStatus.iSPC=(RMobilePhone::TMobilePhoneLockStatus) temp;
+
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,6,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,6,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iPhBkHiddenKey=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iPhBkHiddenKey=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,7,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,7,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iUSimAppPin=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iUSimAppPin=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,8,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,8,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iSecondUSimAppPin=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iSecondUSimAppPin=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,9,temp);
+		if(ret!=KErrNone)
+			{
+			LOGPARSERR("temp",ret,9,&KICCLockedAtStart);
+			}
+		else
+			{
+			iSecStatus.iUniversalPin=(RMobilePhone::TMobilePhoneLockStatus) temp;
+			iSecSetting.iUniversalPin=(RMobilePhone::TMobilePhoneLockSetting) temp;
+			}
+		}
+		
+		TInt count=CfgFile()->ItemCount(KICCStatus);
+		for(i=0;i<count;i++)
+			{
+			item=CfgFile()->Item(KICCStatus,i);
+			if(!item)
+				break;
+
+			TInt duration;
+			TInt ICCStatus;
+			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
+			if(ret!=KErrNone)
+				{
+				LOGPARSERR("duration",ret,0,&KICCStatus);
+				continue;
+				}
+			
+			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,ICCStatus);
+			if(ret!=KErrNone)
+				{
+				LOGPARSERR("ICCStatus",ret,1,&KICCStatus);
+				continue;
+				}
+			
+			TICCStatusEntry icc;
+			icc.iDuration=duration;
+			icc.iICCStatus=(RMobilePhone::TMobilePhoneSecurityEvent) ICCStatus;
+			iICCStatusProfile->AppendL(icc);
+			}
+			
+			
+		count=CfgFile()->ItemCount(KICCSetting);
+		for(i=0;i<count;i++)
+			{
+			item=CfgFile()->Item(KICCSetting,i);
+			if(!item)
+				break;
+
+	
+			TInt duration(0), lock(0), lockSetting(0), lockStatus(0);
+
+			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,duration);
+			if(ret!=KErrNone)
+				{
+				LOGPARSERR("duration",ret,0,&KICCSetting);
+				continue;
+				}
+				
+			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,lock);
+			if(ret!=KErrNone)
+				{
+				LOGPARSERR("lock",ret,1,&KICCSetting);
+				continue;
+				}
+			
+			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,lockSetting);
+			if(ret!=KErrNone)
+				{
+				LOGPARSERR("lockSetting",ret,2,&KICCSetting);
+				continue;
+				}
+			
+			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,lockStatus);
+			if(ret!=KErrNone)
+				{
+				LOGPARSERR("lockStatus",ret,3,&KICCSetting);
+				continue;
+				}
+			
+			TICCSettingEntry icc;
+			icc.iLock = (RMobilePhone::TMobilePhoneLock)lock;
+			icc.iDuration=duration;
+			icc.iLockInfo.iSetting=(RMobilePhone::TMobilePhoneLockSetting) lockSetting;
+			icc.iLockInfo.iStatus=(RMobilePhone::TMobilePhoneLockStatus) lockStatus;
+			iICCSettingProfile->AppendL(icc);
+			}
+
+	}
+
+
+CSimPhoneSecurity::~CSimPhoneSecurity()
+/**
+ * Standard destructor.  Any objects created by the ::ConstructL() function
+ * will be destroyed here.
+ */
+	{
+
+	if(iICCStatusProfile)
+		{
+		iICCStatusProfile->Delete(0,iICCStatusProfile->Count());
+		delete iICCStatusProfile;
+		}
+	if(iICCSettingProfile)
+		{
+		iICCSettingProfile->Delete(0, iICCSettingProfile->Count());
+		delete iICCSettingProfile;
+		}
+		
+	delete iNotifySettingsTimer;
+	delete iNotifySecurityEventsTimer;
+	
+	if (iUnlockNamTimer)
+		{
+		iUnlockNamTimer->Cancel();
+		delete iUnlockNamTimer;
+		iUnlockNamTimer = NULL;
+		}
+	if (iLockNamTimer)
+		{
+		iLockNamTimer->Cancel();
+		delete iLockNamTimer;
+		iLockNamTimer = NULL;
+		}
+	}
+
+TInt CSimPhoneSecurity::ExtFunc(const TTsyReqHandle aReqHandle,const TInt aIpc, const TDataPackage& aPckg)
+/**
+ * Dispatch function for all Phonebook Store requests.
+ * @param aReqHandle	The TSY request handle for this request.
+ * @param aIpc			The IPC number of this request.
+ * @param aPckg			The parameter package related to this request.
+ * @return TInt			The return error condition.
+ */
+	{
+
+	TAny* dataPtr = aPckg.Ptr1();
+	TAny* dataPtr2 = aPckg.Ptr2();
+
+// The following requests can be completed even if the completion of another request is pending.
+	switch(aIpc)
+		{
+	case EMobilePhoneGetSecurityCaps:
+		return GetSecurityCaps(aReqHandle,
+			REINTERPRET_CAST(TUint32*, dataPtr));
+
+	case EMobilePhoneNotifySecurityCapsChange:
+		return NotifySecurityCapsChange(aReqHandle, 
+			REINTERPRET_CAST(TUint32*, dataPtr2));
+
+	case EMobilePhoneGetLockInfo:
+		return GetLockInfo(aReqHandle, 
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneLock*, dataPtr), 
+			aPckg.Des2n());
+
+	case EMobilePhoneNotifyLockInfoChange:
+		return NotifyLockInfoChange(aReqHandle, 
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneLock*, dataPtr), 
+			aPckg.Des2n());
+
+	case EMobilePhoneSetLockSetting:
+		return SetLockSetting(aReqHandle, 
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneLock*, dataPtr), 
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneLockSetting*, dataPtr2));
+
+	case EMobilePhoneGetSecurityCodeInfo:
+		return GetSecurityCodeInfo(aReqHandle, 
+			reinterpret_cast<RMobilePhone::TMobilePhoneSecurityCode*> (dataPtr), 
+			aPckg.Des2n());
+
+	case EMobilePhoneNotifySecurityCodeInfoChange:
+		return NotifySecurityCodeInfoChange(aReqHandle, 
+			reinterpret_cast<RMobilePhone::TMobilePhoneSecurityCode*> (dataPtr), 
+			aPckg.Des2n());
+		
+	case EMobilePhoneChangeSecurityCode:
+		return ChangeSecurityCode(aReqHandle, 
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneSecurityCode*, dataPtr),
+			aPckg.Des2n());
+
+	case EMobilePhoneNotifySecurityEvent:
+		return NotifySecurityEvent(aReqHandle, aPckg.Des1n());
+
+	case EMobilePhoneVerifySecurityCode:
+		return VerifySecurityCode(aReqHandle, 
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneSecurityCode*, dataPtr), 
+			REINTERPRET_CAST(RMobilePhone::TCodeAndUnblockCode*, dataPtr2));
+ 
+	case EMobilePhoneAbortSecurityCode:
+		return AbortSecurityCode(aReqHandle,
+			REINTERPRET_CAST(RMobilePhone::TMobilePhoneSecurityCode*, dataPtr));
+	default:
+		break;
+		}
+
+
+// The TSY can only process one of the following requests at a time.  If a second is received
+// while processing the first, then it will be errored with KErrInUse.  This restriction will
+// be removed later, by inserting a request queuing mechanism.  Note that the standard TSY
+// "flow control" mechanism works phone-wide and so is not suitable.
+
+//	switch(aIpc)
+//		{
+//	default:
+//		break;
+//		}
+
+	return KErrNotSupported;
+	}
+
+CTelObject* CSimPhoneSecurity::OpenNewObjectByNameL(const TDesC& /*aName*/)
+/**
+ * The API does not support any objects that could be opened from this one.
+ */
+	{
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+CTelObject* CSimPhoneSecurity::OpenNewObjectL(TDes&)
+/**
+ * The API does not support any objects that could be opened from this one.
+ */
+	{
+	User::Leave(KErrNotSupported);
+	return NULL;
+	}
+
+CTelObject::TReqMode CSimPhoneSecurity::ReqModeL(const TInt aIpc)
+/**
+ * This function returns the Request Mode for the request with the passed IPC value.
+ * @param aIpc		The IPC number of the request.
+ * @return TReqMode	The request mode.
+ */
+	{
+	CTelObject::TReqMode ret=0;	
+	// This function seems be unused. ReqModeL for security related IPC is in CSimPhone. 
+	switch(aIpc)
+		{
+	case EMobilePhoneGetSecurityCaps:
+	case EMobilePhoneGetLockInfo:
+	case EMobilePhoneSetLockSetting:
+	case EMobilePhoneChangeSecurityCode:
+	case EMobilePhoneVerifySecurityCode:
+	case EMobilePhoneAbortSecurityCode:
+		break;
+
+	case EMobilePhoneNotifyLockInfoChange:
+	case EMobilePhoneNotifySecurityCapsChange:
+	case EMobilePhoneNotifySecurityEvent:
+		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;
+		break;
+
+	default:
+		User::Leave(KErrNotSupported);
+		break;
+		}
+
+	return ret;
+	}
+
+TInt CSimPhoneSecurity::RegisterNotification(const TInt /*aIpc*/)
+/**
+ * The ETel Server calls this function when the first client makes a notification
+ * request.  If supported by the underlying protocol controlling the
+ * signalling stack, this can be used to start requesting updates for the relevant
+ * service.
+ */
+	{
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::DeregisterNotification(const TInt /*aIpc*/)
+/**
+ * The ETel Server calls this function when the last client that had previously
+ * made a notification request closes its ETel Server handle.  If supported by
+ * the underlying protocol controlling the	signalling stack, this can be used
+ * to stop requesting updates for the relevant service.
+ */
+	{
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NumberOfSlotsL(const TInt aIpc)
+/**
+ * Return the number of slots that the ETel Server should allocate for buffering requests
+ * of the given IPC number.
+ */
+	{
+	switch(aIpc)
+		{
+	case EMobilePhoneNotifyLockInfoChange:
+	case EMobilePhoneNotifySecurityCapsChange:
+	case EMobilePhoneNotifySecurityEvent:
+		return KDefaultNumberOfSlots;
+
+	default:
+		LOGPHONE1("CSimPhoneSecurity: Number of Slots error, unknown IPC");
+		User::Leave(KErrNotSupported);
+		break;
+		}
+	return KDefaultNumberOfSlots;
+	}
+
+TInt CSimPhoneSecurity::CancelService(const TInt aIpc, const TTsyReqHandle aReqHandle)
+/**
+ * Cancel an outstanding request.
+ * @param aIpc			The IPC number of the request that is to be cancelled.
+ * @param aTsyReqHandle	The TSY request handle of the request that is to be cancelled.
+ * @param TInt			Standard return value.
+ */
+	{
+	switch(aIpc)
+		{
+	case EMobilePhoneNotifySecurityCapsChange:
+		return NotifySecurityCapsChangeCancel(aReqHandle);
+
+	case EMobilePhoneGetLockInfo:
+		return GetLockInfoCancel(aReqHandle);
+
+	case EMobilePhoneNotifyLockInfoChange:
+		return NotifyLockInfoChangeCancel(aReqHandle);
+
+	case EMobilePhoneSetLockSetting:
+		return SetLockSettingCancel(aReqHandle);
+
+	case EMobilePhoneGetSecurityCodeInfo:
+		return GetSecurityCodeInfoCancel(aReqHandle);
+		
+	case EMobilePhoneNotifySecurityCodeInfoChange:
+		return NotifySecurityCodeInfoChangeCancel(aReqHandle);
+	
+	case EMobilePhoneChangeSecurityCode:
+		return ChangeSecurityCodeCancel(aReqHandle);
+
+	case EMobilePhoneNotifySecurityEvent:
+		return NotifySecurityEventCancel(aReqHandle);
+
+	case EMobilePhoneVerifySecurityCode:
+		return VerifySecurityCodeCancel(aReqHandle);
+	default:
+		break;
+		}
+	return KErrNone;
+	}
+
+
+const CTestConfigSection* CSimPhoneSecurity::CfgFile()
+/**
+* Returns a pointer to the config file section
+*
+* @return CTestConfigSection a pointer to the configuration file data section
+*/
+	{
+	LOGPHONE1(">>CSimPhoneSecurity::CfgFile");
+	return iPhone->CfgFile();
+	}
+
+
+TInt CSimPhoneSecurity::GetSecurityCaps(const TTsyReqHandle aReqHandle, TUint32* aCaps)
+	{
+		//Support all the security features that can be configured using config.txt
+		*aCaps= ( RMobilePhone::KCapsLockPhone |
+				  RMobilePhone::KCapsLockICC |
+				  RMobilePhone::KCapsAccessPin1 |
+				  RMobilePhone::KCapsAccessPin2 |
+				  RMobilePhone::KCapsAccessPhonePassword |
+				  RMobilePhone::KCapsAccessSPC |
+				  RMobilePhone::KCapsAccessHiddenKey |
+				  RMobilePhone::KCapsAccessUSIMAppPin |
+				  RMobilePhone::KCapsAccessUSIMAppSecondPin |
+				  RMobilePhone::KCapsAccessUniversalPin );  
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NotifySecurityCapsChange(const TTsyReqHandle aReqHandle, TUint32* /*aCaps*/)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNotSupported);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NotifySecurityCapsChangeCancel(const TTsyReqHandle aReqHandle)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::GetLockInfo(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneLock* aLock, TDes8* aLockInfo)
+	{
+		RMobilePhone::TMobilePhoneLockInfoV1Pckg* lockPckg = (RMobilePhone::TMobilePhoneLockInfoV1Pckg*) aLockInfo;
+		RMobilePhone::TMobilePhoneLockInfoV1& lock = (*lockPckg)();
+
+		// Check that the data structure is supported by the simulated TSY version
+		TInt err = iPhone->CheckSimTsyVersion(lock);
+		if(err != KErrNone)
+			{
+			iPhone->ReqCompleted(aReqHandle, err);
+			return KErrNone;
+			}
+
+		switch(*aLock)
+		{
+		case RMobilePhone::ELockICC:
+			lock.iStatus=iSecStatus.iPin1;
+			lock.iSetting=iSecSetting.iPin1;
+			break;
+		case RMobilePhone::ELockPin2:
+			lock.iStatus=iSecStatus.iPin2;
+			lock.iSetting=iSecSetting.iPin2;
+			break;
+		case RMobilePhone::ELockHiddenKey:
+			lock.iStatus=iSecStatus.iPhBkHiddenKey;
+			lock.iSetting=iSecSetting.iPhBkHiddenKey;
+			break;
+		case RMobilePhone::ELockUSimApp:
+			lock.iStatus=iSecStatus.iUSimAppPin;
+			lock.iSetting=iSecSetting.iUSimAppPin;
+			break;
+		case RMobilePhone::ELockSecondUSimApp:
+			lock.iStatus=iSecStatus.iSecondUSimAppPin;
+			lock.iSetting=iSecSetting.iSecondUSimAppPin;
+			break;
+		case RMobilePhone::ELockUniversalPin:
+			lock.iStatus=iSecStatus.iUniversalPin;
+			lock.iSetting=iSecSetting.iUniversalPin;
+			break;
+
+		case RMobilePhone::ELockNam:
+			iPhone->ReqCompleted(aReqHandle,KErrNotSupported);
+			return KErrNone;	
+				
+//		Not supported!
+//		case RMobilePhone::ELockPhoneDevice:
+//		case RMobilePhone::ELockPhoneToIcc:
+//		case RMobilePhone::ELockPhoneToFirstIcc:
+//		case RMobilePhone::ELockOTA:	
+		default:
+			iPhone->ReqCompleted(aReqHandle,KErrNotSupported);
+			return KErrNone;	
+		}
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::GetLockInfoCancel(const TTsyReqHandle aReqHandle)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NotifyLockInfoChange(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneLock* aLock, TDes8* aLockInfo)
+	{
+	RMobilePhone::TMobilePhoneLockInfoV1Pckg* lockPckg = (RMobilePhone::TMobilePhoneLockInfoV1Pckg*) aLockInfo;
+	RMobilePhone::TMobilePhoneLockInfoV1& lock = (*lockPckg)();
+
+	// Check that the data structure is supported by the simulated TSY version
+	TInt err = iPhone->CheckSimTsyVersion(lock);
+	if(err != KErrNone)
+		{
+		iPhone->ReqCompleted(aReqHandle, err);
+		return KErrNone;
+		}
+
+	__ASSERT_ALWAYS(!iNotifyLock.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+	
+	if (iNotifySettingsTimer->iIndex <  iICCSettingProfile->Count())
+		{
+		TICCSettingEntry entry = iICCSettingProfile->At(iNotifySettingsTimer->iIndex);
+		if(iNotifySettingsTimer->iTimerStarted)
+			{
+			delete iNotifySettingsTimer->iTimer;
+			iNotifySettingsTimer->iTimer = NULL;
+			TRAPD(err,iNotifySettingsTimer->iTimer=CSimTimer::NewL(iPhone));
+			if (err!=KErrNone)
+				return (err);
+			}
+		iNotifySettingsTimer->iTimer->Start(entry.iDuration, this, ETimerIdSecurityNotifyLockInfo);
+		iNotifySettingsTimer->iTimerStarted = ETrue;
+		}
+	
+	iNotifyLock.iNotifyPending=ETrue;
+	iNotifyLock.iNotifyHandle=aReqHandle;
+	iNotifyLock.iNotifyData=&lock;
+	iNotifyLock.iNotifyDataXtra=aLock;
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NotifyLockInfoChangeCancel(const TTsyReqHandle aReqHandle)
+	{
+	if(iNotifyLock.iNotifyPending)
+		{
+		iNotifyLock.iNotifyPending=EFalse;
+		iPhone->ReqCompleted(aReqHandle,KErrCancel);
+		return KErrNone;
+		}	
+	iPhone->ReqCompleted(aReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::SetLockSetting(const TTsyReqHandle aTsyReqHandle,
+									   RMobilePhone::TMobilePhoneLock* aLock,
+									   RMobilePhone::TMobilePhoneLockSetting* aSetting)
+	{
+	// create dummy RMobilePhone::TMobilePhoneLockInfoV1 for
+	// UpdateLockInfo and CompleteNotifyLockInfoChange
+	RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+
+	// Check that the data structure is supported by the simulated TSY version
+	TInt err = iPhone->CheckSimTsyVersion(lockInfo);
+	if(err != KErrNone)
+		{
+		iPhone->ReqCompleted(aTsyReqHandle, err);
+		return KErrNone;
+		}
+
+	lockInfo.iSetting = *aSetting;
+
+	// set the iStatus of our local lock info to whatever the current
+	// lock info iStatus is set to. The reason is because the intent of
+	// SetLockSetting is to set the iSetting value of the lock while
+	// leaving the iStatus value untouched
+	switch(*aLock)
+		{
+		case RMobilePhone::ELockICC:
+			lockInfo.iStatus=iSecStatus.iPin1;
+			break;
+		case RMobilePhone::ELockPin2:
+			lockInfo.iStatus=iSecStatus.iPin2;
+			break;
+		case RMobilePhone::ELockHiddenKey:
+			lockInfo.iStatus=iSecStatus.iPhBkHiddenKey;
+			break;
+		case RMobilePhone::ELockUSimApp:
+			lockInfo.iStatus=iSecStatus.iUSimAppPin;
+			break;
+		case RMobilePhone::ELockSecondUSimApp:
+			lockInfo.iStatus=iSecStatus.iSecondUSimAppPin;
+			break;
+		case RMobilePhone::ELockUniversalPin:
+			lockInfo.iStatus=iSecStatus.iUniversalPin;
+			break;
+
+		case RMobilePhone::ELockNam:
+			iPhone->ReqCompleted(aTsyReqHandle,KErrNotSupported);
+			return KErrNone;	
+				
+//		Not supported!
+//		case RMobilePhone::ELockPhoneDevice:
+//		case RMobilePhone::ELockPhoneToIcc:
+//		case RMobilePhone::ELockPhoneToFirstIcc:
+//		case RMobilePhone::ELockOTA:
+		default:
+			iPhone->ReqCompleted(aTsyReqHandle,KErrNotSupported);
+			return KErrNone;
+		}
+
+	err = UpdateLockInfo(*aLock, lockInfo);
+	if(err)
+		{
+		iPhone->ReqCompleted(aTsyReqHandle,err);
+		return KErrNone;	
+		}
+
+	CompleteNotifyLockInfoChange(*aLock, lockInfo);		
+
+	iPhone->ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::SetLockSettingCancel(const TTsyReqHandle aReqHandle)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::GetSecurityCodeInfo(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TMobilePhoneSecurityCode* aSecurityCode,TDes8* aSecurityCodeInfo)
+/**
+Handle GetSecurityCodeInfo request
+
+@param aTsyReqHandle		TSY handle associated with this request
+@param aSecurityCode		Security code to get info on
+@param aSecurityCodeInfo	The TMobilePhoneSecurityCodeInfoV5 that will be populated with the
+							security code information
+@return KErrNone
+*/
+	{
+	RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg* securityCodeInfoPckg = 
+		reinterpret_cast<RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg*> (aSecurityCodeInfo);
+	RMobilePhone::TMobilePhoneSecurityCodeInfoV5& securityCodeInfo = (*securityCodeInfoPckg)();
+
+	// Check that the data structure is supported by the simulated TSY version
+	TInt err = iPhone->CheckSimTsyVersion(securityCodeInfo);
+	if(err != KErrNone)
+		{
+		iPhone->ReqCompleted(aTsyReqHandle, err);
+		return KErrNone;
+		}
+
+	switch(*aSecurityCode)
+		{
+		case RMobilePhone::ESecurityCodePin1:
+			securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPin1;
+			break;
+		case RMobilePhone::ESecurityCodePin2:
+			securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPin2;
+			break;
+		case RMobilePhone::ESecurityCodePuk1:
+			securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPuk1;
+			break;
+		case RMobilePhone::ESecurityCodePuk2:
+			securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPuk2;
+			break;
+		default:
+			iPhone->ReqCompleted(aTsyReqHandle,KErrNotFound);
+			return KErrNone;
+		}
+	iPhone->ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+	
+TInt CSimPhoneSecurity::GetSecurityCodeInfoCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+Retrieve a security code information
+
+@param aTsyReqHandle		TSY handle associated with this request
+@return KErrNone
+*/
+	{
+	iPhone->ReqCompleted(aTsyReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NotifySecurityCodeInfoChange(const TTsyReqHandle aTsyReqHandle, RMobilePhone::TMobilePhoneSecurityCode* aSecurityCode,TDes8* aSecurityCodeInfo)
+/**
+Record a client's interest in being notified when information of asecurity code changes.
+
+@param aTsyReqHandle		TSY handle associated with this request
+@param aSecurityCode		pointer that will be populated with the security code that changed
+@param aSecurityCodeInfo	The TMobilePhoneSecurityCodeInfoV5 that will be populated with the
+							security code information
+@return KErrNone
+*/
+	{
+	__ASSERT_ALWAYS(!iNotifySecurityCodeInfo.iNotifyPending,SimPanic(ENotificationAlreadyPending));
+
+	RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg* securityCodeInfoPckg = 
+		reinterpret_cast<RMobilePhone::TMobilePhoneSecurityCodeInfoV5Pckg*> (aSecurityCodeInfo);
+	RMobilePhone::TMobilePhoneSecurityCodeInfoV5& securityCodeInfo = (*securityCodeInfoPckg)();
+
+	// Check that the data structure is supported by the simulated TSY version
+	TInt err = iPhone->CheckSimTsyVersion(securityCodeInfo);
+	if(err != KErrNone)
+		{
+		iPhone->ReqCompleted(aTsyReqHandle, err);
+		return KErrNone;
+		}
+
+	iNotifySecurityCodeInfo.iNotifyPending=ETrue;
+	iNotifySecurityCodeInfo.iNotifyHandle=aTsyReqHandle;
+	iNotifySecurityCodeInfo.iNotifyData=&securityCodeInfo;
+	iNotifySecurityCodeInfo.iNotifyDataXtra=aSecurityCode;
+	return KErrNone;
+	}
+	
+TInt CSimPhoneSecurity::NotifySecurityCodeInfoChangeCancel(const TTsyReqHandle aReqHandle)
+/**
+Cancel a client's interest in being notified when the RMobileCall capabilities change.
+
+@param aTsyReqHandle		TSY handle associated with this request
+@return KErrNone
+*/
+	{
+	if(iNotifySecurityCodeInfo.iNotifyPending)
+		{
+		iNotifySecurityCodeInfo.iNotifyPending=EFalse;
+		iPhone->ReqCompleted(aReqHandle,KErrCancel);
+		return KErrNone;
+		}	
+	iPhone->ReqCompleted(aReqHandle,KErrNone);
+	return KErrNone;
+	}
+	
+TInt CSimPhoneSecurity::ChangeSecurityCode(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneSecurityCode* aType,const TDes8* aChange)
+	{
+	TPckg<RMobilePhone::TMobilePhonePasswordChangeV1>* passPckg= (TPckg<RMobilePhone::TMobilePhonePasswordChangeV1>*)aChange;
+	RMobilePhone::TMobilePhonePasswordChangeV1& pass = (*passPckg)();
+
+	// Check that the data structure is supported by the simulated TSY version
+	TInt err = iPhone->CheckSimTsyVersion(pass);
+	if(err != KErrNone)
+		{
+		iPhone->ReqCompleted(aReqHandle, err);
+		return KErrNone;
+		}
+
+	switch(*aType)
+		{
+		case RMobilePhone::ESecurityCodePin1:
+			if(iSecCodes.iPin1 == pass.iOldPassword)
+				{
+				iSecCodes.iPin1.Copy(pass.iNewPassword);
+				Pin1Success();
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Pin1Failure();
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecurityCodePin2:
+			if(iSecCodes.iPin2==pass.iOldPassword)
+				{
+				iSecCodes.iPin2.Copy(pass.iNewPassword);
+				Pin2Success();
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Pin2Failure();
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecurityCodePuk1:
+			if(iSecCodes.iPuk1==pass.iOldPassword)
+				{
+				iSecCodes.iPuk1.Copy(pass.iNewPassword);
+				Puk1Success();
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Puk1Failure();
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecurityCodePuk2:
+			if(iSecCodes.iPuk2==pass.iOldPassword)
+				{
+				iSecCodes.iPuk2.Copy(pass.iNewPassword);
+				Puk2Success();
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Puk2Failure();
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecurityHiddenKey:
+			if(iSecCodes.iPhBkHiddenKey==pass.iOldPassword)
+				iSecCodes.iPhBkHiddenKey.Copy(pass.iNewPassword);
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecurityUSIMAppPin:
+			if(iSecCodes.iUSimAppPin==pass.iOldPassword)
+				iSecCodes.iUSimAppPin.Copy(pass.iNewPassword);
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecuritySecondUSIMAppPin:
+			if(iSecCodes.iSecondUSimAppPin==pass.iOldPassword)
+				iSecCodes.iSecondUSimAppPin.Copy(pass.iNewPassword);
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+			break;
+		case RMobilePhone::ESecurityUniversalPin:
+			if(iSecCodes.iUniversalPin==pass.iOldPassword)
+				iSecCodes.iUniversalPin.Copy(pass.iNewPassword);
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+			break;
+	//  Not supported
+	//	case RMobilePhone::ESecurityCodePhonePassword:
+	//	case RMobilePhone::ESecurityCodeSPC:
+	
+		default:
+			iPhone->ReqCompleted(aReqHandle,KErrNotSupported);
+			return KErrNone;
+		}
+	iPhone->ReqCompleted(aReqHandle,KErrNone);
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::ChangeSecurityCodeCancel(const TTsyReqHandle aReqHandle)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+/*TInt CSimPhoneSecurity::UnlockNam(const TTsyReqHandle aReqHandle, const RMobilePhone::TMobilePassword* aSpc)
+	{
+	if(iSecStatus.iSPC==RMobilePhone::EStatusUnlocked)
+		{
+		iPhone->ReqCompleted(aReqHandle,KErrNotReady);
+		return KErrNone;
+		}	
+	else if(iSecCodes.iSPC==*aSpc)
+		{
+		iUnlockNamHandle = aReqHandle;
+		iUnlockNamTimer->Start(KNamTimeout,this,ETimerIdSecurityUnlockNam);
+		return KErrNone;
+		}
+	else
+		{
+		iPhone->ReqCompleted(aReqHandle,KErrAccessDenied);
+		return KErrNone;
+		}
+	}*/
+	
+void CSimPhoneSecurity::TimerCallBackUnlockNam()
+	{
+	SecurityEvent(RMobilePhone::ESPCVerified);
+	iPhone->ReqCompleted(iUnlockNamHandle,KErrNone);
+	}
+
+TInt CSimPhoneSecurity::UnlockNamCancel(const TTsyReqHandle aReqHandle)
+	{
+	iUnlockNamTimer->Cancel();
+	iPhone->ReqCompleted(aReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+void CSimPhoneSecurity::TimerCallBackLockNam()
+	{
+	LockSpc();
+	iPhone->ReqCompleted(iLockNamHandle,KErrNone);
+	}
+
+TInt CSimPhoneSecurity::LockNamCancel(const TTsyReqHandle aReqHandle)
+	{
+	iLockNamTimer->Cancel();
+	iPhone->ReqCompleted(aReqHandle,KErrCancel);
+	return KErrNone;
+	}
+
+
+TInt CSimPhoneSecurity::VerifySecurityCode(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneSecurityCode* aType, const RMobilePhone::TCodeAndUnblockCode* aCode)
+	{
+	switch(*aType)
+		{
+		case RMobilePhone::ESecurityCodePin1:
+			if(iSecCodes.iPin1==(*aCode).iCode)
+				{
+				SecurityEvent(RMobilePhone::EPin1Verified);
+				Pin1Success();
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Pin1Failure();
+				return KErrNone;
+				}
+		case RMobilePhone::ESecurityCodePin2:
+			if(iSecCodes.iPin2==(*aCode).iCode)
+				{
+				SecurityEvent(RMobilePhone::EPin2Verified);
+				Pin2Success();
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Pin2Failure();
+				return KErrNone;
+				}
+		case RMobilePhone::ESecurityCodePuk1:
+			if(iSecCodes.iPuk1==(*aCode).iUnblockCode)
+				{
+				SecurityEvent(RMobilePhone::EPuk1Verified);
+				Puk1Success();
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Puk1Failure();
+				return KErrNone;
+				}
+		case RMobilePhone::ESecurityCodePuk2:
+			if(iSecCodes.iPuk2==(*aCode).iUnblockCode)
+				{
+				SecurityEvent(RMobilePhone::EPuk2Verified);
+				Puk2Success();
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				Puk2Failure();
+				return KErrNone;
+				}
+		case RMobilePhone::ESecurityHiddenKey:
+			if(iSecCodes.iPhBkHiddenKey==(*aCode).iCode)
+				{
+				SecurityEvent(RMobilePhone::EHiddenKeyVerified);
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+		case RMobilePhone::ESecurityUSIMAppPin:
+			if(iSecCodes.iUSimAppPin==(*aCode).iCode)
+				{
+				SecurityEvent(RMobilePhone::EUSIMAppPinVerified);
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrAccessDenied);
+				return KErrNone;
+				}
+		case RMobilePhone::ESecuritySecondUSIMAppPin:
+			if(iSecCodes.iSecondUSimAppPin==(*aCode).iCode)
+				{
+				SecurityEvent(RMobilePhone::ESecondUSIMAppPinVerified);
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+		case RMobilePhone::ESecurityUniversalPin:
+			if(iSecCodes.iUniversalPin==(*aCode).iCode)
+				{
+				SecurityEvent(RMobilePhone::EUniversalPinVerified);
+				break;
+				}
+			else
+				{
+				iPhone->ReqCompleted(aReqHandle,KErrArgument);
+				return KErrNone;
+				}
+	//  Not supported
+	//	case RMobilePhone::ESecurityCodePhonePassword:
+	//	case RMobilePhone::ESecurityCodeSPC:
+	
+		default:
+			iPhone->ReqCompleted(aReqHandle,KErrNotSupported);
+			return KErrNone;
+		}
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::VerifySecurityCodeCancel(const TTsyReqHandle aReqHandle)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::AbortSecurityCode(const TTsyReqHandle aReqHandle, RMobilePhone::TMobilePhoneSecurityCode* /*aType*/)
+	{
+		iPhone->ReqCompleted(aReqHandle,KErrNone);
+		return KErrNone;
+	}
+
+
+TInt CSimPhoneSecurity::NotifySecurityEvent(const TTsyReqHandle aTsyReqHandle, TDes8* aPckg1)
+/**
+ * Registers a Client Interest in security event 
+ *
+ */
+	{
+	__ASSERT_ALWAYS(!iNotifyEvent.iNotifyPending,SimPanic(ENotificationReqAlreadyOutstanding));
+	
+	TPckg<TUint32>* eventPckg=(TPckg<TUint32>*)aPckg1;
+	TUint32& event=(*eventPckg)();
+
+	TInt count = iICCStatusProfile->Count();
+	
+	if (iNotifySecurityEventsTimer->iIndex < count)
+		{
+		TICCStatusEntry entry = iICCStatusProfile->At(iNotifySecurityEventsTimer->iIndex);
+		if(iNotifySecurityEventsTimer->iTimerStarted)
+			{
+			delete iNotifySecurityEventsTimer->iTimer;
+			iNotifySecurityEventsTimer->iTimer=NULL;
+			TRAPD(err,iNotifySecurityEventsTimer->iTimer=CSimTimer::NewL(iPhone));
+			if (err!=KErrNone)
+				{
+				return (err);
+				}
+			}
+		iNotifySecurityEventsTimer->iTimer->Start(entry.iDuration, this, ETimerIdSecurityNotifyEvent);
+		iNotifySecurityEventsTimer->iTimerStarted = ETrue;
+		}
+
+	iNotifyEvent.iNotifyPending=ETrue;
+	iNotifyEvent.iNotifyHandle=aTsyReqHandle;
+	iNotifyEvent.iNotifyData=&event;
+	
+	return KErrNone;
+	}
+
+TInt CSimPhoneSecurity::NotifySecurityEventCancel(const TTsyReqHandle aTsyReqHandle)
+/**
+ * De-registeres the client interest in security events
+ *
+ */
+	{
+	if(iNotifyEvent.iNotifyPending)
+		{
+		iNotifyEvent.iNotifyPending=EFalse;
+		iPhone->ReqCompleted(aTsyReqHandle, KErrCancel);
+		return KErrNone;
+		}
+	iPhone->ReqCompleted(aTsyReqHandle, KErrNone);
+	return KErrNone;
+	}
+
+
+void CSimPhoneSecurity::SecurityEvent(RMobilePhone::TMobilePhoneSecurityEvent aEvent)
+/** 
+ * Hanldes events related to the ICC state (locked/unlocked)
+ *
+ */
+	{
+	switch(aEvent)
+		{
+		case RMobilePhone::EPin1Required:
+			LockICC();		
+			break;
+		case  RMobilePhone::EPin1Verified:
+			UnLockICC();
+			break;
+		case RMobilePhone::EPin2Required:
+			LockPIN2();
+			break;
+		case RMobilePhone::EPin2Verified:
+			UnLockPIN2();
+			break;
+		case RMobilePhone::EHiddenKeyRequired:
+			HideEntries();
+			break;
+		case RMobilePhone::EHiddenKeyVerified:
+			ShowHidden();
+			break;
+		case RMobilePhone::ESPCVerified:
+			 return;
+				
+		case RMobilePhone::ESPCRequired:
+			return;
+		case RMobilePhone::ENoICCFound:
+		case RMobilePhone::EICCTerminated:
+		case RMobilePhone::EPhonePasswordRequired:
+		case RMobilePhone::EPhonePasswordVerified:
+		case RMobilePhone::ESecondUSIMAppPinRequired:
+		case RMobilePhone::ESecondUSIMAppPinVerified:
+		case RMobilePhone::EUniversalPinRequired:
+		case RMobilePhone::EUniversalPinVerified:
+			return;
+		
+		case RMobilePhone::EUSIMAppPinRequired:
+		case RMobilePhone::EUSIMAppPinVerified:			
+			break;
+
+		case RMobilePhone::ESPCChanged:
+			//  FALLTHRU
+		default:
+			LOGPHONE4("CSimPhoneSecurity::SecurityEvent %d OOR [%d,%d]",
+					aEvent, RMobilePhone::ENoICCFound, RMobilePhone::ESPCChanged);
+			return;
+		}
+	
+	if(iNotifyEvent.iNotifyPending)
+		{
+		iNotifyEvent.iNotifyPending=EFalse;
+		*(RMobilePhone::TMobilePhoneSecurityEvent*)iNotifyEvent.iNotifyData=aEvent;
+		iPhone->ReqCompleted(iNotifyEvent.iNotifyHandle, KErrNone);
+		}
+	}
+
+void CSimPhoneSecurity::TimerCallBack(TInt aId)
+/**
+ * The timer callback function.  This function will be called when the timer
+ * completes.  It indicates a change in ICC state.  So, the new
+ * ICC state settings must be loaded into the member variables representing
+ * the current settings   Finally, the next timer is started.
+ *
+ * @param aId	This parameter is unused.  It is only required for CSimXxx classes
+ *				that have more than one timer instance and need to identify which
+ *				timer has expired.
+ */
+	{
+	if(aId == ETimerIdSecurityNotifyEvent)
+		{
+		if((iNotifySecurityEventsTimer->iIndex < iICCStatusProfile->Count()) && iNotifyEvent.iNotifyPending)
+			{
+			TICCStatusEntry entry = iICCStatusProfile->At(iNotifySecurityEventsTimer->iIndex);
+			SecurityEvent(entry.iICCStatus);
+			iNotifySecurityEventsTimer->iIndex++;
+			}
+		}
+	else if(aId == ETimerIdSecurityNotifyLockInfo)
+		{
+		if((iNotifySettingsTimer->iIndex < iICCSettingProfile->Count()) &&	iNotifyLock.iNotifyPending)
+			{
+			TICCSettingEntry entry = iICCSettingProfile->At(iNotifySettingsTimer->iIndex);
+			UpdateLockInfo(entry.iLock, entry.iLockInfo);
+			iNotifySettingsTimer->iIndex++;
+			iNotifySettingsTimer->iTimerStarted = EFalse;
+			CompleteNotifyLockInfoChange(entry.iLock, entry.iLockInfo);			
+			}
+		}
+
+	}
+
+TBool CSimPhoneSecurity::IsICCLocked()
+	{
+	if((iSecStatus.iPin1==RMobilePhone::EStatusLocked) &&
+	   (iSecSetting.iPin1==RMobilePhone::ELockSetEnabled)) 
+			return ETrue;
+	
+	 return EFalse;
+	}
+	
+TBool CSimPhoneSecurity::IsPIN2Locked()
+	{
+	if((iSecStatus.iPin2==RMobilePhone::EStatusLocked) &&
+	   (iSecSetting.iPin2==RMobilePhone::ELockSetEnabled)) 
+			return ETrue;
+	
+	 return EFalse;
+	}	
+
+void CSimPhoneSecurity::LockICC()
+	{
+	iSecStatus.iPin1=RMobilePhone::EStatusLocked;
+	return;
+	}
+
+void CSimPhoneSecurity::UnLockICC()
+	{
+	iSecStatus.iPin1=RMobilePhone::EStatusUnlocked;
+	return;
+	}
+	
+void CSimPhoneSecurity::LockPIN2()
+	{
+	iSecStatus.iPin2=RMobilePhone::EStatusLocked;
+	return;
+	}
+
+void CSimPhoneSecurity::UnLockPIN2()
+	{
+	iSecStatus.iPin2=RMobilePhone::EStatusUnlocked;
+	return;
+	}
+
+TBool CSimPhoneSecurity::IsHiddenEnabled()
+	{
+	if((iSecStatus.iPhBkHiddenKey==RMobilePhone::EStatusLocked) &&
+	   (iSecSetting.iPhBkHiddenKey==RMobilePhone::ELockSetEnabled)) 
+		return ETrue;
+	
+	 return EFalse;
+	}
+
+void CSimPhoneSecurity::HideEntries()
+	{
+	iSecStatus.iPhBkHiddenKey=RMobilePhone::EStatusLocked;
+	return;
+	}
+
+void CSimPhoneSecurity::ShowHidden()
+	{
+	iSecStatus.iPhBkHiddenKey=RMobilePhone::EStatusUnlocked;
+	return;
+	}
+	
+void CSimPhoneSecurity::LockSpc()
+	{
+	if (iNotifyLock.iNotifyPending)
+		{
+		// there is a notification waiting
+		RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+
+		lockInfo.iStatus = RMobilePhone::EStatusLocked;
+		lockInfo.iSetting = RMobilePhone::ELockSetEnabled;
+		CompleteNotifyLockInfoChange(RMobilePhone::ELockNam, lockInfo);
+		}
+	iSecStatus.iSPC=RMobilePhone::EStatusLocked;
+	return;
+	}
+
+void CSimPhoneSecurity::UnLockSpc()
+	{
+	if (iNotifyLock.iNotifyPending)
+		{
+		RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+
+		lockInfo.iStatus = RMobilePhone::EStatusUnlocked;
+		lockInfo.iSetting = RMobilePhone::ELockSetEnabled;
+		// there is a notification waiting
+		CompleteNotifyLockInfoChange(RMobilePhone::ELockNam, lockInfo);
+		}
+	iSecStatus.iSPC=RMobilePhone::EStatusUnlocked;
+	return;
+	}
+
+CSimPhoneSecurity::CIccTimer::CIccTimer()
+	: iTimerStarted(EFalse)
+	, iIndex(0)
+	, iTimer(NULL)
+	{
+	}
+
+CSimPhoneSecurity::CIccTimer::~CIccTimer()
+	{
+	if(iTimer)
+		iTimer->Cancel();
+	delete iTimer; 
+	}
+	
+CSimPhoneSecurity::CIccTimer* CSimPhoneSecurity::CIccTimer::NewL()
+	{
+	CSimPhoneSecurity::CIccTimer* self = new(ELeave)CSimPhoneSecurity::CIccTimer;
+	return self;
+	}
+	
+TInt CSimPhoneSecurity::UpdateLockInfo(RMobilePhone::TMobilePhoneLock aLock, const RMobilePhone::TMobilePhoneLockInfoV1& aLockInfo)
+	{
+	TInt err = KErrNone;
+	switch(aLock)
+		{
+		case RMobilePhone::ELockICC:
+			iSecSetting.iPin1 = aLockInfo.iSetting;	
+			iSecStatus.iPin1 = aLockInfo.iStatus;	
+			break;
+		case RMobilePhone::ELockPin2:
+			iSecSetting.iPin2 = aLockInfo.iSetting;
+			iSecStatus.iPin2 = aLockInfo.iStatus;	
+			break;
+		case RMobilePhone::ELockHiddenKey:
+			iSecSetting.iPhBkHiddenKey = aLockInfo.iSetting;
+			iSecStatus.iPhBkHiddenKey = aLockInfo.iStatus;	
+			break;
+		case RMobilePhone::ELockUSimApp:
+			iSecSetting.iUSimAppPin = aLockInfo.iSetting;
+			iSecStatus.iUSimAppPin = aLockInfo.iStatus;	
+			break;
+		case RMobilePhone::ELockSecondUSimApp:
+			iSecSetting.iSecondUSimAppPin = aLockInfo.iSetting;
+			iSecStatus.iSecondUSimAppPin = aLockInfo.iStatus;	
+			break;
+		case RMobilePhone::ELockUniversalPin:
+			iSecSetting.iUniversalPin = aLockInfo.iSetting;
+			iSecStatus.iUniversalPin = aLockInfo.iStatus;	
+			break;
+
+		case RMobilePhone::ELockNam:
+			err = KErrNotSupported;	
+		
+			break;
+
+//		Not supported!
+//		case RMobilePhone::ELockPhoneDevice:
+//		case RMobilePhone::ELockPhoneToIcc:
+//		case RMobilePhone::ELockPhoneToFirstIcc:
+//		case RMobilePhone::ELockOTA:
+		
+		default:
+			err = KErrNotSupported;	
+		}
+	return err;
+	}
+
+void CSimPhoneSecurity::Pin1Failure()
+/**
+Handle wrong PIN1 entry. Decrement the entry counter, lock the corresponding lock after the maximum 
+of entry. Complete the Security Code Info Change Notification if the counter has changed
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPin1 > 0)
+		{
+		iSecurityCodeRemainigAttempts.iPin1--;
+		if (iSecurityCodeRemainigAttempts.iPin1 == 0)
+			{
+			iSecStatus.iPin1 = RMobilePhone::EStatusBlocked;
+			RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+
+			lockInfo.iSetting = iSecSetting.iPin1;
+			lockInfo.iStatus = iSecStatus.iPin1;
+			CompleteNotifyLockInfoChange(RMobilePhone::ELockICC,lockInfo);
+			}
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPin1;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePin1,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Pin1Success()
+/**
+Handle correct PIN1 entry. if require, Reset the entry counter and complete the Security Code Info 
+Change Notification.
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPin1 <  iSecurityCodeDefaultRemainigAttempts.iPin1)
+		{
+		iSecurityCodeRemainigAttempts.iPin1 = iSecurityCodeDefaultRemainigAttempts.iPin1;
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPin1;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePin1,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Pin2Failure()
+/**
+Handle wrong PIN2 entry. Decrement the entry counter, lock the corresponding lock after the maximum 
+of entry. Complete the Security Code Info Change Notification if the counter has changed
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPin2 > 0)
+		{
+		iSecurityCodeRemainigAttempts.iPin2--;
+		if (iSecurityCodeRemainigAttempts.iPin2 == 0)
+			{
+			iSecStatus.iPin2 = RMobilePhone::EStatusBlocked;
+			RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+
+			lockInfo.iSetting = iSecSetting.iPin2;
+			lockInfo.iStatus = iSecStatus.iPin2;
+			CompleteNotifyLockInfoChange(RMobilePhone::ELockPin2,lockInfo);
+			}
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPin2;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePin2,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Pin2Success()
+/**
+Handle correct PIN2 entry. if require, Reset the entry counter and complete the Security Code Info 
+Change Notification.
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPin2 <  iSecurityCodeDefaultRemainigAttempts.iPin2)
+		{
+		iSecurityCodeRemainigAttempts.iPin2 = iSecurityCodeDefaultRemainigAttempts.iPin2;
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPin2;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePin2,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Puk1Failure()
+/**
+Handle wrong PUK1 entry. Decrement the entry counter. Complete the Security Code Info Change Notification 
+if the counter has changed
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPuk1 > 0)
+		{
+		iSecurityCodeRemainigAttempts.iPuk1--;
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPuk1;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePuk1,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Puk1Success()
+/**
+Handle correct PUK1 entry. if require, Reset the entry counter and complete the Security Code Info 
+Change Notification.
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPuk1 <  iSecurityCodeDefaultRemainigAttempts.iPuk1)
+		{
+		iSecurityCodeRemainigAttempts.iPuk1 = iSecurityCodeDefaultRemainigAttempts.iPuk1;
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPuk1;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePuk1,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Puk2Failure()
+/**
+Handle wrong PUK2 entry. Decrement the entry counter. Complete the Security Code Info Change Notification 
+if the counter has changed
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPuk2 > 0)
+		{
+		iSecurityCodeRemainigAttempts.iPuk2--;
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPuk2;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePuk2,securityCodeInfo);
+		}
+	}
+
+void CSimPhoneSecurity::Puk2Success()
+/**
+Handle correct PUK2 entry. if require, Reset the entry counter and complete the Security Code Info 
+Change Notification.
+*/
+	{
+	if (iSecurityCodeRemainigAttempts.iPuk2 <  iSecurityCodeDefaultRemainigAttempts.iPuk2)
+		{
+		iSecurityCodeRemainigAttempts.iPuk2 = iSecurityCodeDefaultRemainigAttempts.iPuk2;
+		RMobilePhone::TMobilePhoneSecurityCodeInfoV5 securityCodeInfo;
+		// Simulated version checking is omitted in this case - function is called after a ReqCompleted
+
+		securityCodeInfo.iRemainingEntryAttempts = iSecurityCodeRemainigAttempts.iPuk2;
+		CompleteNotifySecurityCodeInfoChange(RMobilePhone::ESecurityCodePuk2,securityCodeInfo);
+		}
+	}
+	
+void CSimPhoneSecurity::CompleteNotifyLockInfoChange(RMobilePhone::TMobilePhoneLock aLock, const RMobilePhone::TMobilePhoneLockInfoV1& aLockInfo)
+	{
+	if (iNotifyLock.iNotifyPending)
+		{
+		*(RMobilePhone::TMobilePhoneLockInfoV1*)iNotifyLock.iNotifyData=aLockInfo;
+		*(RMobilePhone::TMobilePhoneLock*)iNotifyLock.iNotifyDataXtra=aLock;
+		iNotifyLock.iNotifyPending=EFalse;
+		iPhone->ReqCompleted(iNotifyLock.iNotifyHandle,KErrNone);
+		}
+	}
+
+void CSimPhoneSecurity::CompleteNotifySecurityCodeInfoChange(RMobilePhone::TMobilePhoneSecurityCode aSecurityCode, const RMobilePhone::TMobilePhoneSecurityCodeInfoV5& aSecurityCodeInfo)
+/**
+Complete a Security code info notification if pending.
+
+@param aSecurityCode 		security code that must be notified
+@param aSecurityCodeInfo	security code information for the notification
+*/
+	{
+	if (iNotifySecurityCodeInfo.iNotifyPending)
+		{
+		*reinterpret_cast<RMobilePhone::TMobilePhoneSecurityCodeInfoV5*>(iNotifySecurityCodeInfo.iNotifyData)=aSecurityCodeInfo;
+		*reinterpret_cast<RMobilePhone::TMobilePhoneSecurityCode*>(iNotifySecurityCodeInfo.iNotifyDataXtra)=aSecurityCode;
+		iNotifySecurityCodeInfo.iNotifyPending=EFalse;
+		iPhone->ReqCompleted(iNotifySecurityCodeInfo.iNotifyHandle,KErrNone);
+		}
+	}
+