// Copyright (c) 2010 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:

// e32test/rpmb/d_rpmb.cpp

// LDD for testing RPMB kernel extension

// 

//

/**

 @file

 @internalComponent

 @prototype

*/

#include "d_rpmb.h"

#include "../t_rpmb.h"

_LIT(KRpmbTestThreadName,"RpmbTestThread");

const TInt KRpmbTestPriority = 24;

TDfcQue RpmbTestDfcQ;

TDfc* DfcPtr;

// please read this before uncommenting out #define RPMBTESTS_TRY_TO_WRITE_KEY:

// Don't want to write key 'pre production' on real device as this will lock 

// the system out of the RPMB partition (the key should be preprogrammed as 

// part of the production process so that the system has access to the key - 

// if the key has already been written it can't be written again).

// #define RPMBTESTS_TRY_TO_WRITE_KEY

/****************************************

 Implementation of DRpmbTestFactory class

*****************************************/

DRpmbTestFactory::DRpmbTestFactory()

	{

	}

DRpmbTestFactory::~DRpmbTestFactory()

	{

	}

TInt DRpmbTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DRpmbTest;

	return KErrNone;

	}

TInt DRpmbTestFactory::Install()

	{

	return SetName(&KRpmbTestLddName);

	}

void DRpmbTestFactory::GetCaps(TDes8& /*aDes*/) const

// implementation required since DLogicalDevice::GetCaps is pure virtual

	{

	// do nothing 

	}

static void RpmbTestDfcFunction(TAny* /*aPtr*/)

	{

	DRpmbDevice * rpmb;

	rpmb = new DRpmbDevice;

	TInt r = rpmb->Open(0);

	Kern::Printf("%S Early on DRpmbDevice::Open test returned %d",&KDRpmbTestBanner, r);

	// ASSERT to indicate test failure if DRpmbDevice::Open() returned error

	__ASSERT_ALWAYS((r==KErrNone), Kern::Fault(__FILE__, __LINE__));

	rpmb->Close();

	delete rpmb;

	// run more extensive tests early on 

	// note the unconventional use of a class derived from DLogicalChannelBase which is justified

	// in the current context to provide more startup test coverage

	DRpmbTest * test;

	test = new DRpmbTest;

	// while a call to DRpmbTest::DRpmbDeviceTests() works in this context

	// a call to DRpmbTest::RpmbStackTests() would fail as DRpmbTest::DoCreate() wouldn't be

	// called so that DRpmbTest::iStackSemPtr wouldn't get set up properly so that when it 

	// was uaed an exception would be generated

	r = test->DRpmbDeviceTests();

	Kern::Printf("%S Early on DRpmbTest::DRpmbDeviceTests() returned %d",&KDRpmbTestBanner, r);

	// ASSERT to indicate test failure

	__ASSERT_ALWAYS((r==KErrNone), Kern::Fault(__FILE__, __LINE__));

	// not safe to delete test as  not setup conventionally DRpmbTest::DoCreate() wasn't called 

	// at setup and DLogicalChannelBase::~DLogicalChannelBase__sub_object() would generate an 

	// exception

	}

/********************************

 Entry point for RPMB test driver

*********************************/

DECLARE_STANDARD_EXTENSION()

    {     

	TInt r = Kern::DfcQInit(&RpmbTestDfcQ,KRpmbTestPriority,&KRpmbTestThreadName);;      

	if (r != KErrNone)

		return r;

	DfcPtr = new TDfc(RpmbTestDfcFunction,NULL, &RpmbTestDfcQ, KMaxDfcPriority-7);

	DfcPtr->Enque();     

	return KErrNone;

    }

DECLARE_EXTENSION_LDD()

	{

	return new DRpmbTestFactory;

	}

/*********************************

 Implementation of DRpmbTest class

**********************************/

DRpmbTest::DRpmbTest():

// initialise parameters

	iStackSemPtr(NULL),

	iPowerSemPtr(NULL),

	iSessionEndCallBack(DRpmbTest::StackCallBack, this)

	{

	}

DRpmbTest::~DRpmbTest()

	{

	iBusCallBack.Remove();

	if (iPowerSemPtr)

		{

		iPowerSemPtr->Close(NULL);

		}

	if (iStackSemPtr)

		{

		iStackSemPtr->Close(NULL);

		}

	if (iSession)

		{

		delete iSession;

		}

	}

TInt DRpmbTest::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	TInt r = KErrNone;

	r = Kern::SemaphoreCreate(iStackSemPtr, _L("DRpmbStackSem"), 0);

	return r;

	}

TInt DRpmbTest::Request(TInt aFunction, TAny* /*a1*/, TAny* /*a2*/)

	{

	TInt r = KErrNotSupported;

	switch (aFunction)

		{

		case RTestRpmb::ERunTests:

			{

			// respond to user side request 

			// execute tests for RPMB kernel extension

			// run standatd tests that use the DRpmbDevice interface

            Kern::Printf("	");

            Kern::Printf("%S << START DRpmbDevice TESTS >>", &KDRpmbTestBanner);

			r = DRpmbDeviceTests();

            if (r != KErrNone)

                {

                Kern::Printf("%S DPrmbDevice test FAILED", &KDRpmbTestBanner);

                break;

                }

            Kern::Printf("%S >> ALL DRpmbDevice TESTS PASSED", &KDRpmbTestBanner);

			// run tests that use the MMC stack bypassing the RPMB kernel extension

            Kern::Printf("	");

	        Kern::Printf("%S << START STACK TESTS >>", &KDRpmbTestBanner);

			r = RpmbStackTests();

			if (r != KErrNone)

			    {

                Kern::Printf("%S stack test FAILED", &KDRpmbTestBanner);

                break;

			    }

            Kern::Printf("%S >> ALL STACK TESTS PASSED", &KDRpmbTestBanner);

			break;

			}

		default:

			break;

		}

	return r;

	}

// test RPMB using the DRpmbDevice interface

TInt DRpmbTest::DRpmbDeviceTests()

// open interface and make data write, ket write, counter read and data write accesses

	{				

	TInt size = (TInt)(2*KRpmbOneFramePacketLength);

	NKern::ThreadEnterCS();

	iRequest = (TUint8 *)Kern::Alloc(size);

	NKern::ThreadLeaveCS();

	iResponse = iRequest + KRpmbOneFramePacketLength;

	TInt r = SendAccessRequestNotOpen();

	if (r==KErrNone)

		{

		r = OpenWithBadIndex();

		}

	if (r==KErrNone)

		{

		r = MultipleOpen();

		}

	if (r==KErrNone)

		{

		r = iRpmb.Open(0);

		}

	if (r!=KErrNone)

		{

		Kern::Printf("%S DRpmbTest::DRpmbDeviceTest DRpmbDevice open error = %d", 

		        &KDRpmbTestBanner, r);

		}

	else

		{

		r  = SendAccessRequestBadParms();

		}

	if (r==KErrNone)

		{

		r = InvalidRequestId();

		}   

	if (r==KErrNone)

		{

		r = IsKeyProgrammed();

		}   

// Don't want to write key 'pre production' on real device as this will lock 

// the system out of the RPMB partition (the key should be preprogrammed as 

// part of the production process so that the system has access to the key - 

// if the key has already been written it can't be written again)

#ifdef RPMBTESTS_TRY_TO_WRITE_KEY

	if (r==KErrNone)

		{

		r = WriteKey();

		}

#endif

	if (r==KErrNone)

		{  

		r = ReadWriteCounter();

		}

	if (r==KErrNone)

		{

		r = ReadData();

		}

	iRpmb.Close();

	NKern::ThreadEnterCS();	

	Kern::Free(iRequest);

	NKern::ThreadLeaveCS();

	return r;

}

TInt DRpmbTest::SendAccessRequestNotOpen()

// test cases where DRpmbDevice::SendAccessRequest() is called 

// 1.) before DRpmbDevice::Open() is ever called

// 2,) after DRpmbDevice::Close() has been called but before DRpmbDevice::Open() is called

	{	

	Kern::Printf("%S DRpmbDevice::SendAccessRequest not open test", &KDRpmbTestBanner);     

	// wrap up IO buffers in descriptors to pass across interface

	TPtr8 request(iRequest,KRpmbOneFramePacketLength,KRpmbOneFramePacketLength);

	TPtr8 response(iResponse,KRpmbOneFramePacketLength,KRpmbOneFramePacketLength);

	// test call DRpmbDevice::SendAccessRequest before EVER calling open

	TInt r = iRpmb.SendAccessRequest(request, response);

	if (r != KErrNotReady)

		{

        Kern::Printf("%S SendAccessRequest not open test, before EVER opening, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	// test open and close and call again

	r = iRpmb.Open(0);

	if (r != KErrNone)

		{

        Kern::Printf("%S SendAccessRequest not open test, opening, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	iRpmb.Close();

	r = iRpmb.SendAccessRequest(request, response);

	if (r != KErrNotReady)

		{

        Kern::Printf("%S SendAccessRequest not open test, before opening AFTER closing, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	Kern::Printf("%S DRpmbDevice::SendAccessRequest not open test PASS", &KDRpmbTestBanner);     

	return KErrNone;

}

TInt DRpmbTest::OpenWithBadIndex()

// test case where DRpmbDevice::Open() is called with a device index of more than zero

	{

	Kern::Printf("%S DRpmbDevice::Open bad index test", &KDRpmbTestBanner);     

	// test index > 0

	TInt r = iRpmb.Open(1);

	if (r != KErrGeneral)

		{

        Kern::Printf("%S RpmbDevice::Open bad index test, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	Kern::Printf("%S DRpmbDevice::Open bad index test PASS", &KDRpmbTestBanner);     

	return KErrNone;

}

TInt DRpmbTest::MultipleOpen()

// test case where DRpmbDevice::Open() is called twice with the same index parameter and

// the same instance of DRpmbDevice

// test case where DRpmbDevice::Open() is called twice with the same index parameter and

// a different instance of DRpmbDevice

	{

	Kern::Printf("%S DRpmbDevice::Open use more than once test", &KDRpmbTestBanner);     

	TInt r = iRpmb.Open(0);

	if (r != KErrNone)

		{

        Kern::Printf("%S RpmbDevice::Open use more than once test first open, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	r = iRpmb.Open(0);

	if (r != KErrNone)

		{

        Kern::Printf("%S RpmbDevice::Open use more than once test second open, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;	

		}

	r = iRpmbSecondInstance.Open(0);

	if (r != KErrInUse)

		{

        Kern::Printf("%S RpmbDevice::Open use more than once test third open, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;	

		}

	iRpmb.Close();

	iRpmbSecondInstance.Close();

	Kern::Printf("%S DRpmbDevice::Open use more than once test PASS", &KDRpmbTestBanner);     

	return KErrNone;

	}

TInt DRpmbTest::SendAccessRequestBadParms()

// test cases where DRpmbDevice::SendAccessRequest is called with secriptor arguments with invalid lengths

	{

	Kern::Printf("%S DRpmbDevice::SendAccessRequest bad parms test", &KDRpmbTestBanner);     

	// test both lengths !=	KRpmbOneFramePacketLength

	TBuf<KRpmbOneFramePacketLength-1> request;

	TBuf<KRpmbOneFramePacketLength+1> response;

	request.SetLength(KRpmbOneFramePacketLength-1);

	response.SetLength(KRpmbOneFramePacketLength+1);

	TInt r = iRpmb.SendAccessRequest(request, response);

	if (r != KErrArgument)

		{

        Kern::Printf("%S SendAccessRequest bad parms test, both params bad, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	// test request length != KRpmbOneFramePacketLength

	TBuf<KRpmbOneFramePacketLength+1> request1;

	TBuf<KRpmbOneFramePacketLength> response1;

	request1.SetLength(KRpmbOneFramePacketLength+1);

	response1.SetLength(KRpmbOneFramePacketLength);

	r = iRpmb.SendAccessRequest(request1, response1);

	if (r != KErrArgument)

		{

        Kern::Printf("%S SendAccessRequest bad parms test, request param bad, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	// test response length !=KRpmbOneFramePacketLength

	TBuf<KRpmbOneFramePacketLength> request2;

	TBuf<KRpmbOneFramePacketLength-1> response2;

	request2.SetLength(KRpmbOneFramePacketLength);

	response2.SetLength(KRpmbOneFramePacketLength-1);

	r = iRpmb.SendAccessRequest(request1, response1);

	if (r != KErrArgument)

		{

        Kern::Printf("%S SendAccessRequest bad parms test, response param bad, unexpected error = %d", 

                &KDRpmbTestBanner, r);     

		return KErrGeneral;

		}

	Kern::Printf("%S DRpmbDevice::SendAccessRequest bad parms test PASS", &KDRpmbTestBanner);     

	return KErrNone;

}

TInt DRpmbTest::InvalidRequestId()

// send a request with an invalid request ID to the RPMB partition

// when SendAccessRequest returns iResponse should not have reponse or result fields filled in

	{

    Kern::Printf("%S invalid request ID test", &KDRpmbTestBanner);     

	// set up write request packet with blank MAC

	memset(iRequest, 0, KRpmbOneFramePacketLength);

	* (iRequest + KRpmbRequestLsbOffset) = KRpmbRequestReadResultRegister + 1;

	// wrap up IO buffers in descriptors to pass across interface

	TPtr8 request(iRequest,KRpmbOneFramePacketLength,KRpmbOneFramePacketLength);

	TPtr8 response(iResponse,KRpmbOneFramePacketLength,KRpmbOneFramePacketLength);

	TInt r = iRpmb.SendAccessRequest(request, response);

	if (r != KErrNone)

		{

        Kern::Printf("%S invalid request ID test, send request error = %d", 

                &KDRpmbTestBanner, r);     

		return r;

		}

	// check that response or result fields have not been set in response

	TUint resp = DecodeResponse(iResponse);

	TUint result = DecodeResult(iResponse);

	if (resp != 0x0006)

		{

        Kern::Printf("%S invalid request ID test, unexpected response = %d error", 

                &KDRpmbTestBanner, resp);

		return KErrGeneral;

		}

	if (result != 0x0000)

		{

		Kern::Printf("%S invalid request ID test, unexpected result = %d error", 

                &KDRpmbTestBanner, result);

		return KErrGeneral;

		}

	Kern::Printf("%S invalid requeset ID test PASS", &KDRpmbTestBanner);     

	return KErrNone;

	}

TInt DRpmbTest::IsKeyProgrammed()

// send a data write request to the RPMB partition

// because the request has a blank MAC (not authenticated) 

// the partition returns operation result authentication failure if the key is programmed

// else the partition returns authentication key not programmed

	{

    Kern::Printf("%S data write test", &KDRpmbTestBanner);     

	// set up write request packet with blank MAC

	memset(iRequest, 0, KRpmbOneFramePacketLength);

	* (iRequest + KRpmbRequestLsbOffset) = KRpmbRequestWriteData;

	// wrap up IO buffers in descriptors to pass across interface

	TPtr8 request(iRequest,KRpmbOneFramePacketLength,KRpmbOneFramePacketLength);

	TPtr8 response(iResponse,KRpmbOneFramePacketLength,KRpmbOneFramePacketLength);

	TInt r = iRpmb.SendAccessRequest(request, response);

	if (r != KErrNone)

		{

        Kern::Printf("%S data write test, send request error = %d", 

                &KDRpmbTestBanner, r);     

		return r;

		}

	TUint resp = DecodeResponse(iResponse);

	TUint result = DecodeResult(iResponse);

	if (resp != KRpmbResponseWriteData)

		{

        Kern::Printf("%S data write test, unexpected response = %d error", 

                &KDRpmbTestBanner, resp);

		return KErrGeneral;

		}

	if (result == KRpmbResultKeyNotProgrammed)

		{

		iKeySet = EFalse;

	    Kern::Printf("%S data write test, key NOT programmed", 

	            &KDRpmbTestBanner);     

		}

	else if (result == KRpmbResultAuthenticationFailure)

		{

		iKeySet = ETrue;

	    Kern::Printf("%S data write test, key ALREADY programmed", 

	            &KDRpmbTestBanner);     

		}

	else

		{

        Kern::Printf("%S data write test, unexpected result = %d error", 

                &KDRpmbTestBanner, result);

		return KErrGeneral;