--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserverplugins/ctsydispatchlayer/src/csecuritydispatcher.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,860 @@
+// 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:
+//
+
+#include <ctsy/rmmcustomapi.h>
+#include "csecuritydispatcher.h"
+
+#include <ctsy/ltsy/mltsydispatchsecurityinterface.h>
+#include <ctsy/pluginapi/mmmessagemanagercallback.h>
+#include <ctsy/serviceapi/mmtsy_ipcdefs.h>
+#include <ctsy/serviceapi/cmmutility.h>
+
+#include <ctsy/ltsy/ltsylogger.h>
+#include "ctsydispatcherpanic.h"
+#include "tdispatcherholder.h"
+
+CSecurityDispatcher::CSecurityDispatcher(
+		MLtsyDispatchFactoryV1& aLtsyFactory,
+		MmMessageManagerCallback& aMessageManagerCallback,
+		CRequestQueueOneShot& aRequestAsyncOneShot)
+	: 	iLtsyFactoryV1(aLtsyFactory),
+		iMessageManagerCallback(aMessageManagerCallback),
+		iRequestAsyncOneShot(aRequestAsyncOneShot)
+	{
+	} // CSecurityDispatcher::CSecurityDispatcher
+
+	  
+CSecurityDispatcher::~CSecurityDispatcher()
+	{
+	} // CSecurityDispatcher::~CSecurityDispatcher
+
+
+CSecurityDispatcher* CSecurityDispatcher::NewLC(
+	MLtsyDispatchFactoryV1& aLtsyFactory,
+	MmMessageManagerCallback& aMessageManagerCallback,
+	CRequestQueueOneShot& aRequestAsyncOneShot)
+	{
+	TSYLOGENTRYEXIT;
+	CSecurityDispatcher* self =
+		new (ELeave) CSecurityDispatcher(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	return self;
+	} // CSecurityDispatcher::NewLC
+
+
+CSecurityDispatcher* CSecurityDispatcher::NewL(
+	MLtsyDispatchFactoryV1& aLtsyFactory,
+	MmMessageManagerCallback& aMessageManagerCallback,
+	CRequestQueueOneShot& aRequestAsyncOneShot)
+	{
+	TSYLOGENTRYEXIT;
+	CSecurityDispatcher* self =
+		CSecurityDispatcher::NewLC(aLtsyFactory, aMessageManagerCallback, aRequestAsyncOneShot);
+	CleanupStack::Pop (self);
+	return self;
+	} // CSecurityDispatcher::NewL
+
+
+void CSecurityDispatcher::ConstructL()
+/**
+ * Second phase constructor.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	// Get the Licensee LTSY interfaces related to Security functionality
+	// from the factory
+	
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId))
+		{
+		TAny* getSecurityCodeInfoInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecurityGetSecurityCodeInfo::KLtsyDispatchSecurityGetSecurityCodeInfoApiId,
+		       	getSecurityCodeInfoInterface);
+		iLtsyDispatchSecurityGetSecurityCodeInfo =
+				static_cast<MLtsyDispatchSecurityGetSecurityCodeInfo*>(getSecurityCodeInfoInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityGetSecurityCodeInfo, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId))
+		{
+		TAny* getLockInfoInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecurityGetLockInfo::KLtsyDispatchSecurityGetLockInfoApiId,
+		       	getLockInfoInterface);
+		iLtsyDispatchSecurityGetLockInfo =
+				static_cast<MLtsyDispatchSecurityGetLockInfo*>(getLockInfoInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityGetLockInfo, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId))
+		{
+		TAny* abortSecurityCodeInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecurityAbortSecurityCode::KLtsyDispatchSecurityAbortSecurityCodeApiId,
+		       	abortSecurityCodeInterface);
+		iLtsyDispatchSecurityAbortSecurityCode =
+				static_cast<MLtsyDispatchSecurityAbortSecurityCode*>(abortSecurityCodeInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityAbortSecurityCode, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId))
+		{
+		TAny* getCurrentActivePinInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecurityGetCurrentActivePin::KLtsyDispatchSecurityGetCurrentActivePinApiId,
+		       	getCurrentActivePinInterface);
+		iLtsyDispatchSecurityGetCurrentActivePin =
+				static_cast<MLtsyDispatchSecurityGetCurrentActivePin*>(getCurrentActivePinInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityGetCurrentActivePin, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId))
+		{
+		TAny* setLockSettingInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecuritySetLockSetting::KLtsyDispatchSecuritySetLockSettingApiId,
+		       	setLockSettingInterface);
+		iLtsyDispatchSecuritySetLockSetting =
+				static_cast<MLtsyDispatchSecuritySetLockSetting*>(setLockSettingInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecuritySetLockSetting, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId))
+		{
+		TAny* verifySecurityCodeInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecurityVerifySecurityCode::KLtsyDispatchSecurityVerifySecurityCodeApiId,
+		       	verifySecurityCodeInterface);
+		iLtsyDispatchSecurityVerifySecurityCode =
+				static_cast<MLtsyDispatchSecurityVerifySecurityCode*>(verifySecurityCodeInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityVerifySecurityCode, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityGetPin1DisableSupported::KLtsyDispatchSecurityGetPin1DisableSupportedApiId))
+		{
+		TAny* getPin1DisableSupportedInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+		       	MLtsyDispatchSecurityGetPin1DisableSupported::KLtsyDispatchSecurityGetPin1DisableSupportedApiId,
+		       	getPin1DisableSupportedInterface);
+		iLtsyDispatchSecurityGetPin1DisableSupported =
+			static_cast<MLtsyDispatchSecurityGetPin1DisableSupported*>(getPin1DisableSupportedInterface);
+  		__ASSERT_DEBUG(iLtsyDispatchSecurityGetPin1DisableSupported, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+  		
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId))
+		{
+		TAny* checkSecurityCodeInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+				MLtsyDispatchSecurityCheckSecurityCode::KLtsyDispatchSecurityCheckSecurityCodeApiId,
+		       	checkSecurityCodeInterface);
+		iLtsyDispatchSecurityCheckSecurityCode =
+				static_cast<MLtsyDispatchSecurityCheckSecurityCode*>(checkSecurityCodeInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityCheckSecurityCode, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId))
+		{
+		TAny* disablePhoneLockInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+				MLtsyDispatchSecurityDisablePhoneLock::KLtsyDispatchSecurityDisablePhoneLockApiId,
+		       	disablePhoneLockInterface);
+		iLtsyDispatchSecurityDisablePhoneLock =
+				static_cast<MLtsyDispatchSecurityDisablePhoneLock*>(disablePhoneLockInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityDisablePhoneLock, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId))
+		{
+		TAny* getCipheringInfoInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+				MLtsyDispatchSecurityGetCipheringInfo::KLtsyDispatchSecurityGetCipheringInfoApiId,
+		       	getCipheringInfoInterface);
+		iLtsyDispatchSecurityGetCipheringInfo =
+				static_cast<MLtsyDispatchSecurityGetCipheringInfo*>(getCipheringInfoInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityGetCipheringInfo, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId))
+		{
+		TAny* isSecurityCodeBlockedInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+				MLtsyDispatchSecurityIsSecurityCodeBlocked::KLtsyDispatchSecurityIsSecurityCodeBlockedApiId,
+		       	isSecurityCodeBlockedInterface);
+		iLtsyDispatchSecurityIsSecurityCodeBlocked =
+				static_cast<MLtsyDispatchSecurityIsSecurityCodeBlocked*>(isSecurityCodeBlockedInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityIsSecurityCodeBlocked, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	
+	if(iLtsyFactoryV1.IsDispatchInterfaceSupported(KDispatchSecurityFuncUnitId, MLtsyDispatchSecurityCheckSecurityCodeCancel::KLtsyDispatchSecurityCheckSecurityCodeCancelApiId))
+		{
+		TAny* checkSecurityCodeCancelInterface = NULL;
+		iLtsyFactoryV1.GetDispatchHandler(
+				MLtsyDispatchSecurityCheckSecurityCodeCancel::KLtsyDispatchSecurityCheckSecurityCodeCancelApiId,
+		       	checkSecurityCodeCancelInterface);
+		iLtsyDispatchSecurityCheckSecurityCodeCancel =
+				static_cast<MLtsyDispatchSecurityCheckSecurityCodeCancel*>(checkSecurityCodeCancelInterface);
+        __ASSERT_DEBUG(iLtsyDispatchSecurityCheckSecurityCodeCancel, CtsyDispatcherPanic(EInvalidNullPtr));
+  		}
+	  		
+	} // CSecurityDispatcher::ConstructL
+
+void CSecurityDispatcher::SetDispatcherHolder(TDispatcherHolder& aDispatcherHolder)
+/**
+ * Set the dispatcher holder.  
+ * 
+ * @param aDispatcherHolder Reference to dispatcher holder.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	iDispatcherHolder = &aDispatcherHolder;
+	} // CSecurityDispatcher::SetDispatcherHolder
+
+TInt CSecurityDispatcher::DispatchGetSecurityCodeInfoL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneGetSecurityCodeInfo
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+   
+    __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityGetSecurityCodeInfo)
+		{
+		RMobilePhone::TMobilePhoneSecurityCode secCode;
+		aDataPackage->UnPackData(secCode);
+		ret = iLtsyDispatchSecurityGetSecurityCodeInfo->HandleGetSecurityCodeInfoReqL(secCode);				
+		}		
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchGetSecurityCodeInfoL
+
+TInt CSecurityDispatcher::DispatchGetLockInfoL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneGetLockInfo
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+    __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityGetLockInfo)
+		{
+		RMobilePhone::TMobilePhoneLock lockType;
+		aDataPackage->UnPackData(lockType);
+		ret = iLtsyDispatchSecurityGetLockInfo->HandleGetLockInfoReqL(lockType);				
+		}
+			
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchGetLockInfoL
+
+TInt CSecurityDispatcher::DispatchAbortSecurityCodeL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneAbortSecurityCode
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+   __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityAbortSecurityCode)
+		{
+		RMobilePhone::TMobilePhoneSecurityCode secCode;
+		aDataPackage->UnPackData(secCode);
+		ret = iLtsyDispatchSecurityAbortSecurityCode->HandleAbortSecurityCodeReqL(secCode);				
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchAbortSecurityCodeL
+
+TInt CSecurityDispatcher::DispatchGetCurrentActivePinL()
+/**
+ * Pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Call Handle... method in Licensee LTSY
+	
+	if (iLtsyDispatchSecurityGetCurrentActivePin)
+		{
+		ret = iLtsyDispatchSecurityGetCurrentActivePin->HandleGetCurrentActivePinReqL();
+		}
+	 	 
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchGetCurrentActivePinL
+
+TInt CSecurityDispatcher::DispatchSetLockSettingL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneSetLockSetting
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+    __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecuritySetLockSetting)
+		{
+		TLockAndSetting* lockAndSetting = NULL;
+		RMobilePhone::TMobilePassword* mobilePassword = NULL;
+		aDataPackage->UnPackData(&lockAndSetting,&mobilePassword);
+		
+		//these should never be NULL
+		__ASSERT_DEBUG(lockAndSetting, CtsyDispatcherPanic(EInvalidNullPtr));
+		__ASSERT_DEBUG(lockAndSetting->iLock, CtsyDispatcherPanic(EInvalidNullPtr));
+		__ASSERT_DEBUG(lockAndSetting->iSetting, CtsyDispatcherPanic(EInvalidNullPtr));
+		
+		//mobile password maybe null, as the CTSY has not packed one, if so pass 
+		//down a reference to a null descriptor
+		//ternary operator used so that KNullDesC does not have to have its const cast away
+		const TDesC* mobilePasswordPtr = mobilePassword ? mobilePassword : &KNullDesC;
+
+		ret = iLtsyDispatchSecuritySetLockSetting->HandleSetLockSettingReqL(*(lockAndSetting->iLock),*(lockAndSetting->iSetting),*mobilePasswordPtr);				
+		}		
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchSetLockSettingL
+
+TInt CSecurityDispatcher::DispatchVerifySecurityCodeL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to EMobilePhoneVerifySecurityCode
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+    __ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityVerifySecurityCode)
+		{
+		//sec code also has to be unpacked as a pointer due to CMmDataPackage's
+		RMobilePhone::TMobilePhoneSecurityCode* secCode = NULL;
+		RMobilePhone::TCodeAndUnblockCode* codes = NULL;
+		aDataPackage->UnPackData(&secCode, &codes);
+			
+		//should never be NULL
+		__ASSERT_DEBUG(codes, CtsyDispatcherPanic(EInvalidNullPtr));
+		__ASSERT_DEBUG(secCode, CtsyDispatcherPanic(EInvalidNullPtr));
+			
+		ret = iLtsyDispatchSecurityVerifySecurityCode->HandleVerifySecurityCodeReqL(*secCode, *codes);
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchVerifySecurityCodeL
+
+TInt CSecurityDispatcher::DispatchGetPin1DisableSupportedL()
+/**
+ * Pass request on to Licensee LTSY.
+ * 
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityGetPin1DisableSupported)
+		{
+		ret = iLtsyDispatchSecurityGetPin1DisableSupported->HandleGetPin1DisableSupportedReqL();
+		}
+			
+	return TSYLOGSETEXITERR(ret);	
+	} // CPhoneDispatcher::DispatchGetPin1DisableSupportedL
+	
+TInt CSecurityDispatcher::DispatchCheckSecurityCodeL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to ECustomCheckSecurityCodeIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));	
+
+	// Call Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityCheckSecurityCode)
+		{
+		TUint8* codeID = NULL;
+		RMobilePhone::TMobilePassword* secCode = NULL;
+		aDataPackage->UnPackData(&codeID, &secCode);
+			
+		__ASSERT_DEBUG(codeID, CtsyDispatcherPanic(EInvalidNullPtr));	
+		__ASSERT_DEBUG(secCode, CtsyDispatcherPanic(EInvalidNullPtr));	
+			
+		DispatcherSecurity::TSecurityCodeId secCodeId = static_cast<DispatcherSecurity::TSecurityCodeId> (*codeID);
+		ret = iLtsyDispatchSecurityCheckSecurityCode->HandleCheckSecurityCodeReqL(secCodeId, *secCode);
+		}	
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchCheckSecurityCodeL
+
+TInt CSecurityDispatcher::DispatchDisablePhoneLockL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to ECustomDisablePhoneLockIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));		
+
+	// Can Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityDisablePhoneLock)
+		{		
+		RMobilePhone::TMobilePassword* secCode = NULL;
+		aDataPackage->UnPackData(&secCode);
+		__ASSERT_DEBUG(secCode, CtsyDispatcherPanic(EInvalidNullPtr));
+			
+		ret = iLtsyDispatchSecurityDisablePhoneLock->HandleDisablePhoneLockReqL(*secCode);			
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchDisablePhoneLockL
+
+TInt CSecurityDispatcher::DispatchGetCipheringInfoL()
+/**
+ * Pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+
+	// Can Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityGetCipheringInfo)
+		{
+		ret = iLtsyDispatchSecurityGetCipheringInfo->HandleGetCipheringInfoReqL();
+		}
+
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchGetCipheringInfoL
+
+TInt CSecurityDispatcher::DispatchIsSecurityCodeBlockedL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to ECustomIsBlockedIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));			
+
+	// Can Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityIsSecurityCodeBlocked)
+		{
+		TUint8 codeID;
+		aDataPackage->UnPackData(codeID);
+		DispatcherSecurity::TSecurityCodeId secCodeId = static_cast<DispatcherSecurity::TSecurityCodeId> (codeID);
+		ret = iLtsyDispatchSecurityIsSecurityCodeBlocked->HandleIsSecurityCodeBlockedReqL(secCodeId);			
+		}
+		
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchIsSecurityCodeBlockedL
+
+TInt CSecurityDispatcher::DispatchCheckSecurityCodeCancelL(const CMmDataPackage* aDataPackage)
+/**
+ * Unpack data related to ECustomCheckSecurityCodeCancelIPC
+ * and pass request on to Licensee LTSY.
+ *
+ * @return Returns error code returned by the Licensee LTSY or KErrNotSupported if
+ * the Licensee LTSY does not support this request.
+ */
+	{
+	TSYLOGENTRYEXIT;
+	TInt ret = KErrNotSupported;
+	
+	__ASSERT_DEBUG(aDataPackage, CtsyDispatcherPanic(EInvalidNullPtr));		
+
+	// Can Handle... method in Licensee LTSY
+	if (iLtsyDispatchSecurityCheckSecurityCodeCancel)
+		{
+		TUint8 codeID;
+		TBool flag; // it will not be sent to the LTSY
+		aDataPackage->UnPackData(codeID, flag);
+		DispatcherSecurity::TSecurityCodeId secCodeId = static_cast<DispatcherSecurity::TSecurityCodeId> (codeID);
+		ret = iLtsyDispatchSecurityCheckSecurityCodeCancel->HandleCheckSecurityCodeCancelReqL(secCodeId);			
+		}
+	
+	return TSYLOGSETEXITERR(ret);
+	} // CSecurityDispatcher::DispatchCheckSecurityCodeCancelL
+
+
+//
+// Callback handlers follow
+//
+
+
+
+void CSecurityDispatcher::CallbackBootNotifySecurityReady(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityBootNotifySecurityReadyInd()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+	
+	iMessageManagerCallback.Complete(EMmTsyBootNotifySecurityReadyIPC, aError);
+	
+	} // CSecurityDispatcher::CallbackBootNotifySecurityReady
+
+void CSecurityDispatcher::CallbackNotifySecurityEvent(TInt aError, RMobilePhone::TMobilePhoneSecurityEvent aSecEvent)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityNotifySecurityEventInd()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aSecEvent Security event.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aSecEvent=%d"), aError, aSecEvent);
+
+	CMmDataPackage dataPackage;		
+	dataPackage.PackData(&aSecEvent);			             
+	
+	iMessageManagerCallback.Complete(EMobilePhoneNotifySecurityEvent, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackNotifySecurityEvent
+
+void CSecurityDispatcher::CallbackNotifyLockInfoChange(TInt aError,
+				RMobilePhone::TMobilePhoneLockStatus aStatus, RMobilePhone::TMobilePhoneLockSetting aSetting, RMobilePhone::TMobilePhoneLock aLock)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityNotifyLockInfoChangeInd()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aStatus Status of the lock (unknown, locked, unlocked or blocked).
+ * @param aSetting Lock setting (unknown, enabled, disabled or replaced).
+ * @param aLock Lock information.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aStatus=%d, aSetting=%d, aLock=%d"), 
+			                 aError, aStatus, aSetting, aLock);
+
+    RMobilePhone::TMobilePhoneLockInfoV1 lockInfo;
+    lockInfo.iStatus = aStatus;
+    lockInfo.iSetting = aSetting;
+	CMmDataPackage dataPackage;		
+	dataPackage.PackData(&lockInfo, &aLock);			             
+	
+	iMessageManagerCallback.Complete(EMobilePhoneNotifyLockInfoChange, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackNotifyLockInfoChange
+
+void CSecurityDispatcher::CallbackGetSecurityCodeInfo(TInt aError,
+				RMobilePhone::TMobilePhoneSecurityCode aSecCode, TInt aRemainingEntryAttempts)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityGetSecurityCodeInfoComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aSecCode Security code.
+ * @param aRemainingEntryAttempts Number of remaining security code entry attempts before the corresponding lock gets blocked.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aSecCode=%d, aRemainingEntryAttempts=%d"), aError, aSecCode, aRemainingEntryAttempts);
+
+	RMobilePhone::TMobilePhoneSecurityCodeInfoV5 codeInfo;
+    codeInfo.iRemainingEntryAttempts = aRemainingEntryAttempts;
+	CMmDataPackage dataPackage;		
+	dataPackage.PackData(&aSecCode, &codeInfo);			             
+	
+	iMessageManagerCallback.Complete(EMobilePhoneGetSecurityCodeInfo, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackGetSecurityCodeInfo
+
+void CSecurityDispatcher::CallbackGetLockInfo(TInt aError,
+				RMobilePhone::TMobilePhoneLockStatus aLockStatus, RMobilePhone::TMobilePhoneLockSetting aLockSetting)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityGetLockInfoComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aLockStatus Lock status (unknown, locked, unlocked or blocked).
+ * @param aLockSetting Lock setting (unknown, enabled, disabled or replaced).
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aLockStatus=%d, aLockSetting=%d"), aError, aLockStatus, aLockSetting);
+
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aLockStatus, &aLockSetting);
+		
+	iMessageManagerCallback.Complete(EMobilePhoneGetLockInfo, &dataPackage,  aError);
+	
+	} // CSecurityDispatcher::CallbackGetLockInfo
+
+void CSecurityDispatcher::CallbackAbortSecurityCode(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityAbortSecurityCodeComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	iMessageManagerCallback.Complete(EMobilePhoneAbortSecurityCode, aError);
+	
+	} // CSecurityDispatcher::CallbackAbortSecurityCode
+
+void CSecurityDispatcher::CallbackGetCurrentActivePin(TInt aError, RMobilePhone::TMobilePhoneSecurityCode aSecCode)				
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityGetCurrentActivePinComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aSecCode Security code.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aSecCode=%d"), aError, aSecCode);
+	
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aSecCode);	
+	
+	iMessageManagerCallback.Complete(EMmTsySecurityGetSimActivePinStateIPC, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackGetCurrentActivePin
+
+void CSecurityDispatcher::CallbackSetLockSetting(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecuritySetLockSettingComp()
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aLockStatus Phone lock status.
+ * @param aLockSetting The phone lock setting.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+    // next 2 params are ignored by the CTSY:
+    RMobilePhone::TMobilePhoneLockStatus lockStatus = RMobilePhone::EStatusLocked;
+    RMobilePhone::TMobilePhoneLockSetting lockSetting = RMobilePhone::ELockSetEnabled;
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&lockStatus, &lockSetting);
+		
+	iMessageManagerCallback.Complete(EMobilePhoneSetLockSetting, &dataPackage,  aError);
+		
+	} // CSecurityDispatcher::CallbackSetLockSetting
+
+void CSecurityDispatcher::CallbackVerifySecurityCode(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityVerifySecurityCodeComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	iMessageManagerCallback.Complete(EMobilePhoneVerifySecurityCode, aError);
+	
+	} // CSecurityDispatcher::CallbackVerifySecurityCode
+	
+void CSecurityDispatcher::CallbackGetPin1DisableSupported(TInt aError, TBool aIsSupported)
+/**
+ * Packages the data returned by the Licensee LTSY and completes the 
+ * EMmTsyPhoneGetPin1DisableSupportedIPC back to the Common TSY.
+ * 
+ * @param aError The error code to complete back. 
+ * @param aIsSupported Is SIM support disabling of PIN1.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d aIsSupported=%d"), aError, aIsSupported);
+
+	// Package up data to return to Common TSY
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aIsSupported);
+
+	// Now complete the actual get request
+	iMessageManagerCallback.Complete(EMmTsyPhoneGetPin1DisableSupportedIPC, &dataPackage, aError);		
+	} // CSecurityDispatcher::CallbackGetPin1DisableSupported
+	
+void CSecurityDispatcher::CallbackNotifyCipheringInfoChange(TInt aError, const RMmCustomAPI::TCipheringInfo& aInfo)				
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityNotifyCipheringInfoChangeInd().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aInfo Ciphering information data structure: ciphering indicator and ciphering status.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aInfo.iIndStatus=%d, aInfo.iCiphStatus=%d"), aError, aInfo.iIndStatus, aInfo.iCiphStatus);
+	
+	// Package up data to return to Common TSY
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(const_cast<TBool*>(&aInfo.iIndStatus), 
+			             const_cast<TBool*>(&aInfo.iCiphStatus));	
+	
+	iMessageManagerCallback.Complete(ECustomNotifyCipheringInfoChangeIPC, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackNotifyCipheringInfoChange
+
+void CSecurityDispatcher::CallbackCheckSecurityCode(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityCheckSecurityCodeComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	iMessageManagerCallback.Complete(ECustomCheckSecurityCodeIPC, aError);
+	
+	} // CSecurityDispatcher::CallbackCheckSecurityCode
+
+void CSecurityDispatcher::CallbackDisablePhoneLock(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityDisablePhoneLockComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	iMessageManagerCallback.Complete(ECustomDisablePhoneLockIPC, aError);
+	
+	} // CSecurityDispatcher::CallbackDisablePhoneLock
+
+void CSecurityDispatcher::CallbackGetCipheringInfo(TInt aError, TBool aIndStatus)				
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityGetCipheringInfoComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aIndStatus Ciphering indicator status.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aIndStatus=%d"), aError, aIndStatus);
+	
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aIndStatus);	
+
+	// Pack the data to return to the Common TSY
+	iMessageManagerCallback.Complete(ECustomGetCipheringInfoIPC, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackGetCipheringInfo
+
+void CSecurityDispatcher::CallbackIsSecurityCodeBlocked(TInt aError, TBool aIsBlocked)				
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityIsSecurityCodeBlockedComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ * @param aIsBlocked Is security code blocked.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d, aIsBlocked=%d"), aError, aIsBlocked);
+	
+	CMmDataPackage dataPackage;
+	dataPackage.PackData(&aIsBlocked);		
+	
+	iMessageManagerCallback.Complete(ECustomIsBlockedIPC, &dataPackage, aError);
+	
+	} // CSecurityDispatcher::CallbackIsSecurityCodeBlocked	
+
+void CSecurityDispatcher::CallbackCheckSecurityCodeCancel(TInt aError)
+/**
+ * Callback function to be used by the request to complete
+ * CCtsyDispatcherCallback::CallbackSecurityCheckSecurityCodeCancelComp().
+ *
+ * @param aError The error code to be returned to the CTSY Dispatcher.
+ */
+	{
+	TSYLOGENTRYEXITARGS(_L8("aError=%d"), aError);
+
+	iMessageManagerCallback.Complete(ECustomCheckSecurityCodeCancelIPC, aError);
+	
+	} // CSecurityDispatcher::CallbackCheckSecurityCodeCancel
+
+void CSecurityDispatcher::CallbackSync(CRequestQueueOneShot::TIpcDataPackage& aIpcDataPackage)
+/**
+ * Part of the MDispatcherCallback interface. Used to complete requests handled
+ * synchronously by the Licensee LTSY asynchronously back to the Common TSY.
+ *  
+ * @param aIpcDataPackage Package encapsulating the request.
+ * 
+ * @see MDispatcherCallback::CallbackSync
+ */
+	{
+	TSYLOGENTRYEXIT;
+	
+	switch (aIpcDataPackage.iIpc)
+		{
+	
+	default:
+		LOG(_L8("WARNING: CSecurityDispatcher::CallbackSync unhandled IPC=%d"), aIpcDataPackage.iIpc);
+		__ASSERT_DEBUG(NULL, CtsyDispatcherPanic(EUnhandledCtsyIpc));
+		break;		
+		} // switch (aIpcDataPackage.iIpc)
+	
+	} // CSecurityDispatcher::CallbackSync
+
+
+