// 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;

 	}