/*

* 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 random API implementation

* crypto random API implementation

*

*/

/**

 @file

*/

#include <cryptospi/cryptorandomapi.h>

#include <cryptospi/randomplugin.h>

#include <cryptospi/plugincharacteristics.h>

#include "legacyselector.h"

using namespace CryptoSpi;

//

// Synchronous Random Generator

//

CRandom* CRandom::NewL(MRandom* aRandom, TInt aHandle)

	{

	CRandom* self = new(ELeave) CRandom(aRandom, aHandle);

	return self;

	}

EXPORT_C CRandom::~CRandom()

	{

	}

EXPORT_C void CRandom::GenerateRandomBytesL(TDes8& aDest)

	{

	((MRandom*)iPlugin)->GenerateRandomBytesL(aDest);

	}

CRandom::CRandom(MRandom* aRandom, TInt aHandle) 

: CCryptoBase(aRandom, aHandle)

	{

	}

//

// Random Factory Implementation

//

EXPORT_C void CRandomFactory::CreateRandomL(CRandom*& aRandom,

										TUid aAlgorithmUid,

										const CCryptoParams* aAlgorithmParams)

	{

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

	if (selector)

		{

		selector->CreateRandomL(aRandom, aAlgorithmUid, aAlgorithmParams);	

		}

	else

		{

		CLegacySelector* legacySelector=CLegacySelector::NewLC();

		legacySelector->CreateRandomL(aRandom, aAlgorithmUid, aAlgorithmParams);

		CleanupStack::PopAndDestroy(legacySelector); //legacySelector			

		}

	}

//

// Asynchronous Random Generator

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

//

#ifdef _BullseyeCoverage

#pragma suppress_warnings on

#pragma BullseyeCoverage off

#pragma suppress_warnings off

#endif

CAsyncRandom* CAsyncRandom::NewL(MAsyncRandom* aAsyncRandom, TInt aHandle)

	{

	CAsyncRandom* self = new(ELeave) CAsyncRandom(aAsyncRandom, aHandle);

	return self;

	}

EXPORT_C CAsyncRandom::~CAsyncRandom()

	{

	}

EXPORT_C void CAsyncRandom::GenerateRandomBytesL(TDes8& aDest, TRequestStatus& /*aStatus*/)

	{

	((MRandom*)iPlugin)->GenerateRandomBytesL(aDest);

	}

CAsyncRandom::CAsyncRandom(MAsyncRandom* aRandom, TInt aHandle)

: CCryptoBase(aRandom, aHandle)

	{

	}

EXPORT_C void CRandomFactory::CreateAsyncRandomL(CAsyncRandom*& aRandom,

										TUid aAlgorithmUid,

										const CCryptoParams* aAlgorithmParams)

	{

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

	if (selector)

		{

		selector->CreateAsyncRandomL(aRandom, aAlgorithmUid, aAlgorithmParams);	

		}

	else

		{

		CLegacySelector* legacySelector=CLegacySelector::NewLC();

		legacySelector->CreateAsyncRandomL(aRandom, aAlgorithmUid, aAlgorithmParams);

		CleanupStack::PopAndDestroy(legacySelector); //legacySelector			

		}	

	}