/*

* Copyright (c) 2007-2008 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:       Defines permission data structure

 *

*/

#include <s32mem.h>

#include <rtsecmgrutility.h>

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

// Two-phased constructor

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

//

EXPORT_C CPermission* CPermission::NewL()

	{

	CPermission* self = CPermission::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

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

// Two-phased constructor

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

//

EXPORT_C CPermission* CPermission::NewLC()

	{

	CPermission* self = new (ELeave) CPermission();

	CleanupStack::PushL(self);

	return self;

	}

CPermission::CPermission(const CPermission& aPermission)

	{

	if ( iPermName)

		{

		delete iPermName;

		iPermName = NULL;

		}

	iPermName = aPermission.PermName().Alloc();

	iPermissionData = aPermission.PermissionData();

	}

CPermission::CPermission(const RCapabilityArray& aCapabilities) :iPermName(NULL)

	{

	for(TInt i(0);i!=aCapabilities.Count();++i)

		{

		TUint32 capBit = LOWBIT << (aCapabilities[i]);

		iPermissionData = KDefaultNullBit;

		iPermissionData |= capBit;

		}	

	}

CPermission::CPermission(const RCapabilityArray& aCapabilities, TUserPromptOption aDefOpt) :iPermName(NULL)

	{

	iPermissionData = KDefaultNullBit;

	for(TInt i(0);i!=aCapabilities.Count();++i)

		{

		TUint32 capBit = LOWBIT << (aCapabilities[i]);

		iPermissionData |= capBit;

		if ( aDefOpt&RTUserPrompt_OneShot)

			iPermissionData |= DEFAULT_ONESHOT;

		else

			if ( aDefOpt&RTUserPrompt_Session)

				iPermissionData |= DEFAULT_SESSION;

			else

				if ( aDefOpt&RTUserPrompt_Permanent)

					iPermissionData |= DEFAULT_BLANKET;

		}

	}

CPermission::CPermission(const RCapabilityArray& aCapabilities, TUserPromptOption aDefOpt,TUserPromptOption aCondition) :iPermName(NULL)

	{

	iPermissionData = KDefaultNullBit;

	for(TInt i(0);i!=aCapabilities.Count();++i)

		{

		TUint32 capBit = LOWBIT << (aCapabilities[i]);

		iPermissionData |= capBit;

		iPermissionData |= aCondition;

		if ( aDefOpt&RTUserPrompt_OneShot)

			iPermissionData |= DEFAULT_ONESHOT;

		else

			if ( aDefOpt&RTUserPrompt_Session)

				iPermissionData |= DEFAULT_SESSION;

			else

				if ( aDefOpt&RTUserPrompt_Permanent)

					iPermissionData |= DEFAULT_BLANKET;

		}

	}

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

// Destructor

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

//

EXPORT_C CPermission::~CPermission()

	{

	if(iPermName)

		{

		delete iPermName;

		iPermName = NULL;

		}

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewL(const CPermission& aPermission)

	{

	CPermission* self = CPermission::NewLC(aPermission);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CPermission* CPermission::NewLC(const CPermission& aPermission)

	{

	CPermission* self = new (ELeave) CPermission(aPermission);

	CleanupStack::PushL(self);

	return self;

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewL(const RCapabilityArray& aCapabilities)

	{

	CPermission* self = CPermission::NewLC(aCapabilities);

	CleanupStack::Pop(self);

	return self;

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewLC(const RCapabilityArray& aCapabilities)

	{

	CPermission* self = new (ELeave) CPermission(aCapabilities);

	CleanupStack::PushL(self);

	return self;

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewL(const RCapabilityArray& aCapabilities, TUserPromptOption aDefOpt)

	{

	CPermission* self = CPermission::NewLC(aCapabilities, aDefOpt);

	CleanupStack::Pop(self);

	return self;

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewLC(const RCapabilityArray& aCapabilities, TUserPromptOption aDefOpt)

	{

	CPermission* self = new (ELeave) CPermission(aCapabilities ,aDefOpt);

	CleanupStack::PushL(self);

	return self;

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewL(const RCapabilityArray& aCapabilities, TUserPromptOption aDefOpt,

		TUserPromptOption aCondition)

	{

	CPermission* self = CPermission::NewLC(aCapabilities, aDefOpt, aCondition);

	CleanupStack::Pop(self);

	return self;

	}

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

// Overloaded constructor

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

//

EXPORT_C CPermission* CPermission::NewLC(const RCapabilityArray& aCapabilities, TUserPromptOption aDefOpt,

		TUserPromptOption aCondition)

	{

	CPermission* self = new (ELeave) CPermission(aCapabilities, aDefOpt, aCondition);

	CleanupStack::PushL(self);

	return self;

	}

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

// Returns default condition

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

//

EXPORT_C TUserPromptOption CPermission::Default() const

	{

	TUint32 ret(iPermissionData & DEFAULT_ALL);

	if(DEFAULT_ONESHOT&ret)

		{

		return RTUserPrompt_OneShot;

		}

	else if(DEFAULT_SESSION&ret)

		{

		return RTUserPrompt_Session;

		}

	else if(DEFAULT_BLANKET&ret)

		{

		return RTUserPrompt_Permanent;

		}

	return (TUserPromptOption)ret;

	}

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

// Returns condition set of the permission

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

//

EXPORT_C TUserPromptOption CPermission::Condition() const

	{

	return (TUserPromptOption)(iPermissionData & CONDITION_ALL);

	}

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

// Returns capability of the permission

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

//

EXPORT_C TCapability CPermission::Capability() const

	{

	TCapability retValue = (TCapability)(iPermissionData & CAPABILITY_ALL);

	for(TInt i(ECapabilityTCB);i<=ECapabilityUserEnvironment;++i)

		{

		TUint32 temp = LOWBIT << i;

		if(retValue & temp)

			{

			return (TCapability)i;

			}

		}

	return ECapability_None;

	}

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

// Returns capability of the permission

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

//

EXPORT_C void CPermission::Capabilitilites(RCapabilityArray& aCapabilities) const

	{

	TCapability retValue = (TCapability)(iPermissionData & CAPABILITY_ALL);

	for(TInt i(ECapabilityTCB) ;i <= ECapabilityUserEnvironment ;i++)

		{

		TUint32 temp = LOWBIT << i;

		if(retValue & temp)

			{

			aCapabilities.Append((TCapability)i);

			}

		}

	}

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

// Sets default condition of the permission

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

//

EXPORT_C void CPermission::SetDefault(TUserPromptOption aDefOpt)

	{

	if ( RTUserPrompt_OneShot==aDefOpt)

		{

		iPermissionData |= DEFAULT_ONESHOT;

		iPermissionData |= CONDITION_ONESHOT;

		}

	else

		if ( RTUserPrompt_Session==aDefOpt)

			{

			iPermissionData |= DEFAULT_SESSION;

			iPermissionData |= CONDITION_SESSION;

			}

		else

			if ( RTUserPrompt_Permanent==aDefOpt)

				{

				iPermissionData |= DEFAULT_BLANKET;

				iPermissionData |= CONDITION_BLANKET;

				}

	}

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

// Sets condition of the permission

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

//

EXPORT_C void CPermission::SetCondition(TUserPromptOption aCondition)

	{

	iPermissionData |= aCondition;

	}

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

// Sets name of the permission

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

//

EXPORT_C void CPermission::SetPermName(const TDesC& aPermName)

	{

	if ( iPermName)

		{

		delete iPermName;

		iPermName = NULL;

		}

	iPermName = aPermName.AllocL ();

	}

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

// Returns name of the permission

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

//

EXPORT_C const TDesC& CPermission::PermName() const

	{

	if ( iPermName)

		return *iPermName;

	else

		return KNullDesC ();

	}

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

// Adds an unconditional capability

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

//

EXPORT_C void CPermission::AppendCapPermData(TCapability aCap)

	{

	if ( (aCap>=ECapabilityTCB)&&(aCap<=ECapabilityUserEnvironment))

		{

		iPermissionData = iPermissionData | (LOWBIT << aCap);

		}

	}

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

// Sets the permission data

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

//

EXPORT_C void CPermission::SetPermissionData(TPermissionData aPermData)

	{

		iPermissionData = aPermData;

	}

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

// Returns PermissionData of the permission

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

//

EXPORT_C TPermissionData CPermission::PermissionData() const

	{

	return iPermissionData;

	}

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

// Internalizes permission data from stream

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

//

EXPORT_C void CPermission::InternalizeL(RReadStream& aInStream)

	{

	TInt32 len = aInStream.ReadInt32L ();

	if ( iPermName)

		{

		delete iPermName;

		iPermName = NULL;

		}

	iPermName = HBufC::NewL (aInStream, len);

	iPermissionData = aInStream.ReadUint32L ();

	}

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

// ExternalizeLs permission data to stream

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

//

EXPORT_C void CPermission::ExternalizeL(RWriteStream& aOutStream) const

	{

	if(iPermName)

		{

		aOutStream.WriteInt32L (iPermName->Des().MaxLength ());

		aOutStream << *iPermName;

		}

	else

		{

		aOutStream.WriteInt32L (0);

		aOutStream << KNullDesC;

		}	

	aOutStream.WriteUint32L (iPermissionData);

	}

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

// Copy constructor

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

//

CPermissionSet::CPermissionSet(const CPermissionSet& aPermSet)

	{

	iUncondCapSet = aPermSet.iUncondCapSet;

	}

void CPermissionSet::ConstructL(const CPermissionSet& aPermSet)

	{

	iPermissions.ResetAndDestroy ();

	//iPermissions.Close();

	for (TInt idx(0); idx!=aPermSet.iPermissions.Count ();++idx)

		{

		CPermission *temp = CPermission::NewL(*(aPermSet.iPermissions[idx]));

		iPermissions.Append (temp);

		}

	}

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

// Two-phased constructor

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

//

EXPORT_C CPermissionSet* CPermissionSet::NewL()

	{

	CPermissionSet* self = CPermissionSet::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

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

// Two-phased constructor

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

//

EXPORT_C CPermissionSet* CPermissionSet::NewLC()

	{

	CPermissionSet* self = new (ELeave) CPermissionSet();

	CleanupStack::PushL(self);

	return self;

	}

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

// Two-phased constructor

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

//

EXPORT_C CPermissionSet* CPermissionSet::NewL(const CPermissionSet& aPermSet)

	{

	CPermissionSet* self = CPermissionSet::NewLC(aPermSet);

	CleanupStack::Pop(self);

	return self;

	}

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

// Two-phased constructor

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

//

EXPORT_C CPermissionSet* CPermissionSet::NewLC(const CPermissionSet& aPermSet)

	{

	CPermissionSet* self = new (ELeave) CPermissionSet(aPermSet);

	CleanupStack::PushL(self);

	self->ConstructL(aPermSet);

	return self;

	}

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

// Destructor

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

//

EXPORT_C CPermissionSet::~CPermissionSet()

{

	iPermissions.ResetAndDestroy();

}

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

// Adds an unconditional capability

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

//

EXPORT_C void CPermissionSet::AppendUncondCap(TCapability aCap)

	{

	if ( (aCap>=ECapabilityTCB)&&(aCap<=ECapabilityUserEnvironment))

		{

		iUncondCapSet = iUncondCapSet | (LOWBIT << aCap);

		}

	}

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

// Adds an unconditional capability

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

//

EXPORT_C void CPermissionSet::AppendUncondCapabilities(TUnConditionalPermission aUnConditionals)

	{

		iUncondCapSet = aUnConditionals;

	}

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

// Returns unconditional capabilities of thhe permissionset

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

//

EXPORT_C TUnConditionalPermission CPermissionSet::UnconditionalCaps() const

	{

	return iUncondCapSet;

	}

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

// Returns unconditional capabilities of thhe permissionset

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

//

EXPORT_C void CPermissionSet::UnconditionalCaps(RUnConditionals& aUnConditionals) const

	{

	for (TInt i(ECapabilityTCB); i!=ECapability_Limit;++i)

		{

		TUint32 capBitToCheck(KDefaultEnableBit);

		capBitToCheck = capBitToCheck << i;

		if ( capBitToCheck&iUncondCapSet)

			{

			aUnConditionals.Append ((TCapability)i);

			}

		}

	}

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

// ExternalizeLs permissionset data to stream

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