1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/security/SC_Policy.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,655 @@
1.4 +// Copyright (c) 2004-2009 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 +// CPolicyBase, CDbPolicy, CTblPolicy, CPolicyDomain classes
1.18 +//
1.19 +//
1.20 +
1.21 +#include "SC_Policy.h"
1.22 +
1.23 +namespace DBSC
1.24 +{
1.25 +
1.26 +///////////////////////////////////////////////////////////////////////////////////////////
1.27 +//CPolicyBase class
1.28 +
1.29 +/**
1.30 +*/
1.31 +CPolicyBase::~CPolicyBase()
1.32 + {
1.33 + iPolicyCollection.Close();//Collection of R/W/S security policies
1.34 + }
1.35 +
1.36 +#ifdef __DBDUMP__
1.37 +/**
1.38 +Dumps the content of a CPolicyBase instance to a text file.
1.39 +@param aFile A reference to RFile object, which has to be used for the output.
1.40 +*/
1.41 +void CPolicyBase::Dump(RFile& aFile) const
1.42 + {
1.43 + DB_INVARIANT();
1.44 +
1.45 + _LIT8(KClassName, "Class: CPolicyBase. this=%X");
1.46 + _LIT8(KCount, "Security Policy, Count=%d");
1.47 + _LIT8(KCrLf, "\r\n");
1.48 + _LIT8(KPolicyType, "Policy type: ");
1.49 + _LIT8(KRead, "Read, ");
1.50 + _LIT8(KWrite, "Write, ");
1.51 + _LIT8(KSchema, "Schema, ");
1.52 + _LIT8(KPolicyData, "Policy data: ");
1.53 + _LIT8(KFmt, "%02X ");
1.54 + TBuf8<100> buf;
1.55 +
1.56 + buf.Format(KClassName, this);
1.57 + (void)aFile.Write(buf);
1.58 + (void)aFile.Write(KCrLf);
1.59 +
1.60 + TInt cnt = iPolicyCollection.Count();
1.61 + buf.Format(KCount, TInt32(cnt));
1.62 + (void)aFile.Write(buf);
1.63 + (void)aFile.Write(KCrLf);
1.64 +
1.65 + for(TInt i=0;i<cnt;++i)
1.66 + {
1.67 + const TPolicy& policy = iPolicyCollection[i];
1.68 + (void)aFile.Write(KPolicyType);
1.69 + switch(policy.iType)
1.70 + {
1.71 + case EPTRead:
1.72 + (void)aFile.Write(KRead);
1.73 + break;
1.74 + case EPTWrite:
1.75 + (void)aFile.Write(KWrite);
1.76 + break;
1.77 + case EPTSchema:
1.78 + (void)aFile.Write(KSchema);
1.79 + break;
1.80 + default:
1.81 + __ASSERT(0);
1.82 + break;
1.83 + }
1.84 + (void)aFile.Write(KPolicyData);
1.85 + TPtrC8 packet = policy.iData.Package();
1.86 + TInt len = packet.Length();
1.87 + for(TInt j=0;j<len;++j)
1.88 + {
1.89 + buf.Format(KFmt, packet[j]);
1.90 + (void)aFile.Write(buf);
1.91 + }
1.92 + (void)aFile.Write(KCrLf);
1.93 + }
1.94 + }
1.95 +#endif//__DBDUMP__
1.96 +
1.97 +/**
1.98 +Standard phase-two construction method for CPolicyBase instance.
1.99 +@param aPolicyCollection A const reference to a collection of R/W/S policies, which has to
1.100 + be used to control the access to a database object, controlled by CPolicyBase
1.101 + instance.
1.102 +*/
1.103 +void CPolicyBase::ConstructL(const CPolicyBase::RPolicyCollection& aPolicyCollection)
1.104 + {
1.105 + iPolicyCollection.Reset();
1.106 + TInt cnt = aPolicyCollection.Count();
1.107 + for(TInt i=0;i<cnt;++i)
1.108 + {
1.109 + __LEAVE_IF_ERROR(iPolicyCollection.Append(aPolicyCollection[i]));
1.110 + }
1.111 + DB_INVARIANT();
1.112 + }
1.113 +
1.114 +/**
1.115 +It is used in the production code.
1.116 +If the object data is not in a consistent state, the method will leave
1.117 +with KErrGeneral error.
1.118 +@leave KErrGeneral, if the object data is not in a consistent state
1.119 +*/
1.120 +void CPolicyBase::InvariantL() const
1.121 + {
1.122 + TUint32 mask = 0;
1.123 + for(TInt i=(iPolicyCollection.Count()-1);i>-1;--i)
1.124 + {
1.125 + TPolicy& policy = const_cast <TPolicy&> (iPolicyCollection[i]);
1.126 + if(policy.iType == EPTNone)
1.127 + {
1.128 + __LEAVE(KErrGeneral);
1.129 + }
1.130 + if(mask & policy.iType) //This security policy is duplicated
1.131 + {
1.132 + __LEAVE(KErrGeneral);
1.133 + }
1.134 + TPtrC8 packet = policy.iData.Package();
1.135 + if(policy.iData.Set(packet) != KErrNone)
1.136 + {
1.137 + __LEAVE(KErrGeneral);
1.138 + }
1.139 + mask |= policy.iType;
1.140 + }
1.141 + }
1.142 +
1.143 +/**
1.144 +This method implements pure virtual MPolicy::Get().
1.145 +It searches object's policy collection for a policy of type aPolicyType
1.146 +and initializes aPolicy parameter with the found policy.
1.147 +@param aPolicyType Type of the requested security policy: read/write/schema
1.148 +@param aPolicy Outout parameter, which will be initialized with the found security policy data.
1.149 +@return System-wide error code, including KErrNotFound if the requested policy was not found.
1.150 +*/
1.151 +TInt CPolicyBase::Get(TPolicyType aPolicyType, TSecurityPolicy& aPolicy) const
1.152 + {
1.153 + DB_INVARIANT();
1.154 + TInt err = KErrNotFound;
1.155 + const TSecurityPolicy* securityPolicy = Policy(aPolicyType);
1.156 + if(securityPolicy)
1.157 + {
1.158 + err = aPolicy.Set(securityPolicy->Package());
1.159 + }
1.160 + return err;
1.161 + }
1.162 +
1.163 +#ifdef __DBINVARIANT__
1.164 +/**
1.165 +Asserts the internal state of CPolicyBase instance.
1.166 +It can be used for pre- or post- condition checks in CPolicyBase methods implementations.
1.167 +*/
1.168 +void CPolicyBase::Invariant() const
1.169 + {
1.170 + TRAPD(err, InvariantL());
1.171 + DB_INVARIANT_ASSERT(err == KErrNone);
1.172 + }
1.173 +#endif//__DBINVARIANT__
1.174 +
1.175 +/**
1.176 +The method traverses the policies collection and searches for a policy of aPolicyType type.
1.177 +If such a policy exists, a const pointer to it will be returned, otherwise - NULL.
1.178 +@param aPolicyType Policy type - R/W/S
1.179 +@return A const pointer to the found policy or NULL if not found.
1.180 +*/
1.181 +const TSecurityPolicy* CPolicyBase::Policy(TPolicyType aPolicyType) const
1.182 + {
1.183 + __ASSERT(aPolicyType != EPTNone);
1.184 + const TSecurityPolicy* policy = NULL;
1.185 + for(TInt i=(iPolicyCollection.Count()-1);i>-1;--i)
1.186 + {
1.187 + if(iPolicyCollection[i].iType == aPolicyType)
1.188 + {
1.189 + policy = &iPolicyCollection[i].iData;
1.190 + break;
1.191 + }
1.192 + }
1.193 + return policy;
1.194 + }
1.195 +
1.196 +/**
1.197 +Asserts caller capabilities/SID/VID.
1.198 +@param aMessage An object whith caller capabilities/SID/VID, which has to be checked.
1.199 +@param aPolicyType Policy type - R/W/S.
1.200 +@return EPCNotFound - the policy cannot be found
1.201 + EPCPassed - policy check passed
1.202 + EPCNotPassed - policy check not passed
1.203 +*/
1.204 +CPolicyBase::TPolicyCheckResult CPolicyBase::DoCheck(const RMessage2& aMessage, TPolicyType aPolicyType) const
1.205 + {
1.206 + const TSecurityPolicy* securityPolicy = Policy(aPolicyType);
1.207 +
1.208 + if(!securityPolicy)
1.209 + {
1.210 + return EPCNotFound;
1.211 + }
1.212 +
1.213 + return securityPolicy->CheckPolicy(aMessage) ? EPCPassed : EPCNotPassed;
1.214 + }
1.215 +
1.216 +///////////////////////////////////////////////////////////////////////////////////////////
1.217 +//CDbPolicy class
1.218 +
1.219 +/**
1.220 +*/
1.221 +CDbPolicy::~CDbPolicy()
1.222 + {
1.223 + }
1.224 +
1.225 +/**
1.226 +Asserts caller capabilities/SID/VID.
1.227 +@param aMessage An object whith caller capabilities/SID/VID, which has to be checked.
1.228 +@param aPolicyType Policy type - R/W/S.
1.229 +@return ETrue The caller capabilities/SID/VID satisfy the specified security policy.
1.230 + EFalse The check not passed.
1.231 +@panic EDBSCPolicyNotFound, if there is no such policy
1.232 +*/
1.233 +TBool CDbPolicy::Check(const RMessage2& aMessage, TPolicyType aPolicyType) const
1.234 + {
1.235 + __ASSERT(aPolicyType != EPTNone);
1.236 + DB_INVARIANT();
1.237 + TPolicyCheckResult res = DoCheck(aMessage, aPolicyType);
1.238 + __ASSERT(res != EPCNotFound);
1.239 + return res == EPCPassed ? ETrue : EFalse;
1.240 + }
1.241 +
1.242 +/**
1.243 +Standard phase-one factory method for CDbPolicy instance.
1.244 +@param aPolicyCollection A const reference to a collection of R/W/S policies, which has to
1.245 + be used to control the access to the database, controlled by CDbPolicy instance.
1.246 +@return A pointer to just created CDbPolicy instance.
1.247 +@leave System-wide error codes, including KErrNoMemory.
1.248 +*/
1.249 +CDbPolicy* CDbPolicy::NewLC(const CPolicyBase::RPolicyCollection& aPolicyCollection)
1.250 + {
1.251 + CDbPolicy* self = new (ELeave) CDbPolicy;
1.252 + CleanupStack::PushL(self);
1.253 + self->ConstructL(aPolicyCollection);
1.254 + return self;
1.255 + }
1.256 +
1.257 +#ifdef __DBDUMP__
1.258 +/**
1.259 +Dumps the content of a CDbPolicy instance to a text file.
1.260 +@param aFile A reference to RFile object, which has to be used for the output.
1.261 +*/
1.262 +void CDbPolicy::Dump(RFile& aFile) const
1.263 + {
1.264 + DB_INVARIANT();
1.265 +
1.266 + _LIT8(KClassName, "Class: CDbPolicy. this=%X");
1.267 + _LIT8(KCrLf, "\r\n");
1.268 + _LIT8(KObjType, "Object: Database");
1.269 + _LIT8(KEnd, "==========================");
1.270 + TBuf8<40> buf;
1.271 +
1.272 + buf.Format(KClassName, this);
1.273 + (void)aFile.Write(buf);
1.274 + (void)aFile.Write(KCrLf);
1.275 + (void)aFile.Write(KObjType);
1.276 + (void)aFile.Write(KCrLf);
1.277 + CPolicyBase::Dump(aFile);
1.278 + (void)aFile.Write(KEnd);
1.279 + (void)aFile.Write(KCrLf);
1.280 + }
1.281 +#endif//__DBDUMP__
1.282 +
1.283 +/**
1.284 +It is used in the production code.
1.285 +If the object data is not in a consistent state, the method will leave
1.286 +with KErrGeneral error.
1.287 +@leave KErrGeneral, if the object data is not in a consistent state
1.288 +*/
1.289 +void CDbPolicy::InvariantL() const
1.290 + {
1.291 + for(TInt c=0;c<KPolicyTypesCount;++c)
1.292 + {
1.293 + TPolicyType t = static_cast <TPolicyType> (1 << c);
1.294 + if(Policy(t) == NULL)
1.295 + {
1.296 + __LEAVE(KErrGeneral);
1.297 + }
1.298 + }
1.299 + CPolicyBase::InvariantL();
1.300 + }
1.301 +
1.302 +///////////////////////////////////////////////////////////////////////////////////////////
1.303 +//CTblPolicy class
1.304 +
1.305 +/**
1.306 +*/
1.307 +CTblPolicy::~CTblPolicy()
1.308 + {
1.309 + delete iTblName;
1.310 + }
1.311 +
1.312 +/**
1.313 +Asserts caller capabilities/SID/VID.
1.314 +@param aMessage An object whith caller capabilities/SID/VID, which has to be checked.
1.315 +@param aPolicyType Policy type - R/W/S.
1.316 +@return ETrue The caller capabilities/SID/VID satisfy the specified security policy.
1.317 + EFalse The check not passed.
1.318 +@panic EDBSCPolicyNotFound, if there is no such policy
1.319 +*/
1.320 +TBool CTblPolicy::Check(const RMessage2& aMessage, TPolicyType aPolicyType) const
1.321 + {
1.322 + __ASSERT(aPolicyType != EPTNone);
1.323 + __ASSERT(iDbPolicy);
1.324 + DB_INVARIANT();
1.325 + TPolicyCheckResult res = EPCNotPassed;
1.326 + //1. Check database security policy
1.327 + if(iDbPolicy->Check(aMessage, aPolicyType))
1.328 + {
1.329 + //2. Check table security policy
1.330 + res = DoCheck(aMessage, aPolicyType);
1.331 + }
1.332 + //If there is no table security policy of the requested type - no problem, the database
1.333 + //security policy of that type has been checked already and the check passed.
1.334 + return res == EPCNotPassed ? EFalse : ETrue;
1.335 + }
1.336 +
1.337 +/**
1.338 +This method implements pure virtual MPolicy::Get().
1.339 +It searches object's policy collection for a policy of type aPolicyType
1.340 +and initializes aPolicy parameter with the found policy.
1.341 +@param aPolicyType Type of the requested security policy: read/write
1.342 +@param aPolicy Outout parameter, which will be initialized with the found security policy data.
1.343 +@return System-wide error codes, including KErrNotSupported, if the request is for a schema policy.
1.344 +*/
1.345 +TInt CTblPolicy::Get(TPolicyType aPolicyType, TSecurityPolicy& aPolicy) const
1.346 + {
1.347 + if(aPolicyType == EPTSchema)
1.348 + {
1.349 + return KErrNotSupported;
1.350 + }
1.351 + DB_INVARIANT();
1.352 + TInt err = CPolicyBase::Get(aPolicyType, aPolicy);
1.353 + if(err == KErrNotFound)
1.354 + {
1.355 + err = iDbPolicy->Get(aPolicyType, aPolicy);
1.356 + }
1.357 + __ASSERT(err != KErrNotFound);
1.358 + return err;
1.359 + }
1.360 +
1.361 +/**
1.362 +Standard phase-one factory method for CTblPolicy instance.
1.363 +@param aTblName Name of the controlled by this instance database table.
1.364 +@param aPolicyCollection A const reference to a collection of R/W/S policies, which has to
1.365 + be used to control the access to the table, controlled by CTblPolicy instance.
1.366 +@param aDbPolicy The related for the table database policy.
1.367 + CTblPolicy instance does not take the ownership on aDbPolicy pointer!
1.368 +@return A pointer to just created CTblPolicy instance.
1.369 +@leave System-wide error codes, including KErrNoMemory.
1.370 +*/
1.371 +CTblPolicy* CTblPolicy::NewLC(const TDesC& aTblName,
1.372 + const CPolicyBase::RPolicyCollection& aPolicyCollection,
1.373 + const CDbPolicy* aDbPolicy)
1.374 + {
1.375 + CTblPolicy* self = new (ELeave) CTblPolicy(aDbPolicy);
1.376 + CleanupStack::PushL(self);
1.377 + self->ConstructL(aTblName, aPolicyCollection);
1.378 + return self;
1.379 + }
1.380 +
1.381 +#ifdef __DBDUMP__
1.382 +/**
1.383 +Dumps the content of a CTblPolicy instance to a text file.
1.384 +@param aFile A reference to RFile object, which has to be used for the output.
1.385 +*/
1.386 +void CTblPolicy::Dump(RFile& aFile) const
1.387 + {
1.388 + DB_INVARIANT();
1.389 +
1.390 + _LIT8(KClassName, "Class: CTblPolicy. this=%X");
1.391 + _LIT8(KDbPolicyPtr, "Db policy ptr=%X");
1.392 + _LIT8(KCrLf, "\r\n");
1.393 + _LIT8(KName, "Table name: ");
1.394 + _LIT8(KObjType, "Object: Table");
1.395 + _LIT8(KEnd, "==========================");
1.396 + TBuf8<100> buf;
1.397 +
1.398 + buf.Format(KClassName, this);
1.399 + (void)aFile.Write(buf);
1.400 + (void)aFile.Write(KCrLf);
1.401 + (void)aFile.Write(KObjType);
1.402 + (void)aFile.Write(KCrLf);
1.403 + buf.Format(KDbPolicyPtr, iDbPolicy);
1.404 + (void)aFile.Write(buf);
1.405 + (void)aFile.Write(KCrLf);
1.406 + buf.Copy(KName);
1.407 + buf.Append(*iTblName);
1.408 + (void)aFile.Write(buf);
1.409 + (void)aFile.Write(KCrLf);
1.410 + CPolicyBase::Dump(aFile);
1.411 + (void)aFile.Write(KEnd);
1.412 + (void)aFile.Write(KCrLf);
1.413 + }
1.414 +#endif//__DBDUMP__
1.415 +
1.416 +/**
1.417 +It is used in the production code.
1.418 +If the object data is not in a consistent state, the method will leave
1.419 +with KErrGeneral error.
1.420 +@leave KErrGeneral, if the object data is not in a consistent state
1.421 +*/
1.422 +void CTblPolicy::InvariantL() const
1.423 + {
1.424 + if(iDbPolicy == NULL)
1.425 + {
1.426 + __LEAVE(KErrGeneral);
1.427 + }
1.428 + if(iTblName == NULL || iTblName->Length() == 0)
1.429 + {
1.430 + __LEAVE(KErrGeneral);
1.431 + }
1.432 + if(Policy(EPTSchema) != NULL)
1.433 + {
1.434 + __LEAVE(KErrGeneral);
1.435 + }
1.436 + CPolicyBase::InvariantL();
1.437 + }
1.438 +
1.439 +/**
1.440 +Standard phase-two construction method for CTblPolicy instance.
1.441 +@param aTblName Name of the controlled by this instance database table.
1.442 +@param aPolicyCollection A const reference to a collection of R/W/S policies, which has to
1.443 + be used to control the access to the table object, controlled by CTblPolicy
1.444 + instance.
1.445 +*/
1.446 +void CTblPolicy::ConstructL(const TDesC& aTblName, const CPolicyBase::RPolicyCollection& aPolicyCollection)
1.447 + {
1.448 + iTblName = HBufC::NewL(aTblName.Length());
1.449 + *iTblName = aTblName;
1.450 + CPolicyBase::ConstructL(aPolicyCollection);
1.451 + DB_INVARIANT();
1.452 + }
1.453 +
1.454 +///////////////////////////////////////////////////////////////////////////////////////////
1.455 +//CPolicyDomain class
1.456 +
1.457 +/**
1.458 +Standard phase-one factory method for CPolicyDomain instance.
1.459 +@param aUid UID of the controlled by this instance security policy domain.
1.460 +@param aPDLoader A reference to an implementation of MPolicyDomainLoader interface,
1.461 + which is used to load and add security policies to the controlled collection.
1.462 +@return A pointer to just created CPolicyDomain instance.
1.463 +@leave System-wide error codes, including KErrNoMemory.
1.464 +*/
1.465 +CPolicyDomain* CPolicyDomain::NewLC(TUid aUid, MPolicyDomainLoader& aPDLoader)
1.466 + {
1.467 + CPolicyDomain* self = new (ELeave) CPolicyDomain(aUid);
1.468 + CleanupStack::PushL(self);
1.469 + self->InternalizeL(aPDLoader);
1.470 + return self;
1.471 + }
1.472 +
1.473 +/**
1.474 +*/
1.475 +CPolicyDomain::~CPolicyDomain()
1.476 + {
1.477 + Destroy();
1.478 + }
1.479 +
1.480 +/**
1.481 +The method returns the database policy interface.
1.482 +@return A const pointer to the database policy interface in CPolicyDomain.
1.483 +*/
1.484 +const MPolicy* CPolicyDomain::DbPolicy() const
1.485 + {
1.486 + DB_INVARIANT();
1.487 + return iDbPolicy;
1.488 + }
1.489 +
1.490 +/**
1.491 +The method returns a table policy interface, identified by aTblName parameter.
1.492 +@param aTblName Name of the table, which policy interface has to be retrieved.
1.493 +@return A const pointer to the table policy interface, which is identified by aTblName parameter.
1.494 +*/
1.495 +const MPolicy* CPolicyDomain::TblPolicy(const TDesC& aTblName) const
1.496 + {
1.497 + __ASSERT(aTblName.Length() > 0);
1.498 + DB_INVARIANT();
1.499 + const MPolicy* policy = NULL;
1.500 + TInt cnt = iTPCollection.Count();
1.501 + for(TInt i=0;i<cnt;++i)
1.502 + {
1.503 + CTblPolicy* tblPolicy = iTPCollection[i];
1.504 + __ASSERT(tblPolicy);
1.505 + if(aTblName.CompareF(tblPolicy->TableName()) == 0)
1.506 + {
1.507 + policy = tblPolicy;
1.508 + break;
1.509 + }
1.510 + }
1.511 + if(!policy)
1.512 + {
1.513 + policy = iDbPolicy;
1.514 + }
1.515 + __ASSERT(policy);
1.516 + return policy;
1.517 + }
1.518 +
1.519 +/**
1.520 +Externalizes the security policy collection using MPolicyDomainPersister interface as an
1.521 +persister.
1.522 +@param aPDPersister A reference to an MPolicyDomainPersister implementation, which will
1.523 + persist the controlled collection of security policies.
1.524 +*/
1.525 +void CPolicyDomain::ExternalizeL(MPolicyDomainPersister& aPDPersister) const
1.526 + {
1.527 + DB_INVARIANT();
1.528 + TPolicyDomainReader reader(*this);
1.529 + aPDPersister.RunL(reader);
1.530 + }
1.531 +
1.532 +#ifdef __DBDUMP__
1.533 +/**
1.534 +Dumps the content of a CPolicyDomain instance to a text file.
1.535 +@param aFile A reference to RFile object, which has to be used for the output.
1.536 +*/
1.537 +void CPolicyDomain::Dump(RFile& aFile) const
1.538 + {
1.539 + DB_INVARIANT();
1.540 +
1.541 + _LIT8(KClassName, "Class: CPolicyDomain. this=%X");
1.542 + _LIT8(KUidFmt, "UID=%X");
1.543 + _LIT8(KCrLf, "\r\n");
1.544 + _LIT8(KEnd, "==========================");
1.545 + _LIT8(KBackupSIDFmt, "BackupSID=%X");
1.546 + TBuf8<40> buf;
1.547 +
1.548 + buf.Format(KClassName, this);
1.549 + (void)aFile.Write(buf);
1.550 + (void)aFile.Write(KCrLf);
1.551 + buf.Format(KUidFmt, iUid.iUid);
1.552 + (void)aFile.Write(buf);
1.553 + (void)aFile.Write(KCrLf);
1.554 + (void)aFile.Write(KEnd);
1.555 + (void)aFile.Write(KCrLf);
1.556 + iDbPolicy->Dump(aFile);
1.557 + TInt cnt = iTPCollection.Count();
1.558 + for(TInt i=0;i<cnt;++i)
1.559 + {
1.560 + __ASSERT(iTPCollection[i]);
1.561 + iTPCollection[i]->Dump(aFile);
1.562 + }
1.563 + (void)aFile.Write(KEnd);
1.564 + buf.Format(KBackupSIDFmt, iBackupSID.iUid);
1.565 + (void)aFile.Write(buf);
1.566 + (void)aFile.Write(KCrLf);
1.567 + }
1.568 +#endif//__DBDUMP__
1.569 +
1.570 +/**
1.571 +It is used in the production code.
1.572 +If the object data is not in a consistent state, the method will leave
1.573 +with KErrGeneral error.
1.574 +@leave KErrGeneral, if the object data is not in a consistent state
1.575 +*/
1.576 +void CPolicyDomain::InvariantL() const
1.577 + {
1.578 + if(iUid == KNullUid)
1.579 + {
1.580 + __LEAVE(KErrGeneral);
1.581 + }
1.582 + if(iDbPolicy == NULL)
1.583 + {
1.584 + __LEAVE(KErrGeneral);
1.585 + }
1.586 + iDbPolicy->InvariantL();
1.587 +
1.588 + TInt cnt = iTPCollection.Count();
1.589 + TInt i;
1.590 + for(i=0;i<cnt;++i)
1.591 + {
1.592 + if(iTPCollection[i] == NULL)
1.593 + {
1.594 + __LEAVE(KErrGeneral);
1.595 + }
1.596 + iTPCollection[i]->InvariantL();
1.597 + }
1.598 + //Check that each represented table has unique name
1.599 + for(i=0;i<(cnt-1);++i)
1.600 + {
1.601 + for(TInt j=(i+1);j<cnt;++j)
1.602 + {
1.603 + if(iTPCollection[i]->TableName() == iTPCollection[j]->TableName())
1.604 + {
1.605 + __LEAVE(KErrGeneral);
1.606 + }
1.607 + }
1.608 + }
1.609 + }
1.610 +
1.611 +#ifdef __DBINVARIANT__
1.612 +/**
1.613 +Asserts the internal state of CPolicyDomain instance.
1.614 +It can be used for pre- or post- condition checks in CPolicyDomain methods implementations.
1.615 +*/
1.616 +void CPolicyDomain::Invariant() const
1.617 + {
1.618 + TRAPD(err, InvariantL());
1.619 + DB_INVARIANT_ASSERT(err == KErrNone);
1.620 + }
1.621 +#endif//__DBINVARIANT__
1.622 +
1.623 +/**
1.624 +Creates the collection of security policies using MPolicyDomainLoader interface as a security
1.625 +policy loader.
1.626 +@param aPDLoader A reference to MPolicyDomainLoader implementation, which is used to load
1.627 + and add security policies to the controlled collection.
1.628 +@leave System-wide error code including KErrGeneral if the data is not consistent
1.629 +*/
1.630 +void CPolicyDomain::InternalizeL(MPolicyDomainLoader& aPDLoader)
1.631 + {
1.632 + TPolicyDomainBuilder builder(*this);
1.633 + aPDLoader.RunL(builder);
1.634 +#ifdef __DBINVARIANT__
1.635 + Invariant();
1.636 +#else
1.637 + InvariantL();
1.638 +#endif
1.639 + }
1.640 +
1.641 +/**
1.642 +The method destroys the controlled by CPolicyDomain collection of security policies.
1.643 +*/
1.644 +void CPolicyDomain::Destroy()
1.645 + {
1.646 + TInt cnt = iTPCollection.Count();
1.647 + for(TInt i=0;i<cnt;++i)
1.648 + {
1.649 + __ASSERT(iTPCollection[i]);
1.650 + delete iTPCollection[i];
1.651 + }
1.652 + iTPCollection.Close();
1.653 + delete iDbPolicy;
1.654 + iDbPolicy = NULL;
1.655 + }
1.656 +
1.657 +} //end of - namespace DBSC
1.658 +