--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/sql/SRC/Security/SqlSecurityImpl.h Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,203 @@
+// Copyright (c) 2006-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:
+//
+
+#ifndef __SQLSECURITYIMPL_H__
+#define __SQLSECURITYIMPL_H__
+
+#include <sqldb.h>
+#include "SqlBufFlat.h" //RSqlBufFlat
+
+//Forward declarations
+class TSqlSecurityPolicyIterator;
+
+/**
+CSqlSecurityPolicy class implements RSqlSecurityPolicy.
+
+Current CSqlSecurityPolicy implementation uses a flat buffer (see RSqlBufFlat class) as a storage for the database
+objects security policies.
+By default the flat buffer has threee entries:
+ - entry 0 is a system entry and keeps the count of the database security entries;
+ - entry 1 is reserved for the default database security policy. This is a nameless entry;
+ - entry 2 is reserved for the database security policies: read, write and schema. This is a nameless entry;
+The flat buffer may have more entries if database object security policies are added. In this case each flat buffer entry
+has a 16-bit encoded database object name, kept at the end of the entry, after the database object security policy data and
+database object name length.
+Note: Current CSqlSecurityPolicy implementation can have no more than 13 database object security policy entries.
+An access to the flat buffer can be obtained via CSqlSecurityPolicy::BufFlat() methods (const and non-const).
+There are two ways to externalize (resp. internalize) CSqlSecurityPolicy data:
+ - (1) using CSqlSecurityPolicy::ExternalizeL()/CSqlSecurityPolicy::InternalizeL();
+ - (2) using CSqlSecurityPolicy::BufFlat() to get an access to the flat buffer and then externalize/internalize the buffer.
+ CSqlSecurityPolicy class has only one data member which is the flat buffer;
+
+TSqlSecurityPolicyIterator class gives a convinient way to access the security policies kept inside the flat buffer.
+The given access is a read-only.
+
+@see RSqlSecurityPolicy
+@see RSqlBufFlat
+@see TSqlSecurityPolicyIterator
+@see RSqlSecurityPolicy::TPolicyType
+@see RSqlSecurityPolicy::TObjectType
+@see CSqlSecurityPolicy::NewL()
+@see CSqlSecurityPolicy::NewLC()
+@see CSqlSecurityPolicy::SetDefaultPolicy()
+@see CSqlSecurityPolicy::SetDbPolicy()
+@see CSqlSecurityPolicy::SetPolicy()
+@see CSqlSecurityPolicy::DefaultPolicy()
+@see CSqlSecurityPolicy::DbPolicy()
+@see CSqlSecurityPolicy::Policy()
+@see CSqlSecurityPolicy::ExternalizeL()
+@see CSqlSecurityPolicy::InternalizeL()
+@see CSqlSecurityPolicy::BufFlat()
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(CSqlSecurityPolicy) : public CBase
+ {
+ friend class TSqlSecurityPolicyIterator;
+ struct TPolicyItem;
+
+public:
+ static CSqlSecurityPolicy* NewL(const TSecurityPolicy& aDefaultPolicy);
+ static CSqlSecurityPolicy* NewLC(const TSecurityPolicy& aDefaultPolicy);
+ virtual ~CSqlSecurityPolicy();
+ void SetDefaultPolicy(const TSecurityPolicy& aPolicy);
+ TInt SetDbPolicy(RSqlSecurityPolicy::TPolicyType aPolicyType, const TSecurityPolicy& aPolicy);
+ TInt SetPolicy(RSqlSecurityPolicy::TObjectType aObjectType, const TDesC& aObjectName, RSqlSecurityPolicy::TPolicyType aPolicyType, const TSecurityPolicy& aPolicy);
+ TSecurityPolicy DefaultPolicy() const;
+ TSecurityPolicy DbPolicy(RSqlSecurityPolicy::TPolicyType aPolicyType) const;
+ TSecurityPolicy Policy(RSqlSecurityPolicy::TObjectType aObjectType, const TDesC& aObjectName, RSqlSecurityPolicy::TPolicyType aPolicyType);
+ TInt Count() const;
+ const RSqlBufFlat& BufFlat() const;
+ RSqlBufFlat& BufFlat();
+
+private:
+ CSqlSecurityPolicy();
+ void ConstructL(const TSecurityPolicy& aDefaultPolicy);
+ inline static TInt PolicyType2Index(RSqlSecurityPolicy::TPolicyType aPolicyType);
+ inline static TPolicyItem* PolicyItemPtr(const RSqlBufFlat::TCell* aBegin, const RSqlBufFlat::TCell* aCurrent);
+ const TPolicyItem* FindPolicyItemPtr(RSqlSecurityPolicy::TObjectType aObjectType, const TDesC& aObjectName) const;
+ void SetCount(TInt aCount);
+
+private:
+ enum {
+ EPolicyTypeCount = 3, //Schema, Read, Write policy types
+ EMaxCount = 16, //iBufFlat max element count. The database cannot have more than EMaxCount security policies.
+ ECountIdx = 0, //The index of the policy counter
+ EDefaultPolicyIdx = 1, //The index of the default policy type in iBufFlat
+ EDbPolicyIdx = 2 //The index of the database policy type in iBufFlat
+ };
+
+ //The database security policies are kept in objects of TPolicyItem type.
+ //If particular TPolicyItem object represents the database security policies, then the memory layout is:
+ // [SchemaPolicy]
+ // [ReadPolicy]
+ // [WritePolicy]
+ //If particular TPolicyItem object represents table security policies, then the memory layout is:
+ // [SchemaPolicy]
+ // [ReadPolicy]
+ // [WritePolicy]
+ // [The length of the table name - 32-bit integer]
+ // [The table name]
+ //As you can see, TPolicyItem does not have "name length" and "name" data members. If that is needed, an appropriate block of memory will be allocated for the TPolicyItem object.
+ //There SQL platform security interface currently supports only database security policies, but the implementation is capable of handling also table security policies.
+ struct TPolicyItem
+ {
+ enum {EPolicyTypeCount = 3}; //Schema, Read, Write policy types. The same as the declaration above.
+ TSecurityPolicy iPolicy[EPolicyTypeCount]; //Database object policies
+ //Database object name size will be after the end of TPolicyItem object
+ inline TInt* NameSizePtr()
+ {
+ //See the comments of the TPolicyItem structure above.
+ //coverity[overrun-local]
+ return reinterpret_cast <TInt*> (reinterpret_cast <TUint8*> (iPolicy) + sizeof(iPolicy));
+ }
+ inline TInt NameSize() const
+ {
+ //See the comments of the TPolicyItem structure above.
+ //coverity[overrun-local]
+ return *reinterpret_cast <const TInt*> (reinterpret_cast <const TUint8*> (iPolicy) + sizeof(iPolicy));
+ }
+ //Database object name will be after the end of TPolicyItem object + sizeof(TInt)
+ inline const TUint16* NamePtr() const
+ {
+ //See the comments of the TPolicyItem structure above.
+ //coverity[overrun-local]
+ return reinterpret_cast <const TUint16*>
+ (reinterpret_cast <const TUint8*> (iPolicy) + sizeof(iPolicy) + sizeof(TInt));
+ }
+ inline TUint16* NamePtr()
+ {
+ //See the comments of the TPolicyItem structure above.
+ //coverity[overrun-local]
+ return reinterpret_cast <TUint16*> (reinterpret_cast <TUint8*> (iPolicy) + sizeof(iPolicy) + sizeof(TInt));
+ }
+ inline static TInt CalcSize(TInt aNameLen)
+ {
+ return sizeof(TPolicyItem) + sizeof(TInt) + aNameLen * sizeof(TUint16);
+ }
+ };
+ RSqlBufFlat iBufFlat;
+ };
+
+/**
+CSqlSecurityPolicy container read-only iterator.
+
+Usage:
+
+@code
+//Valid CSqlSecurityPolicy instance.
+CSqlSecurityPolicy* securityPolicy;
+...
+TSqlSecurityPolicyIterator it(*securityPolicy);
+
+//The following variables will be initialized on each iteration
+RSqlSecurityPolicy::TObjectType objectType;
+TPtrC objectName;
+RSqlSecurityPolicy::TPolicyType policyType;
+TSecurityPolicy policy;
+
+while(it.Next(objectType, objectName, policyType, policy))
+ {
+ //"objectType" is initialized with the object type (see RSqlSecurityPolicy::TObjectType)
+ //"objectName" is initialized with the object name (database table name)
+ //"policyType" is initialized with the policy type (see RSqlSecurityPolicy::TPolicyType)
+ //"policy" is initialized with the security policy data (see TSecurityPolicy)
+ <do something with the policy>;
+ }
+
+@endcode
+
+@see CSqlSecurityPolicy
+@see RSqlSecurityPolicy::TObjectType
+@see RSqlSecurityPolicy::TPolicyType
+@see TSecurityPolicy
+
+@internalComponent
+*/
+NONSHARABLE_CLASS(TSqlSecurityPolicyIterator)
+ {
+public:
+ TSqlSecurityPolicyIterator(const CSqlSecurityPolicy& aSqlSecurityPolicy);
+ TBool Next(RSqlSecurityPolicy::TObjectType& aObjectType, TPtrC& aObjectName, RSqlSecurityPolicy::TPolicyType& aPolicyType, TSecurityPolicy& aPolicy);
+
+private:
+ const RSqlBufFlat::TCell* iBegin;
+ const RSqlBufFlat::TCell* iCurrent;
+ const RSqlBufFlat::TCell* iEnd;
+ TInt iCurPolicyIdx;
+
+ };
+
+#endif//__SQLSECURITYIMPL_H__