/*

 * 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);

 	}