// Copyright (c) 2004-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_polsvr.cpp

// Overview:

// Policy Server Tests

// API Information:

// CPolicyServer

// Details:

// - Perform various policy server tests:

// Server1 has implementations of CustomSecurityCheckL and

// CustomFailureActionL This is the test for all the paths in a policy servers

// implementations -- not all connect paths though

// This test also ensures that every path through the binary search is

// covered.

// Policy2,3,4,5,6, are bad policies that should cause the server to panic

// in debug mode.  In release, they'll just pass, however, if you later tried

// to use them, something would go horribly wrong

// Policies 7,8,9 check various types of connect policies.

// Server 1,2,3 are used here all with policy 8 because you can only test 1

// type of connect policy per server.

// Sever2 does not have implementations of CustomSecurityCheckL and

// CustomFailureActionL. When these functions are called it should crash

// Server4 is used for checking what happens when the custom functions use

// another active object.  This test encompasses leaving due to OOM, and

// cancellation.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32debug.h>

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

_LIT(KPolSvr, "T_POLSVR");

#define Debug(x) RDebug::Print(_L(x))

const TUint32 KTestCapabilities =(1<<ECapabilityTCB)

								|(1<<ECapabilityPowerMgmt)

								|(1<<ECapabilityReadDeviceData)

								|(1<<ECapabilityDRM)

								|(1<<ECapabilityProtServ)

								|(1<<ECapabilityNetworkControl)

								|(1<<ECapabilitySwEvent)

								|(1<<ECapabilityLocalServices)

								|(1<<ECapabilityWriteUserData);

const TInt KCustomCheckMask		= 0x01000000;

const TInt KCustomActionMask	= 0x02000000;

const TInt KServiceLMask		= 0x04000000;

const TInt KActiveCheckMask 	= 0x08000000;

const TInt KActiveActionMask	= 0x00100000;

const TInt KActiveRunLMask  	= 0x00200000;

const TInt KActiveRunErrorMask	= 0x00400000;

const TInt KActiveDoCancelMask	= 0x00800000;

const TInt KServiceErrorMask	= 0x00010000;

//Ideally this constant should go in your derived server.  However, I couldn't

//be bothered to put the same constant in every one of the derived servers in

//this test code

const TInt KQueryUser = -1;

void OrInFlags(const RMessage2& aMsg, TUint aMask)

	{

	TBuf8<4> flags(0);

	TInt r = aMsg.Read(0, flags);

	test(r == KErrNone);

	(*(TUint32*)(flags.Ptr())) |= aMask;

	flags.SetLength(4);

	r = aMsg.Write(0, flags);

	test(r == KErrNone);

	}

void SetFlags(TDes8& aDes, TUint aValue)

	{

	(*(TUint32*)(aDes.Ptr())) = aValue;

	}

TUint FlagsValue(const TDes8& aDes)

	{

	return (*(TUint32*)(aDes.Ptr()));

	}

enum TTestProcessFunctions

	{

	ETestProcessPolicyServer,

	};

enum TTestServerIndex

	{

	ETestServer1=0,

	ETestServer2,

	ETestServer3,

	ETestServer4,

	};

enum TServerPolicyIndex

	{

	EPolicy1=0,

	EPolicy2,

	EPolicy3,

	EPolicy4,

	EPolicy5,

	EPolicy6,

	EPolicy7,

	EPolicy8,

	EPolicy9,

	EPolicy10,

	EPolicy11,

	EPolicy12,

	};

//

// EPolicy1

//

const TUint gServerPolicy1RangeCount = 12;

const TInt gServerPolicy1Ranges[gServerPolicy1RangeCount] = { 

	0, //ENotSupported

	1, //ECustomCheck

	6, //EAlwaysPass

	7, //ENotSupported

	8, //->0

	9, //->1

	10, //->2

	11, //->3

	12, //->3

	13, //ENotSupported

	100, //EAlwaysPass -> Shutdown

	101, //ENotSupported

	};

const TUint8 gServerPolicy1ElementsIndex[] = { 

	CPolicyServer::ENotSupported,

	CPolicyServer::ECustomCheck, 

	CPolicyServer::EAlwaysPass, 

	CPolicyServer::ENotSupported,

	0, //RequireNetworkControl or EFail

	1, //RequireNetworkControl or EQueryUser

	2, //RequireDiskAdmin or EFail

	3, //RequireDiskAdmin or EQueryUser

	3, //RequireDiskAdmin or EQueryUser

	CPolicyServer::ENotSupported,

	CPolicyServer::EAlwaysPass, 

	CPolicyServer::ENotSupported,

	};

const CPolicyServer::TPolicyElement gServerPolicy1Elements[] =

	{

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl),CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl),KQueryUser},

	{_INIT_SECURITY_POLICY_C1(ECapabilityDiskAdmin),CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityDiskAdmin),KQueryUser},

	};

const CPolicyServer::TPolicy gServerPolicy1 = 

	{

	CPolicyServer::EAlwaysPass,gServerPolicy1RangeCount,

	gServerPolicy1Ranges,

	gServerPolicy1ElementsIndex,

	gServerPolicy1Elements,

	};

//

//EPolicy2

//

const TUint gServerPolicy2RangeCount = 1;

//Invalid Policy -- doesn't start with 0

const TInt gServerPolicy2Ranges[gServerPolicy2RangeCount] = { 

	1, //KErrNotSupported

	};

const TUint8 gServerPolicy2ElementsIndex[] = { 

	CPolicyServer::ENotSupported,

	};

const CPolicyServer::TPolicyElement gServerPolicy2Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EFailClient},

	};

const CPolicyServer::TPolicy gServerPolicy2 = 

	{

	0,gServerPolicy2RangeCount,

	gServerPolicy2Ranges,

	gServerPolicy2ElementsIndex,

	gServerPolicy2Elements

	};

//

//EPolicy3

//

const TUint gServerPolicy3RangeCount = 12;

//Invalid Policy -- range values not increasing

const TInt gServerPolicy3Ranges[gServerPolicy3RangeCount] = { 

	0, //ECustomCheck

	6, //EAlwaysPass

	7, //ENotSupported

	8, //->0

	9, //->1

	10, //->2

	11, //->3

	12, //->3

	13, //ENotSupported

	100, //EAlwaysPass -> Shutdown

	101, //ENotSupported

	99, //EAlwaysPass

	};

const TUint8 gServerPolicy3ElementsIndex[] = { 

	CPolicyServer::ECustomCheck, 

	CPolicyServer::EAlwaysPass, 

	CPolicyServer::ENotSupported,

	0, //RequireNetworkControl or EFail

	1, //RequireNetworkControl or EQueryUser

	2, //RequireDiskAdmin or EFail

	3, //RequireDiskAdmin or EQueryUser

	3, //RequireDiskAdmin or EQueryUser

	CPolicyServer::ENotSupported,

	CPolicyServer::EAlwaysPass, 

	CPolicyServer::ENotSupported,

	CPolicyServer::EAlwaysPass, 

	};

const CPolicyServer::TPolicyElement gServerPolicy3Elements[] =

	{

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl),CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl),KQueryUser},

	{_INIT_SECURITY_POLICY_C1(ECapabilityDiskAdmin),CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityDiskAdmin),KQueryUser},

	};

const CPolicyServer::TPolicy gServerPolicy3 = 

	{

	0,gServerPolicy3RangeCount,

	gServerPolicy3Ranges,

	gServerPolicy3ElementsIndex,

	gServerPolicy3Elements

	};

//

//EPolicy4

//

const TUint gServerPolicy4RangeCount = 1;

//Invalid Policy -- Elements Index has invalid values

const TInt gServerPolicy4Ranges[gServerPolicy4RangeCount] = { 

	0, //Invalid value

	};

const TUint8 gServerPolicy4ElementsIndex[] = { 

	CPolicyServer::ESpecialCaseHardLimit,

	};

const CPolicyServer::TPolicyElement gServerPolicy4Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EFailClient},

	};

const CPolicyServer::TPolicy gServerPolicy4 = 

	{

	0,gServerPolicy4RangeCount,

	gServerPolicy4Ranges,

	gServerPolicy4ElementsIndex,

	gServerPolicy4Elements

	};

//

//EPolicy5

//

const TUint gServerPolicy5RangeCount = 1;

//Invalid Policy -- Elements Index has invalid values

const TInt gServerPolicy5Ranges[gServerPolicy5RangeCount] = { 

	0, //uses Invalid value

	};

const TUint8 gServerPolicy5ElementsIndex[] = { 

	//Uses invalid value 

	CPolicyServer::ESpecialCaseLimit,

	};

const CPolicyServer::TPolicyElement gServerPolicy5Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EFailClient},

	};

const CPolicyServer::TPolicy gServerPolicy5 = 

	{

	0,gServerPolicy5RangeCount,

	gServerPolicy5Ranges,

	gServerPolicy5ElementsIndex,

	gServerPolicy5Elements

	};

//

//EPolicy6

//

const TUint gServerPolicy6RangeCount = 1;

//Invalid Policy -- Elements Index has invalid values

const TInt gServerPolicy6Ranges[gServerPolicy6RangeCount] = { 

	0,

	};

const TUint8 gServerPolicy6ElementsIndex[] = { 

	CPolicyServer::ENotSupported,

	};

const CPolicyServer::TPolicyElement gServerPolicy6Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EFailClient},

	};

const CPolicyServer::TPolicy gServerPolicy6 = 

	{

	//Uses invalid value for iOnConnect

	CPolicyServer::ESpecialCaseHardLimit,gServerPolicy6RangeCount,

	gServerPolicy6Ranges,

	gServerPolicy6ElementsIndex,

	gServerPolicy6Elements

	};

//

//EPolicy7

//

// Connect not supported

const TUint gServerPolicy7RangeCount = 1;

const TInt gServerPolicy7Ranges[gServerPolicy7RangeCount] = { 

	0,

	};

const TUint8 gServerPolicy7ElementsIndex[] = { 

	0

	};

const CPolicyServer::TPolicyElement gServerPolicy7Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EFailClient},

	};

const CPolicyServer::TPolicy gServerPolicy7 = 

	{

	CPolicyServer::ENotSupported,gServerPolicy7RangeCount,

	gServerPolicy7Ranges,

	gServerPolicy7ElementsIndex,

	gServerPolicy7Elements

	};

//

//EPolicy8

//

// Connect Custom Check

const TUint gServerPolicy8RangeCount = 1;

const TInt gServerPolicy8Ranges[gServerPolicy8RangeCount] = { 

	0,

	};

const TUint8 gServerPolicy8ElementsIndex[] = { 

	0

	};

const CPolicyServer::TPolicyElement gServerPolicy8Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EPanicClient},

	};

const CPolicyServer::TPolicy gServerPolicy8 = 

	{

	CPolicyServer::ECustomCheck,gServerPolicy8RangeCount,

	gServerPolicy8Ranges,

	gServerPolicy8ElementsIndex,

	gServerPolicy8Elements

	};

//

//EPolicy9

//

// Connect has a static policy but it fails.

const TUint gServerPolicy9RangeCount = 1;

const TInt gServerPolicy9Ranges[gServerPolicy9RangeCount] = { 

	0,

	};

const TUint8 gServerPolicy9ElementsIndex[] = { 

	0

	};

const CPolicyServer::TPolicyElement gServerPolicy9Elements[] =

	{

	{_INIT_SECURITY_POLICY_FAIL,CPolicyServer::EFailClient},

	};

const CPolicyServer::TPolicy gServerPolicy9 = 

	{

	0,gServerPolicy9RangeCount,

	gServerPolicy9Ranges,

	gServerPolicy9ElementsIndex,

	gServerPolicy9Elements

	};

//

// EPolicy10

//

const TUint gServerPolicy10RangeCount = 13;

const TInt gServerPolicy10Ranges[gServerPolicy10RangeCount] = { 

	0, //ECustomCheck

	5, //EAlwaysPass

	6, //ENotSupported

	8, //->0

	9, //->3

	10, //->2

	11, //->1

	12, //ENotSupported

	55, //->3

	58, //ENotSupported

	100, //EAlwaysPass -> Shutdown

	101, //ENotSupported

	KMaxTInt, //EAlways Pass

	};

const TUint8 gServerPolicy10ElementsIndex[] = { 

	CPolicyServer::ECustomCheck, 

	CPolicyServer::EAlwaysPass, 

	CPolicyServer::ENotSupported,

	0, //RequireNetworkControl or EFail

	3, //RequireDiskAdmin or EQueryUser

	2, //RequireDiskAdmin or EFail

	1, //RequireNetworkControl or EQueryUser

	CPolicyServer::ENotSupported,

	3,

	CPolicyServer::ENotSupported,

	CPolicyServer::EAlwaysPass, 

	CPolicyServer::ENotSupported,

	CPolicyServer::EAlwaysPass, 

	};

const CPolicyServer::TPolicyElement gServerPolicy10Elements[] =

	{

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl),CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkControl),KQueryUser},

	{_INIT_SECURITY_POLICY_C1(ECapabilityDiskAdmin),CPolicyServer::EFailClient},

	{_INIT_SECURITY_POLICY_C1(ECapabilityDiskAdmin),KQueryUser},

	};

const CPolicyServer::TPolicy gServerPolicy10 = 

	{

	CPolicyServer::EAlwaysPass,gServerPolicy10RangeCount,

	gServerPolicy10Ranges,

	gServerPolicy10ElementsIndex,

	gServerPolicy10Elements,

	};

//A list of all the global policies

const CPolicyServer::TPolicy* gPolicyIndex[] = {

	&gServerPolicy1,

	&gServerPolicy2,

	&gServerPolicy3,

	&gServerPolicy4,

	&gServerPolicy5,

	&gServerPolicy6,

	&gServerPolicy7,

	&gServerPolicy8,

	&gServerPolicy9,

	&gServerPolicy10,

	};

#include "testprocess.h"

TInt StartServer(const CPolicyServer::TPolicy& aPolicy, TUint aServerIndex);

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

	{

	switch(aTestNum)

		{

	case ETestProcessPolicyServer:

		{

		__ASSERT_ALWAYS(aArg1 >= 0 && aArg1 < (TInt)sizeof(gPolicyIndex)>>2, User::Panic(KPolSvr, KErrArgument));

		const CPolicyServer::TPolicy& policy = *(gPolicyIndex[aArg1]);

		__ASSERT_ALWAYS(aArg2 >= 0, User::Panic(KPolSvr, KErrArgument));

		TInt r;

		r=StartServer(policy, TUint(aArg2));

		if(r==KErrAlreadyExists)

			{

			User::After(2*1000*1000);

			r=StartServer(policy, TUint(aArg2));

			}

		return r;

		}

	default:

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

		}

	return KErrNone;

	}

//

// RTestThread

//

class RTestThread : public RThread

	{

public:

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