// Copyright (c) 2001-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\t_capsup.cpp

// Overview:

// Test support of platform security capabilities.

// API Information:

// TCapabilitySet, TSecurityInfo, TSecurityPolicy and various other methods.

// Details:

// - Verify the enumeration of each of the capability names.

// - Test the TCapabilitySet class methods by setting and checking various

// capabilities. Verify results are as expected.

// - Test the TSecurityInfo class methods and verify results.

// - Test the RProcess, RThread and RMessage2 SecureId() methods along with

// User::CreatorSecureId(). Verify results are as expected.

// - Test the RProcess, RThread and RMessage2 VendorId() methods along with

// User::CreatorVendorId(). Verify results are as expected.

// - Test the RProcess, RThread and RMessage2 HasCapability() methods along

// with User::CreatorHasCapability(). Verify results are as expected.

// - Test TSecurityPolicy constructors including macros for compile-time

// construction. Verify results are as expected.

// - Test kernel APIs.  Verify results are as expected.

// - Test setting KernelConfigFlags.  Ensure that, if __PLATSEC_UNLOCKED__

// is not set, the PlatSec flags cannot be unset.

// - Test the use of platform security diagnostic strings.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __INCLUDE_CAPABILITY_NAMES__

#define __E32TEST_EXTENSION__

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <u32exec.h>

#include <e32test.h>

#include <e32def.h>

#include <e32def_private.h>

#include "d_sldd.h"

TBool PlatSecEnforcement;

_LIT_SECURE_ID(KTestSecureId,0x101f534d);

_LIT_SECURE_ID(KTestSecureId2,0x101f534e);

_LIT_VENDOR_ID(KTestVendorId,0x01234567);

_LIT_VENDOR_ID(KTestVendorId2,0x01234568);

const TUint32 KTestCapabilities =(1<<ECapabilityTCB)

								|(1<<ECapabilityPowerMgmt)

								|(1<<ECapabilityReadDeviceData)

								|(1<<ECapabilityDRM)

								|(1<<ECapabilityProtServ)

								|(1<<ECapabilityNetworkControl)

								|(1<<ECapabilitySwEvent)

								|(1<<ECapabilityLocalServices)

								|(1<<ECapabilityWriteUserData)

								|(1<<ECapabilitySurroundingsDD);

LOCAL_D RTest test(_L("T_CAPSUP"));

enum TTestProcessFunctions

	{

	ETestProcessServer,

	};

#include "testprocess.h"

TInt StartServer();

TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)

	{

	(void)aArg1;

	(void)aArg2;

	switch(aTestNum)

		{

	case ETestProcessServer:

		return StartServer();

	default:

		User::Panic(_L("T_CAPSUP"),1);

		}

	return KErrNone;

	}

//

// RTestThread

//

class RTestThread : public RThread

	{

public:

	void Create(TThreadFunction aFunction,TAny* aArg=0);

	};

void RTestThread::Create(TThreadFunction aFunction,TAny* aArg)

	{

	TInt r=RThread::Create(_L(""),aFunction,KDefaultStackSize,KDefaultStackSize,KDefaultStackSize,aArg);

	test(r==KErrNone);

	}

//

// CTestSession

//

class CTestSession : public CSession2

	{

public:

	enum {EShutdown,

		ETestProcessSecurityInfo,ETestThreadSecurityInfo,ETestMessageSecurityInfo,ETestCreatorSecurityInfo,

		ETestProcessSecureId,ETestThreadSecureId,ETestMessageSecureId,ETestCreatorSecureId,

		ETestProcessVendorId,ETestThreadVendorId,ETestMessageVendorId,ETestCreatorVendorId,

		ETestProcessHasCapability1,ETestProcessHasCapability2,

		ETestThreadHasCapability1,ETestThreadHasCapability2,

		ETestMessageHasCapability1,ETestMessageHasCapability2,

		ETestMessageHasCapabilityL1,ETestMessageHasCapabilityL2,

		ETestCreatorHasCapability1,ETestCreatorHasCapability2,

		ETestSecurityPolicyAgainstMessage,

		ETestSecurityPolicyAgainstCreator

		};

	enum {EPolicyCheckPassed = 15, EPolicyCheckFailed = 16};

public:

	CTestSession();

	virtual void ServiceL(const RMessage2& aMessage);

public:

	};

CTestSession::CTestSession()

	: CSession2()

	{}

void CTestSession::ServiceL(const RMessage2& aMessage)

	{

	const RMessagePtr2 m(aMessage);

	switch (aMessage.Function())

		{

		case CTestSession::ETestProcessSecureId:

			{

			RProcess process;

			TInt r=process.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = process.SecureId();

				process.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestThreadSecureId:

			{

			RThread thread;

			TInt r=thread.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = thread.SecureId();

				thread.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageSecureId:

			{

			TInt32 id = m.SecureId();

			m.Complete(id);

			}

			break;

		case CTestSession::ETestCreatorSecureId:

			{

			m.Complete(User::CreatorSecureId());

			}

			break;

		case CTestSession::ETestProcessVendorId:

			{

			RProcess process;

			TInt r=process.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = process.VendorId();

				process.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestThreadVendorId:

			{

			RThread thread;

			TInt r=thread.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = thread.VendorId();

				thread.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageVendorId:

			{

			TInt32 id = m.VendorId();

			m.Complete(id);

			}

			break;

		case CTestSession::ETestCreatorVendorId:

			{

			m.Complete(User::CreatorVendorId());

			}

			break;

		case CTestSession::ETestProcessSecurityInfo:

			{

			RProcess process;

			TInt r=process.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				TSecurityInfo info;

				info.Set(process);

				r = m.Write(1,TPtrC8((TUint8*)&info,sizeof(info)));

				process.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestThreadSecurityInfo:

			{

			RThread thread;

			TInt r=thread.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				TSecurityInfo info;

				info.Set(thread);

				r = m.Write(1,TPtrC8((TUint8*)&info,sizeof(info)));

				thread.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageSecurityInfo:

			{

			TSecurityInfo info;

			info.Set(m);

			TInt r = m.Write(0,TPtrC8((TUint8*)&info,sizeof(info)));

			m.Complete(r);

			}

			break;

		case CTestSession::ETestCreatorSecurityInfo:

			{

			TSecurityInfo info;

			info.SetToCreatorInfo();

			TInt r = m.Write(0,TPtrC8((TUint8*)&info,sizeof(info)));

			m.Complete(r);

			}

			break;

		case CTestSession::ETestProcessHasCapability1:

			{

			RProcess process;

			TInt r=process.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = process.HasCapability((TCapability)aMessage.Int1(),__PLATSEC_DIAGNOSTIC_STRING("ETestProcessHasCapability1"));

				process.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestProcessHasCapability2:

			{

			RProcess process;

			TInt r=process.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = process.HasCapability((TCapability)aMessage.Int1(),(TCapability)aMessage.Int2(),__PLATSEC_DIAGNOSTIC_STRING("ETestProcessHasCapability2"));

				process.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestThreadHasCapability1:

			{

			RThread thread;

			TInt r=thread.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = thread.HasCapability((TCapability)aMessage.Int1(),__PLATSEC_DIAGNOSTIC_STRING("ETestThreadHasCapability1"));

				thread.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestThreadHasCapability2:

			{

			RThread thread;

			TInt r=thread.Open(aMessage.Int0());

			if(r==KErrNone)

				{

				r = thread.HasCapability((TCapability)aMessage.Int1(),(TCapability)aMessage.Int2(),__PLATSEC_DIAGNOSTIC_STRING("ETestThreadHasCapability2"));

				thread.Close();

				}

			else

				r = KErrGeneral;

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageHasCapability1:

			{

			TInt r = m.HasCapability((TCapability)aMessage.Int0(),__PLATSEC_DIAGNOSTIC_STRING("ETestMessageHasCapability1"));

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageHasCapabilityL1:

			{

			TRAPD(r,m.HasCapabilityL((TCapability)aMessage.Int0(),__PLATSEC_DIAGNOSTIC_STRING("ETestMessageHasCapabilityL1")))

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageHasCapability2:

			{

			TInt r = m.HasCapability((TCapability)aMessage.Int0(),(TCapability)aMessage.Int1(),__PLATSEC_DIAGNOSTIC_STRING("ETestMessageHasCapability2"));

			m.Complete(r);

			}

			break;

		case CTestSession::ETestMessageHasCapabilityL2:

			{

			TRAPD(r,m.HasCapabilityL((TCapability)aMessage.Int0(),(TCapability)aMessage.Int1(),__PLATSEC_DIAGNOSTIC_STRING("ETestMessageHasCapabilityL2")))

			m.Complete(r);

			}

			break;

		case CTestSession::ETestCreatorHasCapability1:

			{

			TInt r = User::CreatorHasCapability((TCapability)aMessage.Int0(),__PLATSEC_DIAGNOSTIC_STRING("ETestCreatorHasCapability1"));

			m.Complete(r);

			}

			break;

		case CTestSession::ETestCreatorHasCapability2:

			{

			TInt r = User::CreatorHasCapability((TCapability)aMessage.Int0(),(TCapability)aMessage.Int1(),__PLATSEC_DIAGNOSTIC_STRING("ETestCreatorHasCapability2"));

			m.Complete(r);

			}

			break;

		case CTestSession::ETestSecurityPolicyAgainstMessage:

			{

			TBuf8<sizeof(TSecurityPolicy)> buf(0);

			TInt len = m.GetDesLength(0);

			TInt r = KErrArgument;

			if(len>0 && len <=buf.MaxSize())

				{

				r = m.Read(0, buf, 0);

				if(r==KErrNone)

					{

					TSecurityPolicy policy;

					r = policy.Set(buf);

					if(r == KErrNone)

						{

						r = policy.CheckPolicy(m, __PLATSEC_DIAGNOSTIC_STRING("Testing message against policy -- sample additional diagnostic."));

						if(r)

							r = EPolicyCheckPassed;

						else

							r = EPolicyCheckFailed;

						}

					}

				}

			m.Complete(r);

			break;

			}

		case CTestSession::ETestSecurityPolicyAgainstCreator:

			{

			TBuf8<sizeof(TSecurityPolicy)> buf(0);

			TInt len = m.GetDesLength(0);

			TInt r = KErrArgument;

			if(len>0 && len <=buf.MaxSize())

				{

				r = m.Read(0, buf, 0);

				if(r==KErrNone)

					{

					TSecurityPolicy policy;

					r = policy.Set(buf);

					if(r == KErrNone)

						{

						r = policy.CheckPolicyCreator(__PLATSEC_DIAGNOSTIC_STRING("Testing creator against policy -- sample additional diagnostic."));

						if(r)

							r = EPolicyCheckPassed;

						else

							r = EPolicyCheckFailed;

						}

					}

				}

			m.Complete(r);

			break;

			}

		case CTestSession::EShutdown:

			CActiveScheduler::Stop();

			break;

		default:

			m.Complete(KErrNotSupported);

			break;

		}

	}

//

// CTestServer

//

class CTestServer : public CServer2

	{

public:

	CTestServer(TInt aPriority);

	virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

	};

CTestServer::CTestServer(TInt aPriority)

	: CServer2(aPriority)

	{

	}

CSession2* CTestServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

	{

	return new (ELeave) CTestSession();

	}

//

// CTestActiveScheduler

//

class CTestActiveScheduler : public CActiveScheduler

	{

public:

	virtual void Error(TInt anError) const;

	};

void CTestActiveScheduler::Error(TInt anError) const

	{

	User::Panic(_L("TestServer Error"),anError);

	}

//

// Server thread

//

_LIT(KServerName,"T_CAPSUP-server");

const TInt KServerRendezvous = KRequestPending+1;

void DoStartServer()

	{

	CTestActiveScheduler* activeScheduler = new (ELeave) CTestActiveScheduler;

	CActiveScheduler::Install(activeScheduler);

	CleanupStack::PushL(activeScheduler);

	CTestServer* server = new (ELeave) CTestServer(0);

	CleanupStack::PushL(server);

	User::LeaveIfError(server->Start(KServerName));

	RProcess::Rendezvous(KServerRendezvous);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2);

	}

TInt StartServer()

	{

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if(!cleanupStack)