// 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 "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:

// CPolicyBase, CDbPolicy, CTblPolicy, CPolicyDomain, 

// TPolicyDomainBuilder, TPolicyDomainReader classes.

// MPolicyDomainPersister, MPolicyDomainLoader interfaces

// 

//

#ifndef __SC_POLICY_H__

#define __SC_POLICY_H__

#include <e32base.h>		//CBase

#include "D32Security.h"

namespace DBSC

{

//Forward declarations

class CPolicyDomain;

/**

CPolicyBase class implements MPolicy interface.

It describes an object that manages a set of TSecurityPolicy objects.

CPolicyBase::iPOType data member gives an information access to what kind of 

database object (database or table) is controlled by the set of security policies.

CPolicyBase::Check() can be used to check caller access rights against specified policy type.

@see MPolicy

@internalComponent

*/

NONSHARABLE_CLASS(CPolicyBase) : public CBase, public MPolicy

	{

public:

	struct TPolicy

		{

		TPolicyType		iType;

		TSecurityPolicy	iData;

		};

	typedef RArray<TPolicy> RPolicyCollection;

	typedef enum {EPCNotFound, EPCPassed, EPCNotPassed} TPolicyCheckResult;

public:

	virtual ~CPolicyBase();

	virtual TBool Check(const RMessage2& aMessage, TPolicyType aPolicyType) const = 0; 

	virtual TInt Get(TPolicyType aPolicyType, TSecurityPolicy& aPolicy) const;

	virtual void InvariantL() const;

	DECLARE_DB_INVARIANT()

	inline const RPolicyCollection& PolicyCollection() const;

protected:

	inline CPolicyBase();

	void ConstructL(const RPolicyCollection& aPolicyCollection);

	const TSecurityPolicy* Policy(TPolicyType aPolicyType) const;

	TPolicyCheckResult DoCheck(const RMessage2& aMessage, TPolicyType aPolicyType) const; 

	DECLARE_DB_DUMP2(aFile)

private:

	RPolicyCollection	iPolicyCollection;

	};

/**

CDbPolicy class describes an object that manages the access to all databases, which

have the same format UID.

@see CPolicyBase

@see MPolicy

@internalComponent

*/

NONSHARABLE_CLASS(CDbPolicy) : public CPolicyBase

	{

public:

	static CDbPolicy* NewLC(const RPolicyCollection& aPolicyCollection);

	inline static CDbPolicy* NewL(const RPolicyCollection& aPolicyCollection);

	virtual ~CDbPolicy();

	virtual TBool Check(const RMessage2& aMessage, TPolicyType aPolicyType) const; 

	virtual void InvariantL() const;

	DECLARE_DB_DUMP2(aFile)

private:

	inline CDbPolicy();

	};

/**

CTblPolicy class describes an object that manages the access to all tables, which

have particular format UID and particular name.

@see CPolicyBase

@see MPolicy

@internalComponent

*/

NONSHARABLE_CLASS(CTblPolicy) : public CPolicyBase

	{

public:

	static CTblPolicy* NewLC(const TDesC& aTblName, 

							 const RPolicyCollection& aPolicyCollection,

							 const CDbPolicy* aDbPolicy);

	inline static CTblPolicy* NewL(const TDesC& aTblName, 

								   const RPolicyCollection& aPolicyCollection,

								   const CDbPolicy* aDbPolicy);

	virtual ~CTblPolicy();

	virtual TBool Check(const RMessage2& aMessage, TPolicyType aPolicyType) const; 

	virtual TInt Get(TPolicyType aPolicyType, TSecurityPolicy& aPolicy) const;

	virtual void InvariantL() const;

	inline const TDesC& TableName() const;

	DECLARE_DB_DUMP2(aFile)

private:

	inline CTblPolicy(const CDbPolicy* aDbPolicy);

	void ConstructL(const TDesC& aTblName, const RPolicyCollection& aPolicyCollection);

private:

	HBufC*	iTblName;

	const CDbPolicy* iDbPolicy;

	};

/**

TPolicyDomainBuilder class describes an object that can be used during the initialization

to initialize CPolicyDomain objects. It is used by MPolicyDomainLoader interface.

@internalComponent

*/

class TPolicyDomainBuilder

	{

public:

	inline TPolicyDomainBuilder(CPolicyDomain& aPolicyDomain);

	void SetDbPolicyL(CDbPolicy* aDbPolicy);

	inline void AddTblPolicyL(CTblPolicy* aTblPolicy);

	inline void SetBackupSID(TSecureId& aSecureId);

private:

	CPolicyDomain&	iPolicyDomain;

	};

/**

TPolicyDomainBuilder class describes an object that can be used to explore the content of

CPolicyDomain objects. It is used by MPolicyDomainPersister interface.

@internalComponent

*/

class TPolicyDomainReader

	{

public:

	inline TPolicyDomainReader(const CPolicyDomain& aPolicyDomain);

	inline TUid Uid() const;

	inline const CDbPolicy& DbPolicy() const;

	inline void ResetTblPos() const;

	inline TInt TblPolicyCount() const;

	inline const CTblPolicy* NextTblPolicy() const;

	inline TSecureId BackupSID() const;

private:

	const CPolicyDomain&	iPolicyDomain;

	mutable TInt			iIndex;

	};

/**

MPolicyDomainPersister interface has to be implemented by DBSC clients, who want to store

the information from CPolicyDomain objects (set of security policies) somewhere - text files,

streams, ... It uses TPolicyDomainReader class to traverse CPolicyDomain collection of

security policies.

@see TPolicyDomainReader

@internalComponent

*/

class MPolicyDomainPersister

	{

public:

	virtual void RunL(const TPolicyDomainReader& aPolicyDomainReader) = 0;

	};

/**

MPolicyDomainPersister interface has to be implemented by DBSC clients, who want to load

set of security policies to CPolicyDomain objects from somewhere - text files,

streams, ... It uses TPolicyDomainBuilder class to add to CPolicyDomain collection new

security policies.

@see TPolicyDomainBuilder

@internalComponent

*/

class MPolicyDomainLoader

	{

public:

	virtual void RunL(TPolicyDomainBuilder& aPolicyDomainBuilder) = 0;

	};

/**

CPolicyDomain object describes a set of all security policies related to particular format UID.

It describes only a collection of security policies and offers some functionality for

retrieving particular database/table MPolicy interfaces.

The responsibility for adding new items to secirity policy collection is delegated to 

TPolicyDomainBuilder class.

The responsibility for traversing secirity policy collection is delegated to 

TPolicyDomainReader class.

Both, TPolicyDomainBuilder and TPolicyDomainReader classes are not used directly by 

the CPolicyDomain class implementation. CPolicyDomain instances are created using 

MPolicyDomainLoader interface and externalized using MPolicyDomainPersister interface and

they (the interfaces) use TPolicyDomainBuilder and TPolicyDomainReader respectively.

The delegation of responsibilities for creation/traversing of CPolicyDomain security policy collection

was done because CPolicyDomain class is a part of shared sources used in DBMS server implementation

and DbSpConv tool implementation.

DBMS server creates CPolicyDomain security policy collection from a binary policy files using

TPDStreamLoader class (which implements MPolicyDomainLoader) and TPolicyDomainBuilder class

to insert created CDbPolicy and CTblPolicy instances into CPolicyDomain collection.

The rest of the possibilities: creating CPolicyDomain collection from a text policy file,

exporting CPolicyDomain collection to a binary policy file, 

exporting CPolicyDomain collection to a text policy file, are used by the DbSpConv tool.

So, CPolicyDomain class uses interfaces for its loading/storing, but their 

implementations are part of separate exe-s - no waste of production code.

@see MPolicy

@see CDbPolicy

@see CTblPolicy

@see TPolicyDomainBuilder

@see TPolicyDomainReader

@see MPolicyDomainLoader

@see MPolicyDomainPersister

@internalComponent

*/

NONSHARABLE_CLASS(CPolicyDomain) : public CBase

	{

	friend class TPolicyDomainBuilder;

	friend class TPolicyDomainReader;

public:

	static CPolicyDomain* NewLC(TUid aUid, MPolicyDomainLoader& aPDLoader);

	inline static CPolicyDomain* NewL(TUid aUid, MPolicyDomainLoader& aPDLoader);

	virtual ~CPolicyDomain();

	void ExternalizeL(MPolicyDomainPersister& aPDPersister) const;

	inline TUid Uid() const;

	const MPolicy* DbPolicy() const;

	const MPolicy* TblPolicy(const TDesC& aTblName) const;

	inline TSecureId BackupSID() const;

	virtual void InvariantL() const;

	DECLARE_DB_DUMP3(aFile)

private:

	inline CPolicyDomain(TUid aUid);

	void InternalizeL(MPolicyDomainLoader& aPDLoader);

	void Destroy();

	DECLARE_DB_INVARIANT2()

private:

	TUid						iUid;

	CDbPolicy*					iDbPolicy;

	RPointerArray<CTblPolicy>	iTPCollection;

	TSecureId 					iBackupSID;

	};

} //end of - namespace DBSC

#include "SC_Policy.inl"

#endif//__SC_POLICY_H__