/*

* Copyright (c) 2006-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 symmetric cipher API implementation

* crypto symmetric cipher API implementation

*

*/

/**

 @file

*/

#include "cryptosymmetriccipherapi.h"

#include "legacyselector.h"

#include "symmetriccipherplugin.h"

using namespace CryptoSpi; 

//

// Implementation of Symmetric Cipher Base Class

//

CSymmetricCipherBase::CSymmetricCipherBase(MSymmetricCipherBase* aSymmetricCipher, TInt aHandle)

: CCryptoBase(aSymmetricCipher, aHandle)

	{

	}

CSymmetricCipherBase::~CSymmetricCipherBase()

	{

	}

EXPORT_C void CSymmetricCipherBase::SetKeyL(const CKey& aKey)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	ptr->SetKeyL(aKey);

	}

EXPORT_C void CSymmetricCipherBase::SetOperationModeL(TUid aOperationMode)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	ptr->SetOperationModeL(aOperationMode);

	}

EXPORT_C void CSymmetricCipherBase::SetCryptoModeL(TUid aCryptoMode)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	ptr->SetCryptoModeL(aCryptoMode);

	}

EXPORT_C void CSymmetricCipherBase::SetPaddingModeL(TUid aPaddingMode)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	ptr->SetPaddingModeL(aPaddingMode);

	}

EXPORT_C void CSymmetricCipherBase::SetIvL(const TDesC8& aIv)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	ptr->SetIvL(aIv);

	}

EXPORT_C TInt CSymmetricCipherBase::BlockSize()

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	return ptr->BlockSize();

	}

EXPORT_C TInt CSymmetricCipherBase::KeySize()

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	return ptr->KeySize();

	}	

EXPORT_C TInt CSymmetricCipherBase::MaxOutputLength(TInt aInputLength)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	return ptr->MaxOutputLength(aInputLength);

	}

EXPORT_C TInt CSymmetricCipherBase::MaxFinalOutputLength(TInt aInputLength)

	{

	MSymmetricCipherBase* ptr=static_cast<MSymmetricCipherBase*>(iPlugin);

	return ptr->MaxFinalOutputLength(aInputLength);

	}	

//

// Implementation of Symmetric Cipher

//

CSymmetricCipher* CSymmetricCipher::NewL(MSymmetricCipher* aSymmetricCipher, TInt aHandle)

	{

	CSymmetricCipher* self=new(ELeave) CSymmetricCipher(aSymmetricCipher, aHandle);

	return self;		

	}

CSymmetricCipher::CSymmetricCipher(MSymmetricCipher* aSymmetricCipher, TInt aHandle)

: CSymmetricCipherBase(aSymmetricCipher, aHandle)

	{	

	}

EXPORT_C CSymmetricCipher::~CSymmetricCipher()

	{

	}

EXPORT_C void CSymmetricCipher::ProcessL(const TDesC8& aInput, TDes8& aOutput)

	{

	MSymmetricCipher* ptr=static_cast<MSymmetricCipher*>(iPlugin);

	ptr->ProcessL(aInput, aOutput);

	}

EXPORT_C void CSymmetricCipher::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput)

	{

	MSymmetricCipher* ptr=static_cast<MSymmetricCipher*>(iPlugin);

	ptr->ProcessFinalL(aInput, aOutput);		

	}

//

// Implementation of Symmetric Cipher Factory

//

EXPORT_C void CSymmetricCipherFactory::CreateSymmetricCipherL(CSymmetricCipher*& aCipher,

															TUid aAlgorithmUid,

															const CKey& aKey,

															TUid aCryptoMode,

															TUid aOperationMode,

															TUid aPaddingMode,

															const CCryptoParams* aAlgorithmParams)

	{

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

	if (selector)

		{

		selector->CreateSymmetricCipherL(aCipher, aAlgorithmUid, aKey, aCryptoMode, aOperationMode, aPaddingMode, aAlgorithmParams);

		}

	else

		{

		CLegacySelector* legacySelector=CLegacySelector::NewLC();

		legacySelector->CreateSymmetricCipherL(aCipher, aAlgorithmUid, aKey, aCryptoMode, aOperationMode, aPaddingMode, aAlgorithmParams);

		CleanupStack::PopAndDestroy(legacySelector); //selector	

		}

	}

//

// Implementation of Asynchronous Symmetric Cipher

// (async methods not implemented, so no coverage)

//

#ifdef _BullseyeCoverage

#pragma suppress_warnings on

#pragma BullseyeCoverage off

#pragma suppress_warnings off

#endif

CAsyncSymmetricCipher* CAsyncSymmetricCipher::NewL(MAsyncSymmetricCipher* aAsyncSymmetricCipher, TInt aHandle)

	{

	CAsyncSymmetricCipher* self=new(ELeave) CAsyncSymmetricCipher(aAsyncSymmetricCipher, aHandle);

	return self;		

	}

CAsyncSymmetricCipher::CAsyncSymmetricCipher(MAsyncSymmetricCipher* aAsyncSymmetricCipher, TInt aHandle)

: CSymmetricCipherBase(aAsyncSymmetricCipher, aHandle)

	{

	}

EXPORT_C CAsyncSymmetricCipher::~CAsyncSymmetricCipher()

	{

	}

EXPORT_C void CAsyncSymmetricCipher::ProcessL(const TDesC8& aInput, TDes8& aOutput, TRequestStatus& aRequestStatus)

	{

	MAsyncSymmetricCipher* ptr=static_cast<MAsyncSymmetricCipher*>(iPlugin);

	ptr->ProcessL(aInput, aOutput, aRequestStatus);		

	}

EXPORT_C void CAsyncSymmetricCipher::ProcessFinalL(const TDesC8& aInput, TDes8& aOutput, TRequestStatus& aRequestStatus)

	{

	MAsyncSymmetricCipher* ptr=static_cast<MAsyncSymmetricCipher*>(iPlugin);

	ptr->ProcessFinalL(aInput, aOutput, aRequestStatus);

	}

EXPORT_C void CAsyncSymmetricCipher::Cancel()

	{

	MAsyncSymmetricCipher* ptr=static_cast<MAsyncSymmetricCipher*>(iPlugin);

	ptr->Cancel();		

	}

//

// Implementation of Symmetric Cipher Factory

//

EXPORT_C void CSymmetricCipherFactory::CreateAsyncSymmetricCipherL(CAsyncSymmetricCipher*& aCipher,

														TUid aAlgorithmUid,

														const CKey& aKey,

														TUid aCryptoMode,

														TUid aOperationMode,

														TUid aPaddingMode,

														const CCryptoParams* aAlgorithmParams)

	{

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

	if (selector)

		{

		selector->CreateAsyncSymmetricCipherL(aCipher, aAlgorithmUid, aKey, aCryptoMode, aOperationMode, aPaddingMode, aAlgorithmParams);

		}

	else

		{

		CLegacySelector* legacySelector=CLegacySelector::NewLC();

		legacySelector->CreateAsyncSymmetricCipherL(aCipher, aAlgorithmUid, aKey, aCryptoMode, aOperationMode, aPaddingMode, aAlgorithmParams);

		CleanupStack::PopAndDestroy(legacySelector); //selector	

		}	

	}