diff -r 000000000000 -r 99ef825efeca rtsecuritymanager/rtsecuritymanagerutil/src/rtsecmgrpermission.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rtsecuritymanager/rtsecuritymanagerutil/src/rtsecmgrpermission.cpp Mon Mar 30 12:51:20 2009 +0300 @@ -0,0 +1,585 @@ +/* +* 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 +#include + +// --------------------------------------------------------------------------- +// 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 +// --------------------------------------------------------------------------- +// +EXPORT_C void CPermissionSet::ExternalizeL(RWriteStream& aSink) const + { + aSink.WriteInt32L (iPermissions.Count ()); + for (TInt idx(0); idx!=iPermissions.Count ();++idx) + { + iPermissions[idx]->ExternalizeL (aSink); + } + + aSink.WriteUint32L (iUncondCapSet); + } + +// --------------------------------------------------------------------------- +// InternalizeL permissionset data from stream +// --------------------------------------------------------------------------- +// +EXPORT_C void CPermissionSet::InternalizeL(RReadStream& aSource) + { + iPermissions.Reset (); + TInt cnt(aSource.ReadInt32L ()); + + for (TInt idx(0); idx!=cnt;++idx) + { + CPermission* permission = CPermission::NewL(); + permission->InternalizeL (aSource); + iPermissions.Append (permission); + } + + iUncondCapSet = aSource.ReadUint32L (); + } + +// --------------------------------------------------------------------------- +// Adds a permission data to the permissionset +// --------------------------------------------------------------------------- +// +EXPORT_C void CPermissionSet::AppendPermission(CPermission& aPermission) + { + iPermissions.Append (&aPermission); + } + +// --------------------------------------------------------------------------- +// Returns permission data +// --------------------------------------------------------------------------- +// +EXPORT_C const RPermissions& CPermissionSet::Permissions() const + { + return iPermissions; + } + +// --------------------------------------------------------------------------- +// Returns permission data +// --------------------------------------------------------------------------- +// +EXPORT_C RPermissions& CPermissionSet::Permissions() + { + return iPermissions; + }