// 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;