/*

* Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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: Implementation of policymanagement components

*

*/

#ifndef __POLICY_ENGINE_SERVER_H__

#define __POLICY_ENGINE_SERVER_H__

// INCLUDES

#include <e32base.h>

#include "PolicyEngineClient.h"

#include "PlatformSecurityPolicies.h"

// CONSTANTS

// ----------------------------------------------------------------------------------------

// PolicyEngine server panic codes

// ----------------------------------------------------------------------------------------

enum TPolicyEnginePanic

	{

	EPanicGeneral,

	EBadSubsessionHandle,

	EPanicIllegalFunction,

	EBadDescriptor

	};

const TInt KPolicyEngineSelfCheckDelay 			= 8000000;	// approx 8s

const TInt KPolicyEngineShutdownDelay  		 	= 5;		// approx 8s * 2 = 40s

const TInt KPolicyEngineReleaseElementsDelay  	= 1;		// approx 8s * 1 = 8s

// DATA TYPES

// FUNCTION PROTOTYPES

void PanicClient(const RMessagePtr2& aMessage,TPolicyEnginePanic aPanic);

// FORWARD DECLARATIONS

class CPolicyStorage;

class CPolicyProcessor;

class CPolicyManager;

class CTrustedSession;

class CCertificateMaps;

#ifdef _DEBUG

namespace DebugUtility

{

	TBool PolicyCheckActive();

}

#endif

// MACROS

#ifdef _DEBUG

	#define NO_POLICY_CHECK_RETURN if(!DebugUtility::PolicyCheckActive())return;

	#define NO_POLICY_CHECK_FALSE DebugUtility::PolicyCheckActive()

#else

	#define NO_POLICY_CHECK_RETURN ;

	#define NO_POLICY_CHECK_FALSE ETrue

#endif

// CLASS DECLARATION     

class CShutdown : public CTimer

{

	//shutdown timer for policy server

	public:

	public:

		inline CShutdown();

		inline void ConstructL();

		inline void Start();

	private:

		void RunL();

		TInt iSelfCheckCounter;

};

class CServerStatusFlags : public CBase

{

	public:

		CServerStatusFlags() {}

	public:

		TBool iManagementUiActive;

		TBool iUiActive;

		TBool iProcessorActive;

		TBool iManagementActive;

	private:

};

class CSubSessionObjects : public CObject

{

	public:

		static CSubSessionObjects * NewL( CPolicyProcessor * aPolicyProcessor, 

										  CPolicyManager * aPolicyManager,

			  							  CTrustedSession * aTrustedSession);

		~CSubSessionObjects();

	private:

		CSubSessionObjects( CPolicyProcessor * aPolicyProcessor, 

							CPolicyManager * aPolicyManager,

							CTrustedSession * aTrustedSession);

	private:

		CPolicyProcessor * iPolicyProcessor;

 		CPolicyManager * iPolicyManager; 

		CTrustedSession * iTrustedSession;

		friend class CPolicyEngineSession;

		friend class CPolicyEngineServer;

};

/**

*  CPolicyEngineServer 

*  Description.

*/

class CPolicyEngineServer : public CPolicyServer

{

	public:

		static CServer2* NewLC();

		~CPolicyEngineServer();

		void AddSession();

		void DropSession();

	/**

    * Description

	* @param a??? 

    * @return CObjectCon

    */

		CObjectCon* NewContainerL();

		static CCertificateMaps * CertificateMaps();

		static CServerStatusFlags* StatusFlags();

		static void AddActiveObjectL( CActive* aActiveObject);

		static void RemoveActiveObject( CActive* aActiveObject);

		static void StopAllPendingRequests();

		//get active subsessions object to PolicyEngineServer

		static void SetActiveSubSession( const CBase* iBase);

		void Panic( TInt aPanicCode);

private:

		CPolicyEngineServer();

		void ConstructL();

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

		//From CPolicyServer

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

private:

		TInt iSessionCount;

		CShutdown iShutdown;

		RArray<CActive*> iActiveObjectCancelList;

		CPolicyStorage* iPolicyStorage;

		CCertificateMaps* iCertificateMaps;

		CSubSessionObjects* iSubSessionObjects;

		CServerStatusFlags* iFlags;

		CObjectConIx *iContainerIndex;

		static CPolicyEngineServer* iServer;

		CPolicyServer::TPolicy iPolicyEngineSecurityPolicy;

		friend class CPolicyEngineSession;

};

class CPolicyEngineSession : public CSession2

{

	public:

		CPolicyEngineSession();

		void CreateL();

		void SetStatusFlags( CServerStatusFlags* aFlags);

		CSubSessionObjects* GetSubSessionObjects( const CBase* iBase);

 	private:

	private:

		~CPolicyEngineSession();

		inline CPolicyEngineServer& Server();

		void ServiceL(const RMessage2& aMessage);

		void DispatchMessageL(const RMessage2& aMessage);

		void ServiceError(const RMessage2& aMessage,TInt aError);

		void NewSubSessionL( const RMessage2& aMessage);

		CSubSessionObjects* SubSessionFromHandle( const RMessage2& aMessage);

		void DeleteSubSession( const RMessage2& aMessage);

		void ExecuteRequestL( const RMessage2& aMessage);

		void AddCertificateForSessionL(  const RMessage2& aMessage);

		void PerformRFSL();

	private:	

		TInt iSubsessionCount;

		CObjectCon *iContainer; 		// object container for this session

		CObjectIx* iSessionsObjects; 	// object index which stores objects for this session

};

class CASyncHandler : public CActive

{

	public:

		~CASyncHandler();

		static CASyncHandler* NewLC();

		TRequestStatus& GetRequestStatus();

		void WaitForRequest();

	protected:	

		CASyncHandler();

		void RunL();

		void DoCancel();		

	private:

		CActiveSchedulerWait iWaitScheduler;	

};

#endif //__POLICYENGINESERVER_H__