/*

 * 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 the License "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: 

 * crypto Mac API implementation

 *

 */

 /**

  @file

 */

 #include <cryptospi/cryptomacapi.h>

 #include <cryptospi/macplugin.h>

 #include "legacyselector.h"

 using namespace CryptoSpi;

 EXPORT_C void CMacFactory::CreateMacL(CMac*& aMac,

 									  const TUid aAlgorithmUid,

 									  const CKey& aKey,

 		                              const CCryptoParams* aAlgorithmParams)

 	{

 	MPluginSelector* selector=reinterpret_cast<MPluginSelector *>(Dll::Tls());

 	if (selector)

 		{

 		selector->CreateMacL(aMac, aAlgorithmUid, aKey, aAlgorithmParams);

 		}

 	else

 		{

 		CLegacySelector* legacySelector=CLegacySelector::NewLC();

 		legacySelector->CreateMacL(aMac, aAlgorithmUid, aKey, aAlgorithmParams);

 		CleanupStack::PopAndDestroy(legacySelector); //selector	

 		}

 	}									

 CMac* CMac::NewL(MMac* aMac, TInt aHandle)

 	{

 	CMac* self = new (ELeave) CMac(aMac, aHandle); 		

 	return self;

 	}

 CMac::CMac(MMac* aMac, TInt aHandle)

 : CCryptoBase(aMac, aHandle)

 	{

 	}

 EXPORT_C CMac::~CMac()

 	{

 	}

 /**

  * Following working methods delegate calls to the plug-in implementation 

  * of the requested MAC algorithm.

  */

 EXPORT_C TPtrC8 CMac::MacL(const TDesC8& aMessage)

 	{

 	return ((MMac*)iPlugin)->MacL(aMessage); 

 	}

 EXPORT_C void CMac::UpdateL(const TDesC8& aMessage)

 	{

 	((MMac*)iPlugin)->UpdateL(aMessage);

 	}

 EXPORT_C TPtrC8 CMac::FinalL(const TDesC8& aMessage)

 	{

 	return ((MMac*)iPlugin)->FinalL(aMessage);

 	}

 EXPORT_C void CMac::ReInitialiseAndSetKeyL(const CKey& aKey)

 	{

 	((MMac*)iPlugin)->ReInitialiseAndSetKeyL(aKey);	

 	}

 EXPORT_C CMac* CMac::ReplicateL()

 	{

 	MMac* plugin=((MMac*)iPlugin)->ReplicateL();

 	CleanupClosePushL(*plugin);

 	RLibrary lib;

 	lib.SetHandle(iLibHandle);

 	RLibrary duplib=lib;

 	User::LeaveIfError(duplib.Duplicate(RThread(), EOwnerProcess));

 	CleanupClosePushL(duplib);

 	CMac* self=new(ELeave) CMac(plugin, duplib.Handle());

 	CleanupStack::Pop(2, plugin); //duplib, plugin

 	return self;		

 	}

 EXPORT_C CMac* CMac::CopyL()

 	{

 	MMac* plugin=((MMac*)iPlugin)->CopyL();

 	CleanupClosePushL(*plugin);

 	RLibrary lib;

 	lib.SetHandle(iLibHandle);

 	RLibrary duplib=lib;

 	User::LeaveIfError(duplib.Duplicate(RThread(), EOwnerProcess));

 	CleanupClosePushL(duplib);

 	CMac* self=new(ELeave) CMac(plugin, duplib.Handle());

 	CleanupStack::Pop(2, plugin); //duplib, plugin

 	return self;			

 	}

 //

 // Asynchronous MAC interface implementation

 // (async not implemented, so no coverage)

 // Once we have a dedicated hardware plugin-dll

 // the following pre-processor conditions must be removed.

 //

 #ifdef _BullseyeCoverage

 #pragma suppress_warnings on

 #pragma BullseyeCoverage off

 #pragma suppress_warnings off

 #endif

 EXPORT_C void CMacFactory::CreateAsyncMacL(CAsyncMac*& aMac,

 									  const TUid aAlgorithmUid,

 									  const CKey& aKey,

 		                              const CCryptoParams* aAlgorithmParams)

 	{

 	MPluginSelector* selector=reinterpret_cast<MPluginSelector *>(Dll::Tls());

 	if (selector)

 		{

 		selector->CreateAsyncMacL(aMac, aAlgorithmUid, aKey, aAlgorithmParams);

 		}

 	else

 		{

 		CLegacySelector* legacySelector=CLegacySelector::NewLC();

 		legacySelector->CreateAsyncMacL(aMac, aAlgorithmUid, aKey, aAlgorithmParams);

 		CleanupStack::PopAndDestroy(legacySelector); //selector	

 		}

 	}									

 CAsyncMac* CAsyncMac::NewL(MAsyncMac* aMac, TInt aHandle)

 	{

 	CAsyncMac* self = new (ELeave) CAsyncMac(aMac, aHandle); 		

 	return self;

 	}

 CAsyncMac::CAsyncMac(MAsyncMac* aMac, TInt aHandle)

 : CCryptoBase(aMac, aHandle)

 	{

 	}

 EXPORT_C CAsyncMac::~CAsyncMac()

 	{

 	}

 /**

  * Following asynchronous working methods delegate calls to the plug-in implementation 

  * of the requested MAC algorithm.

  */

 EXPORT_C TPtrC8 CAsyncMac::MacL(const TDesC8& aMessage, TRequestStatus& aStatus)

 	{

 	return ((MAsyncMac*)iPlugin)->MacL(aMessage, aStatus); 

 	}

 EXPORT_C void CAsyncMac::UpdateL(const TDesC8& aMessage, TRequestStatus& aStatus)

 	{

 	((MAsyncMac*)iPlugin)->UpdateL(aMessage, aStatus);

 	}

 EXPORT_C TPtrC8 CAsyncMac::FinalL(const TDesC8& aMessage, TRequestStatus& aStatus)

 	{

 	return ((MAsyncMac*)iPlugin)->FinalL(aMessage, aStatus);

 	}

 EXPORT_C void CAsyncMac::ReInitialiseAndSetKeyL(const CKey& aKey)

 	{

 	((MAsyncMac*)iPlugin)->ReInitialiseAndSetKeyL(aKey);	

 	}

 EXPORT_C CAsyncMac* CAsyncMac::ReplicateL()

 	{

 	MAsyncMac* plugin=((MAsyncMac*)iPlugin)->ReplicateL();

 	CleanupClosePushL(*plugin);

 	RLibrary lib;

 	lib.SetHandle(iLibHandle);

 	RLibrary duplib=lib;

 	User::LeaveIfError(duplib.Duplicate(RThread(), EOwnerProcess));

 	CleanupClosePushL(duplib);

 	CAsyncMac* self=new(ELeave) CAsyncMac(plugin, duplib.Handle());

 	CleanupStack::Pop(2, plugin); //duplib, plugin

 	return self;		

 	}

 EXPORT_C CAsyncMac* CAsyncMac::CopyL()

 	{

 	MAsyncMac* plugin=((MAsyncMac*)iPlugin)->CopyL();

 	CleanupClosePushL(*plugin);

 	RLibrary lib;

 	lib.SetHandle(iLibHandle);

 	RLibrary duplib=lib;

 	User::LeaveIfError(duplib.Duplicate(RThread(), EOwnerProcess));

 	CleanupClosePushL(duplib);

 	CAsyncMac* self=new(ELeave) CAsyncMac(plugin, duplib.Handle());

 	CleanupStack::Pop(2, plugin); //duplib, plugin

 	return self;			

 	}

 EXPORT_C void CAsyncMac::Cancel()

 	{

 	((MAsyncMac*)iPlugin)->Cancel();	

 	}