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

// e32test\secure\d_ldd.cpp

// LDD for testing kernel platsec APIs

// 

//

/* Hack to make sure we get the true value of iKernelConfigFlags */

#include "u32std.h"

#undef __PLATSEC_FORCED_FLAGS__

#define __PLATSEC_FORCED_FLAGS__ 0

/* End hack */

#include <kernel/kern_priv.h>

#include "d_sldd.h"

_LIT(KLddName,"D_SLDD");

const TInt KMajorVersionNumber=0;

const TInt KMinorVersionNumber=1;

const TInt KBuildVersionNumber=1;

TInt AFunction()

	{

	return KErrNone;

	}

TInt data=0x100;

TAny* dataptr=(TAny*)&AFunction;

TInt TheBss;

TUint32 KernelTestData[16] = { 0x32345678, 0x12345678 };

class DTest;

class DTestFactory : public DLogicalDevice

//

// Test LDD factory

//

	{

public:

	DTestFactory();

	virtual TInt Install(); 					//overriding pure virtual

	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual

	virtual TInt Create(DLogicalChannelBase*& aChannel); 	//overriding pure virtual

	};

class DTest : public DLogicalChannelBase

//

// Test logical channel

//

	{

public:

	virtual ~DTest();

protected:

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	};

DECLARE_STANDARD_LDD()

	{

	return new DTestFactory;

	}

DTestFactory::DTestFactory()

//

// Constructor

//

	{

	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	//iParseMask=0;//No units, no info, no PDD

	//iUnitsMask=0;//Only one thing

	}

TInt DTestFactory::Create(DLogicalChannelBase*& aChannel)

//

// Create a new DTest on this logical device

//

	{

	aChannel=new DTest;

	return aChannel?KErrNone:KErrNoMemory;

	}

TInt DTestFactory::Install()

//

// Install the LDD - overriding pure virtual

//

	{

	return SetName(&KLddName);

	}

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

//

// Get capabilities - overriding pure virtual

//

	{

	// deliberately do nothing here for testing purpose

	}

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

//

// Create channel

//

	{

	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

		return KErrNotSupported;

	return KErrNone;

	}

DTest::~DTest()

//

// Destructor

//

	{

	}

TInt DTest::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt r = KErrNone;

	switch (aFunction)

		{

		case RLddTest::EControlTest1:

			r = RLddTest::ETest1Value;

			break;

		case RLddTest::EGetIds:

			{

			RLddTest::TIds ids;

			memclr(&ids, sizeof(ids));

			DThread* thread = &Kern::CurrentThread();

			ids.iThreadVID = Kern::ThreadVendorId(thread);

			ids.iThreadSID = Kern::ThreadSecureId(thread);

			DProcess* process = &Kern::CurrentProcess();

			ids.iProcessVID = Kern::ProcessVendorId(process);

			ids.iProcessSID = Kern::ProcessSecureId(process);

			kumemput(a1, &ids, sizeof(ids));

			break;

			}

		case RLddTest::EGetKernelConfigFlags:

			{

			TSuperPage& superPage = Kern::SuperPage();

			r = superPage.KernelConfigFlags();

			break;

			}

		case RLddTest::ESetKernelConfigFlags:

			{

			TSuperPage& superPage = Kern::SuperPage();

			superPage.SetKernelConfigFlags((TUint32)a1);

			break;

			}

		case RLddTest::ESetDisabledCapabilities0:

			{

			TSuperPage& superPage = Kern::SuperPage();

			memcpy(superPage.iDisabledCapabilities, &a1, sizeof(TUint32));

			break;

			}

		case RLddTest::EKernelTestData:

			{

			TUint32* ptr = KernelTestData;

			TUint32 data = *ptr;

			kumemput32(a1,&ptr,sizeof(ptr));

			kumemput32(a2,&data,sizeof(data));

			}

			break;

		case RLddTest::EGetSecureInfos:

			{

			TSecurityInfo infoThread(&Kern::CurrentThread());

			TSecurityInfo infoProcess(&Kern::CurrentProcess());

			kumemput32(a1,&infoThread,sizeof(infoThread));			

			kumemput32(a2,&infoProcess,sizeof(infoProcess));			

			}

			break;

		default:

			r = KErrNotSupported;

			break;

		}

	return r;

	}