/*

* Copyright (c) 2005-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: 

*

*/

/**

 @file

*/

#include "randsvr.h"

#include "randcliserv.h"

#include <e32math.h>

#include "randsvrimpl.h"

//const TInt KFastTickTimer=1000000;			// These are testing numbers!

//const TInt KSlowTickTimer=30000000;

const TInt KThreshold=1024;

const TInt KFastTickTimer=30000000;			// These are the real numbers!

const TInt KSlowTickTimer=0x7fffffff;

void SignalClient()

//

// Signal the owning thread that the server has started successfully

// This may itself fail

//

	{

	RProcess::Rendezvous(KErrNone);

	}

EXPORT_C TInt RunRandomServer(TAny* /*aUnused*/)

	{

	CTrapCleanup* cleanup=CTrapCleanup::New();

	if (!cleanup)

		{

		return KErrNoMemory;

		}

	TInt ret = User::RenameThread(KRandomServerName);

	__ASSERT_ALWAYS(ret==KErrNone,User::Panic(KRandomServerName,KErrServerTerminated));

	if (CRandomScheduler::New())

		return KErrNoMemory;

	ret = CRandomServer::New();

	if (ret != KErrNone )

		return ret;

	// Initialisation complete, now signal the client

	SignalClient();

	CRandomScheduler::Start();

	delete cleanup;

	return KErrNone;

	}

TBool CRandomScheduler::New(void)

	{

	CRandomScheduler* rs;

	rs=new CRandomScheduler;

	CRandomScheduler::Install(rs);

	return (rs == NULL);

	}

void CRandomScheduler::Error(TInt /*aError*/) const 

	{

	User::Panic(KRandomServerName, 3);

	}

CRandomServer::CRandomServer(void) : CServer2(EPriorityLow)

	{

	}

CRandomServer::~CRandomServer(void)

	{

	// This should never happen....but in case it does:

	delete iHash;

	delete iTicker;

	delete iPool;

	}

TInt CRandomServer::New(void)

	{

	CRandomServer* self;

	self=new CRandomServer;

	if (!self)

		{

		return KErrNoMemory;

		}

	TRAPD(ret,self->ConstructL());

	if (ret)

		{

		return ret;

		}

	return self->Start(KRandomServerName);

	}

void CRandomServer::ConstructL(void)

	{

	iPool=new (ELeave) TUint8[KRandomPoolSize];

	iHash=CSHA1::NewL();

	iPoolIn=0;

	iPoolOut=0;

	iTicker=CPeriodic::NewL(EPriorityLow);

	TCallBack callback(Tick,this);

	iTicker->Start(KFastTickTimer,KFastTickTimer,callback);		// **** these figures might need tweaking!

	iQuality=0;

	iFast=ETrue;

	}

TInt CRandomServer::Tick(TAny* aServer)

	{

	CRandomServer* svr=(CRandomServer*)aServer;

	svr->Stir();

	svr->iQuality+=30;

	if (svr->iFast)

		{

		if (svr->iQuality>KThreshold)

			{

			TCallBack callback(Tick,svr);

			svr->iTicker->Cancel();

			svr->iTicker->Start(KSlowTickTimer,KSlowTickTimer,callback);		// **** these figures might need tweaking!

			svr->iFast=EFalse;

			}

		}

	if (svr->iQuality>(KRandomPoolSize<<3))

		{

		svr->iQuality=(KRandomPoolSize<<3);

		}

	return ETrue;

	}

CSession2* CRandomServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

	{

	return CRandomSession::NewL(const_cast<CRandomServer*>(this));

	//CRandomSession::NewL(CONST_CAST(CRandomServer*,this),Message().Client());

	}

TPtrC8 CRandomServer::GetRandom(void)

	{

	TPtr8 res(&iPool[iPoolOut],iHash->HashSize(),iHash->HashSize());

	iPoolOut+=iHash->HashSize();

	if ((iPoolOut+iHash->HashSize())>KRandomPoolSize)

		{

		iPoolOut=0;

		}

	return iHash->Hash(res);

	}

CMessageDigest* CRandomServer::Hash(void) const

	{

	return iHash;

	}

void CRandomServer::Stir(void) 

	{

	TInt rnd;

	rnd=Math::Random();

	TPtrC8 r((TUint8*)&rnd,sizeof(TInt));

	iHash->Hash(r);

	TPtr8 dest(&iPool[iPoolIn],iHash->HashSize());

	dest.Copy(iHash->Hash(dest));

	iPoolIn+=iHash->HashSize();

	if ((iPoolIn+iHash->HashSize())>KRandomPoolSize)

		{

		iPoolIn=0;

		}

	}

CRandomSession* CRandomSession::NewL(CRandomServer* aServer)

	{

	CRandomSession* self;

	self=new (ELeave) CRandomSession(aServer);

	return self;

	}

CRandomSession::CRandomSession(CRandomServer* aServer) : CSession2(), iServer(aServer)

	{

	}

CRandomSession::~CRandomSession(void)

	{

	}

void CRandomSession::ServiceL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

	case KRandomRequest:

		{

		TInt ret = FillBuffer(aMessage);

		aMessage.Complete(ret);

		break;

		}

	default:

		aMessage.Complete(KErrNotSupported);

		break;

		};

	}

TInt CRandomSession::FillBuffer(const RMessage2& aMessage)

	{

	TInt length = aMessage.Int1();

	if (length < 0 || length > KRandomBlockSize)

		return KErrArgument;

	iServer->iQuality -= length;

	if (iServer->iQuality<0)

		{

		iServer->iQuality=0;

		}

	if (!iServer->iFast)

		{

		if (iServer->iQuality<KThreshold)

			{

			TCallBack callback(CRandomServer::Tick,iServer);

			iServer->iTicker->Cancel();

			iServer->iTicker->Start(KFastTickTimer,KFastTickTimer,callback);		// **** these figures might need tweaking!

			iServer->iFast=ETrue;

			}

		}

	TBuf8<KRandomBlockSize> buf(0);

	iServer->Stir();

	TInt i;

	TInt hashsize=iServer->Hash()->HashSize();

	for (i=0; i+hashsize < length; i+=hashsize)

		{

		buf.Append(iServer->GetRandom());

		iServer->Stir();

		}

	TPtrC8 ptr(iServer->GetRandom().Ptr(), length-i);

	buf.Append(ptr);

	TRAPD(ret, aMessage.WriteL(0, buf));

	return ret;

	}

GLDEF_C TInt E32Main(void)

	{

	return RunRandomServer(NULL);

	}