1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Security/SqlSecurityImpl.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,411 @@
1.4 +// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <s32buf.h>
1.20 +#include "SqlSecurityImpl.h"
1.21 +#include "SqlUtil.h"
1.22 +
1.23 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.24 +//////////////////////////// CSqlSecurityPolicy implementation ////////////////////////////////////////
1.25 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.26 +
1.27 +/**
1.28 +Casts aPolicyType parameter to an integer value, which is used as policy index.
1.29 +
1.30 +@param aPolicyType Security policy type: schema, write, read
1.31 +
1.32 +@return Security policy type casted to an integer value, which is used as a poicy index
1.33 +*/
1.34 +inline TInt CSqlSecurityPolicy::PolicyType2Index(RSqlSecurityPolicy::TPolicyType aPolicyType)
1.35 + {
1.36 + return static_cast <TInt> (aPolicyType);
1.37 + }
1.38 +
1.39 +/**
1.40 +Returns a pointer to the data of the current flat buffer cell. The pointer type is CSqlSecurityPolicy::TPolicyItem.
1.41 +
1.42 +@param aBegin Points to the beginning of flat buffer header
1.43 +@param aCurrent Points to a cell in the flat buffer header, to which data a pointer will be cast and returned.
1.44 +
1.45 +@return CSqlSecurityPolicy::TPolicyItem pointer, which can be used for R/W operations on the database security policy data.
1.46 +*/
1.47 +inline CSqlSecurityPolicy::TPolicyItem* CSqlSecurityPolicy::PolicyItemPtr(const RSqlBufFlat::TCell* aBegin, const RSqlBufFlat::TCell* aCurrent)
1.48 + {
1.49 + __ASSERT_DEBUG(aBegin != NULL && aCurrent != NULL, __SQLPANIC2(ESqlPanicBadArgument));
1.50 + __ASSERT_DEBUG(aCurrent->iPos != 0, __SQLPANIC2(ESqlPanicBadArgument));
1.51 + const TUint8* begin = reinterpret_cast <const TUint8*> (aBegin);
1.52 + return reinterpret_cast <CSqlSecurityPolicy::TPolicyItem*> (const_cast <TUint8*> (begin) + aCurrent->iPos);
1.53 + }
1.54 +
1.55 +/**
1.56 +Searhes the flat buffer for an entry, which "object type" and "object name" attributes match aObjectType and aObjectName parameters.
1.57 +If such entry exists, a pointer to the entry's data will be returned.
1.58 +
1.59 +@param aObjectType Database object type
1.60 +@param aObjectName Database object name
1.61 +
1.62 +@return A pointer to the data of an entry which "object type" and "object name" attributes match aObjectType and aObjectName parameters.
1.63 + If no such entry exists, the function returns NULL.
1.64 +*/
1.65 +const CSqlSecurityPolicy::TPolicyItem* CSqlSecurityPolicy::FindPolicyItemPtr(RSqlSecurityPolicy::TObjectType aObjectType,
1.66 + const TDesC& aObjectName) const
1.67 + {
1.68 + const RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.69 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.70 + const RSqlBufFlat::TCell* end = begin + Count();
1.71 + const RSqlBufFlat::TCell* current = begin + CSqlSecurityPolicy::EDbPolicyIdx;//ignore default and database policiy types ("current" points before the first non-database policy)
1.72 + while(++current < end)
1.73 + {
1.74 + if(current->iPos > 0 && current->Type() == (TInt)aObjectType) //if present and the same type as aObjectType
1.75 + {
1.76 + const CSqlSecurityPolicy::TPolicyItem* item = CSqlSecurityPolicy::PolicyItemPtr(begin, current);
1.77 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.78 + __ASSERT_DEBUG(((current->Size() - sizeof(CSqlSecurityPolicy::TPolicyItem) - sizeof(TInt)) / sizeof(TUint16)) == item->NameSize(), __SQLPANIC(ESqlPanicInternalError));
1.79 + if(::CompareNoCase16(aObjectName, TPtrC(item->NamePtr(), item->NameSize())) == 0)
1.80 + {
1.81 + return item;
1.82 + }
1.83 + }
1.84 + }
1.85 + return NULL;
1.86 + }
1.87 +
1.88 +/**
1.89 +Standard, phase-one CSqlSecurityPolicy factory method.
1.90 +
1.91 +@param aDefaultPolicy Default security policy which will be used as a default replacement for all database and
1.92 + database object security policies.
1.93 +
1.94 +@return A pointer to the created CSqlSecurityPolicy instance.
1.95 +
1.96 +@leave KErrNoMemory, an out of memory condition has occurred;
1.97 +*/
1.98 +CSqlSecurityPolicy* CSqlSecurityPolicy::NewL(const TSecurityPolicy& aDefaultPolicy)
1.99 + {
1.100 + CSqlSecurityPolicy* self = CSqlSecurityPolicy::NewLC(aDefaultPolicy);
1.101 + CleanupStack::Pop(self);
1.102 + return self;
1.103 + }
1.104 +
1.105 +/**
1.106 +Standard, phase-one CSqlSecurityPolicy factory method.
1.107 +
1.108 +@param aDefaultPolicy Default security policy which will be used as a default replacement for all database and
1.109 + database object security policies.
1.110 +
1.111 +@return A pointer to the created CSqlSecurityPolicy instance.
1.112 +
1.113 +@leave KErrNoMemory, an out of memory condition has occurred;
1.114 +*/
1.115 +CSqlSecurityPolicy* CSqlSecurityPolicy::NewLC(const TSecurityPolicy& aDefaultPolicy)
1.116 + {
1.117 + CSqlSecurityPolicy* self = new (ELeave) CSqlSecurityPolicy;
1.118 + CleanupStack::PushL(self);
1.119 + self->ConstructL(aDefaultPolicy);
1.120 + return self;
1.121 + }
1.122 +
1.123 +/**
1.124 +*/
1.125 +CSqlSecurityPolicy::~CSqlSecurityPolicy()
1.126 + {
1.127 + iBufFlat.Close();
1.128 + }
1.129 +
1.130 +/**
1.131 +@return A const reference to the flat buffer
1.132 +*/
1.133 +const RSqlBufFlat& CSqlSecurityPolicy::BufFlat() const
1.134 + {
1.135 + return iBufFlat;
1.136 + }
1.137 +
1.138 +/**
1.139 +@return A reference to the flat buffer
1.140 +*/
1.141 +RSqlBufFlat& CSqlSecurityPolicy::BufFlat()
1.142 + {
1.143 + return iBufFlat;
1.144 + }
1.145 +
1.146 +/**
1.147 +@return Database security policy entry count. This number is at least 2, because every CSqlSecurityPolicy object has by default
1.148 + one default security policy entry and one database security policy entry.
1.149 +*/
1.150 +TInt CSqlSecurityPolicy::Count() const
1.151 + {
1.152 + const RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.153 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.154 + return *reinterpret_cast <const TInt*> (reinterpret_cast <const TUint8*> (begin) + (begin + CSqlSecurityPolicy::ECountIdx)->iPos);
1.155 + }
1.156 +
1.157 +/**
1.158 +Sets the number of database security entries.
1.159 +*/
1.160 +void CSqlSecurityPolicy::SetCount(TInt aCount)
1.161 + {
1.162 + __ASSERT_DEBUG(aCount >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.163 + RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.164 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.165 + *reinterpret_cast <TInt*> (reinterpret_cast <TUint8*> (begin) + (begin + CSqlSecurityPolicy::ECountIdx)->iPos) = aCount;
1.166 + }
1.167 +
1.168 +/**
1.169 +Sets the default policy.
1.170 +*/
1.171 +void CSqlSecurityPolicy::SetDefaultPolicy(const TSecurityPolicy& aPolicy)
1.172 + {
1.173 + RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.174 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.175 + CSqlSecurityPolicy::TPolicyItem* item = CSqlSecurityPolicy::PolicyItemPtr(begin, begin + CSqlSecurityPolicy::EDefaultPolicyIdx);
1.176 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.177 + item->iPolicy[0] = aPolicy;
1.178 + }
1.179 +
1.180 +/**
1.181 +@param aPolicyType Database security policy type: RSqlSecurityPolicy::ESchemaPolicy,
1.182 + RSqlSecurityPolicy::EReadPolicy, RSqlSecurityPolicy::EWritePolicy.
1.183 +@param aPolicy Security policy data used for setting the related database security policy.
1.184 +
1.185 +@panic SqlDb 4 In _DEBUG mode. Invalid policy type.
1.186 +*/
1.187 +void CSqlSecurityPolicy::SetDbPolicy(RSqlSecurityPolicy::TPolicyType aPolicyType, const TSecurityPolicy& aPolicy)
1.188 + {
1.189 + const TInt KPolicyIndex = CSqlSecurityPolicy::PolicyType2Index(aPolicyType);
1.190 + __ASSERT_DEBUG((TUint)KPolicyIndex < EPolicyTypeCount, __SQLPANIC(ESqlPanicBadArgument));
1.191 + RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.192 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.193 + CSqlSecurityPolicy::TPolicyItem* item = CSqlSecurityPolicy::PolicyItemPtr(begin, begin + CSqlSecurityPolicy::EDbPolicyIdx);
1.194 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.195 + //KPolicyIndex value is tested at the beginning of the function
1.196 + //coverity[overrun-local]
1.197 + item->iPolicy[KPolicyIndex] = aPolicy;
1.198 + }
1.199 +
1.200 +/**
1.201 +If there is no entry in the container for the object with aObjectName name, a new entry for this object will be
1.202 +created and all object security policies will be initialized with the default security policy. aPolicyType object
1.203 +policy will be reinitialized with aPolicy argument after that.
1.204 +
1.205 +If an entry for aObjectName object already exists, its aPolicyType security policy will be reinitialized with aPolicy
1.206 +argument.
1.207 +
1.208 +@param aObjectType Database object type. At the moment there is only one database object type allowed for use with
1.209 + SetPolicy() - RSqlSecurityPolicy::ETable.
1.210 +@param aObjectName Database object name. It cannot be a null descriptor.
1.211 +@param aPolicyType Database object security policy type: RSqlSecurityPolicy::EReadPolicy,
1.212 + RSqlSecurityPolicy::EWritePolicy.
1.213 +@param aPolicy Security policy data used for setting the related database object security policy type.
1.214 +
1.215 +@return KErrNone, operation completed successfully;
1.216 + KErrNoMemory, an out of memory condition has occurred;
1.217 + KErrNotSupported, the count of the security policies is too big.
1.218 +
1.219 +@panic SqlDb 4 In _DEBUG mode. Invalid policy type.
1.220 +@panic SqlDb 4 In _DEBUG mode. Invalid database object name (Null descriptor).
1.221 +*/
1.222 +TInt CSqlSecurityPolicy::SetPolicy(RSqlSecurityPolicy::TObjectType aObjectType, const TDesC& aObjectName,
1.223 + RSqlSecurityPolicy::TPolicyType aPolicyType, const TSecurityPolicy& aPolicy)
1.224 + {
1.225 + const TInt KPolicyIndex = CSqlSecurityPolicy::PolicyType2Index(aPolicyType);
1.226 + __ASSERT_DEBUG((TUint)KPolicyIndex < EPolicyTypeCount, __SQLPANIC(ESqlPanicBadArgument));
1.227 + __ASSERT_DEBUG(aObjectName.Length() > 0, __SQLPANIC(ESqlPanicBadArgument));
1.228 + CSqlSecurityPolicy::TPolicyItem* item = const_cast <CSqlSecurityPolicy::TPolicyItem*> (FindPolicyItemPtr(aObjectType, aObjectName));
1.229 + if(item)
1.230 + {//There is a field in the flat buffer for {aObjectType, aObjectName}. Set the policy.
1.231 + //KPolicyIndex value is tested at the beginning of the function
1.232 + //coverity[overrun-local]
1.233 + item->iPolicy[KPolicyIndex] = aPolicy;
1.234 + return KErrNone;
1.235 + }
1.236 + //No field in the flat buffer for {aObjectType, aObjectName}.
1.237 + TInt idx = Count();
1.238 + if(idx >= iBufFlat.Count())
1.239 + {
1.240 + return KErrNotSupported;
1.241 + }
1.242 + //Create and fill a new CSqlSecurityPolicy::TPolicyItem object.
1.243 + const TInt KPolicyDataLen = TPolicyItem::CalcSize(aObjectName.Length());
1.244 + TUint8* buf = new TUint8[KPolicyDataLen];
1.245 + if(!buf)
1.246 + {
1.247 + return KErrNoMemory;
1.248 + }
1.249 + item = reinterpret_cast <CSqlSecurityPolicy::TPolicyItem*> (buf);
1.250 + //coverity[DEADCODE]
1.251 + //The ASSERT might be useful in catching future defect in this function
1.252 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.253 + TSecurityPolicy defaultPolicy = DefaultPolicy();
1.254 + for(TInt i=0;i<CSqlSecurityPolicy::EPolicyTypeCount;++i)
1.255 + {
1.256 + item->iPolicy[i] = defaultPolicy;
1.257 + }
1.258 + item->iPolicy[KPolicyIndex] = aPolicy;
1.259 + //Set the object name length and the object name.
1.260 + *item->NameSizePtr() = aObjectName.Length();
1.261 + TPtr name(item->NamePtr(), item->NameSize());
1.262 + name.Copy(aObjectName);
1.263 + //Copy the item in iBufFlat and release the allocated memory.
1.264 + TInt err = iBufFlat.SetField(idx, (TInt)aObjectType, item, KPolicyDataLen);
1.265 + delete [] buf;
1.266 + if(err == KErrNone)
1.267 + {
1.268 + SetCount(idx + 1);
1.269 + }
1.270 + return err;
1.271 + }
1.272 +
1.273 +/**
1.274 +@return The default security policy.
1.275 +*/
1.276 +TSecurityPolicy CSqlSecurityPolicy::DefaultPolicy() const
1.277 + {
1.278 + const RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.279 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.280 + const CSqlSecurityPolicy::TPolicyItem* item = CSqlSecurityPolicy::PolicyItemPtr(begin, begin + CSqlSecurityPolicy::EDefaultPolicyIdx);
1.281 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.282 + return item->iPolicy[0];
1.283 + }
1.284 +
1.285 +/**
1.286 +@param aPolicyType Database security policy type: RSqlSecurityPolicy::ESchemaPolicy,
1.287 + RSqlSecurityPolicy::EReadPolicy, RSqlSecurityPolicy::EWritePolicy.
1.288 +
1.289 +Note: By default all database security policies will be initialized with the default security policy.
1.290 +
1.291 +@return The requested database security policy.
1.292 +
1.293 +@panic SqlDb 4 In _DEBUG mode. Invalid policy type.
1.294 +*/
1.295 +TSecurityPolicy CSqlSecurityPolicy::DbPolicy(RSqlSecurityPolicy::TPolicyType aPolicyType) const
1.296 + {
1.297 + const TInt KPolicyIndex = CSqlSecurityPolicy::PolicyType2Index(aPolicyType);
1.298 + __ASSERT_DEBUG((TUint)KPolicyIndex < EPolicyTypeCount, __SQLPANIC(ESqlPanicBadArgument));
1.299 + const RSqlBufFlat::TCell* begin = iBufFlat.Header();
1.300 + __ASSERT_DEBUG(begin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.301 + const CSqlSecurityPolicy::TPolicyItem* item = CSqlSecurityPolicy::PolicyItemPtr(begin, begin + CSqlSecurityPolicy::EDbPolicyIdx);
1.302 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.303 + //KPolicyIndex value is tested at the beginning of the function
1.304 + //coverity[overrun-local]
1.305 + return item->iPolicy[KPolicyIndex];
1.306 + }
1.307 +
1.308 +/**
1.309 +Searches the container for an entry belonging to an object with aObjectName name and aObjectType type. If such entry
1.310 +exists the method returns aPolicyType object security policy.
1.311 +
1.312 +If there is no entry for the object with aObjectName name, the default security policy will be returned.
1.313 +
1.314 +@param aObjectType Database object type. At the moment there is only one database object type allowed for use with
1.315 + Policy() - RSqlSecurityPolicy::ETable.
1.316 +@param aObjectName Database object name. It cannot be a null descriptor.
1.317 +@param aPolicyType Database object security policy type: RSqlSecurityPolicy::ERead, RSqlSecurityPolicy::EWrite.
1.318 +
1.319 +Note: By default all database object security policies will be initialized with the default security policy.
1.320 +
1.321 +@return The requested security policy
1.322 +
1.323 +@panic SqlDb 4 In _DEBUG mode. Invalid policy type.
1.324 +@panic SqlDb 4 In _DEBUG mode. Invalid onject name (Null descriptor).
1.325 +*/
1.326 +TSecurityPolicy CSqlSecurityPolicy::Policy(RSqlSecurityPolicy::TObjectType aObjectType,
1.327 + const TDesC& aObjectName, RSqlSecurityPolicy::TPolicyType aPolicyType)
1.328 + {
1.329 + const TInt KPolicyIndex = CSqlSecurityPolicy::PolicyType2Index(aPolicyType);
1.330 + __ASSERT_DEBUG((TUint)KPolicyIndex < EPolicyTypeCount, __SQLPANIC(ESqlPanicBadArgument));
1.331 + __ASSERT_DEBUG(aObjectName.Length() > 0, __SQLPANIC(ESqlPanicBadArgument));
1.332 + const CSqlSecurityPolicy::TPolicyItem* item = FindPolicyItemPtr(aObjectType, aObjectName);
1.333 + //KPolicyIndex value is tested at the beginning of the function
1.334 + //coverity[overrun-local]
1.335 + return item ? item->iPolicy[KPolicyIndex] : DefaultPolicy();
1.336 + }
1.337 +
1.338 +/**
1.339 +*/
1.340 +CSqlSecurityPolicy::CSqlSecurityPolicy()
1.341 + {
1.342 + }
1.343 +
1.344 +/**
1.345 +Standard, phase-two CSqlSecurityPolicy construction method.
1.346 +
1.347 +Note: By default all database security policies will be initialized with the default security policy.
1.348 +
1.349 +@param aDefaultPolicy Security policy data used for setting the default database security policy and
1.350 + database security policies.
1.351 +
1.352 +@leave KErrNoMemory, an out of memory condition has occurred;
1.353 +*/
1.354 +void CSqlSecurityPolicy::ConstructL(const TSecurityPolicy& aDefaultPolicy)
1.355 + {
1.356 + //Create the policy flat buffer.
1.357 + __SQLLEAVE_IF_ERROR(iBufFlat.SetCount(CSqlSecurityPolicy::EMaxCount));
1.358 + //Reserve places for the default policy and database policies.
1.359 + CSqlSecurityPolicy::TPolicyItem item;
1.360 + for(TInt i=0;i<CSqlSecurityPolicy::EPolicyTypeCount;++i)
1.361 + {
1.362 + item.iPolicy[i] = aDefaultPolicy;
1.363 + }
1.364 + TInt count = CSqlSecurityPolicy::EDbPolicyIdx + 1;//count + default policy + database policy;
1.365 + __SQLLEAVE_IF_ERROR(iBufFlat.SetField(CSqlSecurityPolicy::ECountIdx, 0, &count, sizeof(count)));
1.366 + __SQLLEAVE_IF_ERROR(iBufFlat.SetField(CSqlSecurityPolicy::EDefaultPolicyIdx, 0, &item, sizeof(item) - sizeof(TSecurityPolicy) * (CSqlSecurityPolicy::EPolicyTypeCount - 1)));
1.367 + __SQLLEAVE_IF_ERROR(iBufFlat.SetField(CSqlSecurityPolicy::EDbPolicyIdx, 0, &item, sizeof(item)));
1.368 + }
1.369 +
1.370 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.371 +//////////////////// TSqlSecurityPolicyIterator implementation //////////////////////////////
1.372 +///////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.373 +
1.374 +/**
1.375 +@param aSecuritySettings Const reference to CSqlSecurityPolicy object on which content the iterator will work.
1.376 +*/
1.377 +TSqlSecurityPolicyIterator::TSqlSecurityPolicyIterator(const CSqlSecurityPolicy& aSqlSecurityPolicy) :
1.378 + iBegin(aSqlSecurityPolicy.iBufFlat.Header()),
1.379 + iCurrent(iBegin + CSqlSecurityPolicy::EDbPolicyIdx),//ignore the default and database policies
1.380 + iEnd(iBegin + aSqlSecurityPolicy.Count()),
1.381 + iCurPolicyIdx(CSqlSecurityPolicy::EPolicyTypeCount)
1.382 + {
1.383 + __ASSERT_DEBUG(iBegin != NULL, __SQLPANIC(ESqlPanicInternalError));
1.384 + }
1.385 +
1.386 +/**
1.387 +Moves the iterator one step forward and gives a read-only access to the next database object security policy.
1.388 +
1.389 +@param aObjectType Output parameter. Next database object type, if the iteration was successful.
1.390 +@param aObjectName Output parameter. Set to point to the next database object name, if the iteration was successful.
1.391 +@param aPolicyType Output parameter. Next database object security policy type, if the iteration was successful.
1.392 +@param aPolicy Output parameter. Next database object security policy, if the iteration was successful.
1.393 +
1.394 +@return Non-zero - successful iteration step, zero otherwise (no more security policies in the CSqlSecurityPolicy container).
1.395 +*/
1.396 +TBool TSqlSecurityPolicyIterator::Next(RSqlSecurityPolicy::TObjectType& aObjectType, TPtrC& aObjectName,
1.397 + RSqlSecurityPolicy::TPolicyType& aPolicyType, TSecurityPolicy& aPolicy)
1.398 + {
1.399 + if(++iCurPolicyIdx >= CSqlSecurityPolicy::EPolicyTypeCount)
1.400 + {
1.401 + iCurPolicyIdx = static_cast <TInt> (RSqlSecurityPolicy::EReadPolicy);
1.402 + if(++iCurrent >= iEnd)
1.403 + {
1.404 + return EFalse;
1.405 + }
1.406 + }
1.407 + const CSqlSecurityPolicy::TPolicyItem* item = CSqlSecurityPolicy::PolicyItemPtr(iBegin, iCurrent);
1.408 + __ASSERT_DEBUG(item != NULL, __SQLPANIC(ESqlPanicInternalError));
1.409 + aObjectType = static_cast <RSqlSecurityPolicy::TObjectType> (iCurrent->Type());
1.410 + aPolicyType = static_cast <RSqlSecurityPolicy::TPolicyType> (iCurPolicyIdx);
1.411 + aPolicy = item->iPolicy[iCurPolicyIdx];
1.412 + aObjectName.Set(item->NamePtr(), item->NameSize());
1.413 + return ETrue;
1.414 + }