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

	};

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

	{

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

	test(r==KErrNone);

	}

//

// CTestSession1

//

class CTestSession1 : public CSession2

	{

public:

	enum {EShutdown=100};

public:

	CTestSession1();

	virtual void ServiceL(const RMessage2& aMsg);

public:

	};

CTestSession1::CTestSession1()

	: CSession2()

	{}

void CTestSession1::ServiceL(const RMessage2& aMsg)

	{

	OrInFlags(aMsg, KServiceLMask);

	TInt fn = aMsg.Function();

	switch(fn)

		{

		case 2:

		case 4:

		case 5:

		case 6:

		case 8:

		case 9:

		case 12:

		case KMaxTInt:

			aMsg.Complete(KErrNone);

			break;

		case CTestSession1::EShutdown:

			CActiveScheduler::Stop();

			aMsg.Complete(KErrNone);

			break;

		default:

			//If we get here we have an unhandled condition in the test code.

			//The test code is specifically setup to try and catch all branches

			//through the policy server.  If you get, there is some problem in

			//the setup.

			test(0);

			break;

		}

	}

//

// CTestPolicyServer1

//

class CTestPolicyServer1 : public CPolicyServer

	{

public:

	CTestPolicyServer1(TInt aPriority, const TPolicy& aPolicy);

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

	virtual TCustomResult CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo& aMissing);

	virtual TCustomResult CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);

	};

CTestPolicyServer1::CTestPolicyServer1(TInt aPriority, const TPolicy& aPolicy)

	: CPolicyServer(aPriority, aPolicy)

	{

	}

CSession2* CTestPolicyServer1::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMsg*/) const

	{

	return new (ELeave) CTestSession1();

	}

CPolicyServer::TCustomResult CTestPolicyServer1::CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo& aMissing)

	{

	TInt fn = aMsg.Function();

	if(fn >= 0)

		{

		//Connect messages don't use this debugging system

		OrInFlags(aMsg, KCustomCheckMask);

		}

	if(fn == -1) //Connect

		{

		return EPass;

		}

	else if(fn == 1)

		{

		aMissing.iCaps.AddCapability(ECapabilityCommDD);

		return EFail;

		}

	else if(fn == 2)

		{

		return EPass;

		}

	else if(fn == 3)

		{

		aMissing.iCaps.AddCapability(ECapabilityCommDD);

		aAction = KQueryUser;

		return EFail;

		}

	else if(fn == 4)

		{

		aMissing.iCaps.AddCapability(ECapabilityCommDD);

		aAction = KQueryUser;

		return EFail;

		}

	else if(fn == 5)

		{

		//Since we are returning ETrue here, setting the action shouldn't affect

		//anything.  This should result in the same as 2.

		aAction = KQueryUser;

		return EPass;

		}

	//If we get here we have an unhandled condition in the test code.  The test

	//code is specifically setup to try and catch all branches through the

	//policy server.  If you get, there is some problem in the setup.

	test(0);

	return EFail;

	}

CPolicyServer::TCustomResult CTestPolicyServer1::CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing)

	{

	(void)aMissing;

	(void)aMsg;

	(void)aAction;

	TInt fn = aMsg.Function();

	if(fn >= 0)

		{

		//Connect messages don't use this debugging system

		OrInFlags(aMsg, KCustomActionMask);

		}

	switch(fn)

		{

		case 3:

			return EFail;

		case 4:

			return EPass;

		case 11:

			return EFail;

		case 12:

			return EPass;

		default:

			break;

		}

	//If we get here we have an unhandled condition in the test code.  The test

	//code is specifically setup to try and catch all branches through the

	//policy server.  If you get, there is some problem in the setup.

	test(0);

	return EFail;

	}

//

// CTestPolicyServer2

//

class CTestPolicyServer2 : public CPolicyServer

	{

public:

	CTestPolicyServer2(TInt aPriority, const TPolicy& aPolicy);

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

	//virtual TBool CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction);

	//virtual TBool CustomFailureActionL(const TSecurityPolicy* aPolicy, const RMessage2& aMsg, TInt aAction);

	};

//

// CTestSession2

//

class CTestSession2 : public CSession2

	{

public:

	enum {EShutdown=100};

public:

	CTestSession2();

	virtual void ServiceL(const RMessage2& aMsg);

public:

	};

CTestSession2::CTestSession2()

	: CSession2()

	{

	}

void CTestSession2::ServiceL(const RMessage2& aMsg)

	{

	TInt fn = aMsg.Function();

	switch(fn)

		{

		case CTestSession2::EShutdown:

			CActiveScheduler::Stop();

			aMsg.Complete(KErrNone);

			break;

		default:

			//If we get here we have an unhandled condition in the test code.

			//The test code is specifically setup to try and catch all branches

			//through the policy server.  If you get, there is some problem in

			//the setup.

			test(0);

			break;

		}

	}

CTestPolicyServer2::CTestPolicyServer2(TInt aPriority, const TPolicy& aPolicy)

	: CPolicyServer(aPriority, aPolicy)

	{

	}

CSession2* CTestPolicyServer2::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMsg*/) const

	{

	return new (ELeave) CTestSession2();

	}

//

// CTestPolicyServer3

//

class CTestPolicyServer3 : public CPolicyServer

	{

public:

	CTestPolicyServer3(TInt aPriority, const TPolicy& aPolicy);

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

	virtual TCustomResult CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo&);

	virtual TCustomResult CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing);

	};

CPolicyServer::TCustomResult CTestPolicyServer3::CustomSecurityCheckL(const RMessage2& aMsg, TInt& aAction, TSecurityInfo& aMissing)

	{

	(void)aAction;

	(void)aMsg;

	(void)aMissing;

	//If we get here we have an unhandled condition in the test code.  The test

	//code is specifically setup to try and catch all branches through the

	//policy server.  If you get, there is some problem in the setup.

	test(0);

	return EFail;

	}

CPolicyServer::TCustomResult CTestPolicyServer3::CustomFailureActionL(const RMessage2& aMsg, TInt aAction, const TSecurityInfo& aMissing)

	{

	(void)aMissing;

	(void)aMsg;

	(void)aAction;

	TInt fn = aMsg.Function();

	switch(fn)

		{

		case -1:

			return EPass;

		default:

			break;

		}

	//If we get here we have an unhandled condition in the test code.  The test

	//code is specifically setup to try and catch all branches through the

	//policy server.  If you get, there is some problem in the setup.

	test(0);

	return EFail;

	}

//

// CTestSession3

//

class CTestSession3 : public CSession2

	{

public:

	enum {EShutdown=100};

public:

	CTestSession3();

	virtual void ServiceL(const RMessage2& aMsg);

public:

	};

CTestSession3::CTestSession3()

	: CSession2()

	{

	}

void CTestSession3::ServiceL(const RMessage2& aMsg)

	{

	TInt fn = aMsg.Function();

	switch(fn)

		{

		case CTestSession3::EShutdown:

			CActiveScheduler::Stop();

			aMsg.Complete(KErrNone);

			break;

		default:

			//If we get here we have an unhandled condition in the test code.

			//The test code is specifically setup to try and catch all branches

			//through the policy server.  If you get, there is some problem in

			//the setup.

			test(0);

			break;

		}

	}

CTestPolicyServer3::CTestPolicyServer3(TInt aPriority, const TPolicy& aPolicy)

	: CPolicyServer(aPriority, aPolicy)

	{

	}

CSession2* CTestPolicyServer3::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMsg*/) const

	{

	return new (ELeave) CTestSession3();

	}

_LIT(KCustomActive, "CCustomActive");

//

// CCustomActive

//

class CCustomActive : public CActive

	{

public:

	static CCustomActive* NewL(CPolicyServer& aServer);

	void RunL();

	TInt RunError(TInt aError);

	void DoCancel();

	void CustomSecurityCheckL(const RMessage2& aMsg, TInt aAction);

	void CustomFailureActionL(const RMessage2& aMsg, TInt aAction);

protected:

	void HandleSecurityCheckResultL();

	void HandleFailureActionResultL();

	void ConstructL();	

private:

	CCustomActive(CPolicyServer& aServer);

	RTimer iTimer;

	CPolicyServer& iServer;

	const RMessage2* iMsg;

	enum TState {

		ECustomSecurityCheck,

		EFailureAction,

		};

	TState iState;

	TInt iAction;

	TSecurityInfo iMissing;

	};

CCustomActive::CCustomActive(CPolicyServer& aServer)

	: CActive(0), iServer(aServer), iMsg(0), iState(ECustomSecurityCheck)

	{

	CActiveScheduler::Add(this);

	}

CCustomActive* CCustomActive::NewL(CPolicyServer& aServer)

	{

	CCustomActive* self = new(ELeave)CCustomActive(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CCustomActive::ConstructL()

	{

	User::LeaveIfError(iTimer.CreateLocal());

	memset(&iMissing, 0, sizeof(TSecurityInfo));

	}

void CCustomActive::HandleSecurityCheckResultL()

	{

	TInt fn = iMsg->Function();

	switch(fn)

		{

		case 0:

			iStatus = KErrGeneral;

			break;

		case 1: //pass

		case 4:

			break;

		case 2:

		case 3:

			iStatus = KErrGeneral;

			iAction = KQueryUser;

			break;

		default:

			test(0);

		}

	if(iStatus == KErrNone)

		{

		iServer.ProcessL(*iMsg);

		iMsg=0;

		}

	else

		{

		const RMessage2* ptr = iMsg;

		iMsg=0;

		iServer.CheckFailedL(*ptr, iAction, iMissing);

		}

	}

void CCustomActive::HandleFailureActionResultL()

	{

	TInt fn = iMsg->Function();

	switch(fn)

		{

		case 2:

			iStatus = KErrGeneral;

			break;

		case 3: //pass

		case 9:

		case 57: //passes through so ServiceL can leave with NoMem

			break;

		case 56:

			User::Leave(KErrNoMemory);

			break;

		default:

			test(0);

		}

	if(iStatus == KErrNone)

		iServer.ProcessL(*iMsg);

	else

		iMsg->Complete(KErrPermissionDenied);

	iMsg=0;

	}

void CCustomActive::RunL()

	{

	OrInFlags(*iMsg, KActiveRunLMask);

	switch(iState)

		{

		case ECustomSecurityCheck:

			HandleSecurityCheckResultL();

			break;

		case EFailureAction:

			HandleFailureActionResultL();

			break;

		default:

			//Invalid state

			User::Panic(KCustomActive, 11);

			break;

		}

	}

TInt CCustomActive::RunError(TInt aError)

	{

	OrInFlags(*iMsg, KActiveRunErrorMask);

	if(iMsg)

		{

		iServer.ProcessError(*iMsg, aError);

		iMsg = 0;

		iAction = CPolicyServer::EFailClient;

		return KErrNone;

		}

	else

		return aError;

	}

void CCustomActive::DoCancel()

	{

	OrInFlags(*iMsg, KActiveDoCancelMask);

	iTimer.Cancel();

	if(iMsg)

		{

		iMsg->Complete(KErrCancel);