// 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 "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 getrandomstep.cpp

 @internalTechnology

*/

#include "getrandomstep.h"

#include <tlsprovinterface.h>

#include <tlstypedef.h>

_LIT(KEpochDate, "19700000:");

CGetRandomStep::CGetRandomStep()

	{

	SetTestStepName(KGetRandomStep);

	}

TVerdict CGetRandomStep::doTestStepPreambleL()

	{

	ConstructL();

	return EPass;

	}

TVerdict CGetRandomStep::doTestStepL()

	{

	// Get three buffers of random...

	TBuf8<KTLSServerClientRandomLen> random1;

	TBuf8<KTLSServerClientRandomLen> random2;

	TBuf8<KTLSServerClientRandomLen> random3;

	INFO_PRINTF1(_L("Invoking TLS Provider - Generate Random"));

	Provider()->GenerateRandom(random1);

	Provider()->GenerateRandom(random2);

	Provider()->GenerateRandom(random3);

	// check all the buffers are of sane length

	if (random1.Length() != KTLSServerClientRandomLen ||

		random2.Length() != KTLSServerClientRandomLen ||

		random3.Length() != KTLSServerClientRandomLen)

		{

		INFO_PRINTF1(_L("Failed! Not all random buffers are of the required length!"));

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	// check the timestamps on the data are all roughly sane....

	TTime now;

	now.UniversalTime();

	TTime epoch(KEpochDate);

	TUint stamp1 = GetTimestamp(random1);

	TUint stamp2 = GetTimestamp(random2);

	TUint stamp3 = GetTimestamp(random3); 

	if (stamp1 > stamp2 || stamp2 > stamp3)

		{

		INFO_PRINTF1(_L("Failed! Timestamps suggest an insane clock!"));

		// uh oh, timestamps are going backwards...

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	// check all the time stamps are within a sane interval from "now"

	TTime time1 = epoch + TTimeIntervalSeconds(stamp1);

	TTime time2 = epoch + TTimeIntervalSeconds(stamp2);

	TTime time3 = epoch + TTimeIntervalSeconds(stamp3);

	// read the interval from the config file...

	TInt interval(0);

	if (!GetIntFromConfig(ConfigSection(), KMaxTimestampInterval, interval))

		{

		User::Leave(KErrNotFound);

		}

	TTimeIntervalSeconds interval1;

	TInt err1 = now.SecondsFrom(time1, interval1);

	TTimeIntervalSeconds interval2;

	TInt err2 = now.SecondsFrom(time2, interval2);

	TTimeIntervalSeconds interval3;

	TInt err3 = now.SecondsFrom(time3, interval3);

	if (err1 != KErrNone || err2 != KErrNone || err3 != KErrNone)

		{

		INFO_PRINTF1(_L("Failed! Could not get time intervals from 'now'!"));

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	if (interval1.Int() > interval ||

		interval2.Int() > interval ||

		interval3.Int() > interval)

		{

		// Looks like the timestamp algorithm is bad.

		INFO_PRINTF1(_L("Failed! Clock appears to be running far too fast!"));

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	// now, check the random portion of the data... 

	// just make sure it isn't all the same string...

	TPtrC8 ptr1 = random1.Mid(4);

	TPtrC8 ptr2 = random2.Mid(4);

	TPtrC8 ptr3 = random3.Mid(4);

	if (ptr1 == ptr2 || ptr2 == ptr3 || ptr3 == ptr1)

		{

		INFO_PRINTF1(_L("Failed! Random data isn't actually random!"));

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	INFO_PRINTF1(_L("Test step passed."));

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TUint CGetRandomStep::GetTimestamp(const TDesC8& aRandom)

	{

	TUint ret = aRandom[0];

	for (TInt i = 1; i < 4; ++i)

		{

		ret <<= 8;

		ret += aRandom[i];

		}

	return ret;

	}