/*
* Copyright (c) 2002-2005 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:
*
*/
#include "senwspolicymanager.h"
#include "seninternalwspolicy.h"
#include <s32mem.h>
#include <s32file.h>
#include <sysutil.h>
#include <SenFacet.h>
#include <SenXmlUtils.h>
#include "sendebug.h" // internal \Utils\inc - filelogging MACROs
#include "msencoreservicemanager.h" // internal \Framework\inc
#include "SenParser.h"
#include "SenDateUtils.h"
#include "senservicepolicy.h"
#include "wspolicyutils.h"
#include "wspolicy.h"
#include "senguidgen.h"
#include "senxmldebug.h"
#include "senlogger.h"
#include <SenServiceConnection.h>
#include <xml/dom/xmlengnodelist.h>
using namespace WSPolicy;
using namespace SenWSInternalPolicy;
namespace
{
#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )
_LIT(KWsPolicyFile, "C:\\system\\data\\senwspolicies.xml");
#else
_LIT(KWsPolicyFile, "senwspolicies.xml");
#endif
const TInt KStateParsingContainer = 99;
const TInt KStateParsingIdentifier = 100;
const TInt KStateParsingProperties = 102;
const TInt KStateParsingPolicy = 104;
const TInt KFlatBufSize = 128;
const TUint KValidityTime = +7;
}
EXPORT_C CSenWSPolicyManager* CSenWSPolicyManager::NewL(MSenCoreServiceManager& aManager)
{
CSenWSPolicyManager* pNew = NewLC(aManager);
CleanupStack::Pop(pNew);
return(pNew);
}
EXPORT_C CSenWSPolicyManager* CSenWSPolicyManager::NewLC(MSenCoreServiceManager& aManager)
{
CSenWSPolicyManager* pNew = new (ELeave) CSenWSPolicyManager(aManager);
CleanupStack::PushL(pNew);
pNew->ConstructL();
return pNew;
}
EXPORT_C CSenWSPolicyManager::~CSenWSPolicyManager()
{
delete iPolicDataLoader;
iPolicyArray.ResetAndDestroy();
iConsumerArray.ResetAndDestroy();
}
CSenWSPolicyManager::CSenWSPolicyManager(MSenCoreServiceManager& aManager)
:iManager(aManager),
iLog((RFileLogger*)aManager.Log())
{
}
void CSenWSPolicyManager::ConstructL()
{
iPolicDataLoader = CSenWSPolicyLoader::NewL(iManager);
RefreshPolicyContainerL(); //codescannerwarnings
}
RFileLogger* CSenWSPolicyManager::Log()
{
return iLog;
}
EXPORT_C TInt CSenWSPolicyManager::RegisterWsPolicyL(CSenWSDescription* aPattern,
TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RegisterWsPolicyL");
TInt retVal(KErrGeneral);
if(iPolicDataLoader == NULL)
{
iPolicDataLoader = CSenWSPolicyLoader::NewL(iManager);
}
retVal = iPolicDataLoader->RegisterWsPolicyL(aPattern, aErrorTo);
if(retVal == KErrNone)
RefreshPolicyContainerL(); //codescannerwarnings
if(iPolicDataLoader)
{
delete iPolicDataLoader;
iPolicDataLoader = NULL;
}
return retVal;
}
EXPORT_C TInt CSenWSPolicyManager::UnRegisterWsPolicyL(CSenWSDescription* aPattern,
TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::UnRegisterWsPolicyL");
TInt retVal(KErrGeneral);
if(iPolicDataLoader == NULL)
{
iPolicDataLoader = CSenWSPolicyLoader::NewL(iManager);
}
retVal = iPolicDataLoader->UnRegisterWsPolicyL(aPattern, aErrorTo);
if(retVal == KErrNone)
RefreshPolicyContainerL(); //codescannerwarnings
if(iPolicDataLoader)
{
delete iPolicDataLoader;
iPolicDataLoader = NULL;
}
return retVal;
}
EXPORT_C TInt CSenWSPolicyManager::AddWsPolicyL(CSenWSDescription* aPattern, const TDesC8& aUri,
const TDesC8& aPolicy, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::AddWsPolicyL");
TInt retVal(KErrGeneral);
if(iPolicDataLoader == NULL)
{
iPolicDataLoader = CSenWSPolicyLoader::NewL(iManager);
}
retVal = iPolicDataLoader->AddWsPolicyL(aPattern, aUri, aPolicy, aErrorTo);
if(retVal == KErrNone)
RefreshPolicyContainerL(); //codescannerwarnings
if(iPolicDataLoader)
{
delete iPolicDataLoader;
iPolicDataLoader = NULL;
}
return retVal;
}
EXPORT_C TInt CSenWSPolicyManager::RemoveWsPolicyL( CSenWSDescription* aPattern,
const TDesC8& aUri, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RemoveWsPolicyL");
TInt retVal(KErrGeneral);
if(iPolicDataLoader == NULL)
{
iPolicDataLoader = CSenWSPolicyLoader::NewL(iManager);
}
retVal = iPolicDataLoader->RemoveWsPolicyL(aPattern, aUri, aErrorTo);
if(retVal == KErrNone)
RefreshPolicyContainerL(); //codescannerwarnings
if(iPolicDataLoader)
{
delete iPolicDataLoader;
iPolicDataLoader = NULL;
}
return retVal;
}
TInt CSenWSPolicyManager::IsConsumerExist(const TDesC8& aEndpoint, const TDesC8& aConsumerId)
{
TInt count(iConsumerArray.Count());
for(TInt i = 0; i< count; i++)
{
CConsumerContainer* consumer = iConsumerArray[i];
if(consumer->Uri() == aEndpoint && consumer->ConsumerId() == aConsumerId)
return i;
}
return KErrNotFound;
}
TInt CSenWSPolicyManager::PolicyConsumerCountL(CSenInternalWsPolicy* aInternalPolicy) //codescannerwarnings
{
TInt retVal(KErrNone);
if (aInternalPolicy)
{
TPtrC8 metadata = aInternalPolicy->IdentifierL().MetadataEndpointL(); //codescannerwarnings
TInt count(iConsumerArray.Count());
for(TInt i = 0; i< count; i++)
{
CConsumerContainer* consumer = iConsumerArray[i];
if(consumer->Uri() == metadata)
retVal++;
}
}
return retVal;
}
EXPORT_C TInt CSenWSPolicyManager::AddPolicyConsumerL(const TDesC8& aUri, const TDesC8& aConsumerId)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::AddPolicyConsumerL");
TInt indx = IsConsumerExist(aUri,aConsumerId);
if(indx == KErrNotFound)
{
CConsumerContainer* consumer = CConsumerContainer::NewL(aUri,aConsumerId);
if(consumer)
{
iConsumerArray.Append(consumer);
RefreshPolicyContainerL(); //codescannerwarnings
}
else
{
}
}
return KErrNone;
}
EXPORT_C TInt CSenWSPolicyManager::RemovePolicyConsumerL(const TDesC8& aUri, const TDesC8& aConsumerId)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RemovePolicyConsumerL");
TInt indx = IsConsumerExist(aUri,aConsumerId);
if(indx > KErrNotFound)
{
CConsumerContainer* consumer = iConsumerArray[indx];
if(consumer)
{
TInt count (iPolicyArray.Count());
for(TInt i = 0; i< count; i++)
{
CNormalizedPolicyConatiner* container = iPolicyArray[i];
if(container->IsSameContainer(aUri))
{
container->CountDec();
if(container->ConsumerCount() < 1)
{ //we no longer ahve any consumer for this conatiner
iPolicyArray.Remove(i);
delete container;
container = NULL;
}
}
}
iConsumerArray.Remove(indx);
delete consumer;
consumer = NULL;
return KErrNone;
}
}
return KErrNotFound;
}
EXPORT_C CSenElement* CSenWSPolicyManager::WsPolicyL( CSenWSDescription* aPattern,
const TDesC8& aUri, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::WsPolicyL");
aErrorTo = KErrNotFound;
CSenElement* ele = NULL;
if(aPattern == NULL && aUri.Length() > 0) //special case for MS
{
TInt count (iPolicyArray.Count());
for(TInt i = 0; i< count; i++)
{
CNormalizedPolicyConatiner* container = iPolicyArray[i];
if(container->URI() == aUri)
{
aErrorTo = KErrNone;
return container->Policy();
}
}
}
if(aUri.Length() == 0)
{
ele = PolicyFromSDL(aPattern); //codescannerwarnings
}
else
{
ele = PolicyFromUri(aPattern, aUri);
}
if(ele != NULL)
aErrorTo = KErrNone;
return ele;
}
CSenElement* CSenWSPolicyManager::PolicyByProviderId(const TDesC8& aProviderId, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::PolicyByProviderId");
TInt count (iPolicyArray.Count());
for(TInt i = 0; i< count; i++)
{
CNormalizedPolicyConatiner* container = iPolicyArray[i];
if(container->ProviderId() == aProviderId)
{
CSenElement* ele = container->Policy();
if(ele)
{
aErrorTo = KErrNone;
return ele;
}
}
}
aErrorTo = KErrNotFound;
return NULL;
}
CSenElement* CSenWSPolicyManager::PolicyFromUri(CSenWSDescription* /*aPolicy*/, const TDesC8& aUri)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::PolicyFromUri");
TInt count (iPolicyArray.Count());
for(TInt i = 0; i< count; i++)
{
CNormalizedPolicyConatiner* container = iPolicyArray[i];
if(container->IsSameContainer(aUri))
{
return container->Policy();
}
}
return NULL;
}
CSenElement* CSenWSPolicyManager::PolicyFromSDL(CSenWSDescription* aPolicy) //codescannerwarnings
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::PolicyFromSD");
if( aPolicy )
{
CSenServicePolicy* pol = (CSenServicePolicy*)aPolicy->ServicePolicy();
CSenElement& servicePolicy = pol->AsElement();
CSenElement* clientPolicy = servicePolicy.Element( KClientPolicyLocalName );
if(clientPolicy)
{
RPointerArray<CSenElement> metaDataPoliciesUris;
CleanupClosePushL(metaDataPoliciesUris);
clientPolicy->ElementsL(metaDataPoliciesUris, KMetadataEndpointLocalname);
TInt count(metaDataPoliciesUris.Count());
if(count> 0)
{
CSenElement* metaData = NULL;
for(TInt i=0; i<count; i++)
{
metaData = metaDataPoliciesUris[i];
if(metaData && metaData->HasContent())
{
TPtrC8 uriName = metaData->Content();
CleanupStack::PopAndDestroy(&metaDataPoliciesUris);
return PolicyFromUri(aPolicy, uriName);
}
}
}
CleanupStack::PopAndDestroy(&metaDataPoliciesUris);
}
}
return NULL;
}
TInt CSenWSPolicyManager::UpdatePolicyContainerL(CSenInternalWsPolicy* aInternalPolicy) //codescannerwarnings
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::UpdatePolicyContainer");
TInt indx(IsContainerL(aInternalPolicy));
CNormalizedPolicyConatiner* container = iPolicyArray[indx];
if(container && container->URI().Compare(aInternalPolicy->IdentifierL().MetadataEndpointL()) == 0) //codescannerwarnings
{
TBool retval = container->UpdateL(aInternalPolicy);
container->SetConsumerCount(PolicyConsumerCountL(aInternalPolicy));//codescannerwarnings
return KErrNone;
}
return KErrNotFound;
}
TInt CSenWSPolicyManager::IsContainerL(CSenInternalWsPolicy* aInternalPolicy) //codescannerwarnings
{
TInt count (iPolicyArray.Count());
for(TInt i = 0; i< count && aInternalPolicy; i++)
{
CNormalizedPolicyConatiner* container = iPolicyArray[i];
TPtrC8 endpoint = aInternalPolicy->IdentifierL().MetadataEndpointL(); //codescannerwarnings
if(container)
{
if(container->URI().Compare(endpoint) == 0)
return i;
}
}
return KErrNotFound;
}
TInt CSenWSPolicyManager::CreatePolicyContainerL(CSenInternalWsPolicy* aInternalPolicy) //codescannerwarnings
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::CreatePolicyContainer");
TInt retVal(KErrNone);
TInt indx = IsContainerL(aInternalPolicy); //codescannerwarnings
if(indx == KErrNotFound)
{
TPtrC8 metaendpoint = aInternalPolicy->IdentifierL().MetadataEndpointL(); //codescannerwarnings
CSenElement* metadta = aInternalPolicy->IdentifierL().MetadataEndpointElementL(); //codescannerwarnings
{
if(metadta && metadta->HasContent())
{
TPtrC8 endpoint = metadta->Content();
CNormalizedPolicyConatiner* container =
CNormalizedPolicyConatiner::NewL(aInternalPolicy, endpoint);
TPtrC8 metaendpoint = aInternalPolicy->IdentifierL().MetadataEndpointL(); //codescannerwarnings
if(container && container->IsSameContainer(metaendpoint))
{
container->UpdateL(aInternalPolicy);
retVal = iPolicyArray.Append(container);
}
}
}
}
return retVal;
}
TInt CSenWSPolicyManager::RefreshPolicyContainerL() //codescannerwarnings
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::RefreshPolicyContainer");
TInt retVal(KErrGeneral);
if(iPolicDataLoader == NULL)
{
iPolicDataLoader = CSenWSPolicyLoader::NewL(iManager);
}
RSenWSPolicyArray policies;
CleanupClosePushL(policies);
retVal = iPolicDataLoader->InternalWsPoliciesL(policies);
if(retVal == KErrNone)
{
TInt count(policies.Count());
for(TInt i = 0; i< count; i++)
{
CSenInternalWsPolicy* policy = policies[i];
TInt consumerCount = PolicyConsumerCountL(policy);//codescannerwarnings
if( consumerCount > 0)
{
//for every internal policy we should have a container here
if(policy && IsContainerL(policy) != KErrNotFound) //codescannerwarnings
{//We have alreadya containere
// we already have this Policy container
// we just got a new consumer for this policy
// so the count will be increased
retVal = UpdatePolicyContainerL(policy); //codescannerwarnings
if(retVal == KErrNone)
{ //we got proper update
}
}
else
{//create a new container
retVal = CreatePolicyContainerL(policy); //codescannerwarnings
}
}
}
}
CleanupStack::PopAndDestroy(&policies);
if(iPolicDataLoader)
{
delete iPolicDataLoader;
iPolicDataLoader = NULL;
}
return retVal;
}
EXPORT_C TInt CSenWSPolicyManager::ExpiredPoliciesL(RExpiredPolicyArray& aArray, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyManager::ExpiredPoliciesL");
TTime now;
now.UniversalTime();
TInt count (iPolicyArray.Count());
for(TInt i = 0; i< count; i++)
{
CNormalizedPolicyConatiner* container = iPolicyArray[i];
if(container && container->ValidUntil() < now)
{
CExpiredPolicy* expir = CExpiredPolicy::NewL(container->Contract(),
container->Endpoint(),
container->URI(), container->ProviderId());
if(expir)
{
aArray.Append(expir);
aErrorTo = KErrNone;
}
}
}
if(aArray.Count() > 0)
return KErrNone;
else
return KErrNotFound;
}
TInt CSenWSPolicyManager::AddWsPolicy1L(CSenWSDescription* aPattern, const TDesC8& aUri,
const TDesC8& aPolicy, TInt& aErrorTo)
{
return AddWsPolicyL(aPattern, aUri, aPolicy, aErrorTo);
}
TInt CSenWSPolicyManager::RemoveWsPolicy1L( CSenWSDescription* aPattern,
const TDesC8& aUri, TInt& aErrorTo)
{
return RemoveWsPolicyL(aPattern, aUri, aErrorTo);
}
TInt CSenWSPolicyManager::RegisterWsPolicy1L(CSenWSDescription* aPattern,
TInt& aErrorTo)
{
return RegisterWsPolicyL(aPattern, aErrorTo);
}
TInt CSenWSPolicyManager::UnRegisterWsPolicy1L(CSenWSDescription* aPattern,
TInt& aErrorTo)
{
return UnRegisterWsPolicyL(aPattern, aErrorTo);
}
CSenElement* CSenWSPolicyManager::WsPolicy1L( CSenWSDescription* aPattern,
const TDesC8& aUri, TInt& aErrorTo)
{
return WsPolicyL(aPattern, aUri, aErrorTo);
}
CSenElement* CSenWSPolicyManager::WsPolicy1L( CSenWSDescription* aPattern,
TInt& aErrorTo)
{
return WsPolicyL(aPattern, KNullDesC8(), aErrorTo);
}
CSenElement* CSenWSPolicyManager::WsPolicy1L( const TDesC8& aProviderId, TInt& aErrorTo)
{
return PolicyByProviderId(aProviderId, aErrorTo);
}
TInt CSenWSPolicyManager::AddPolicyConsumer1L(const TDesC8& aUri, const TDesC8& aConsumerId)
{
return AddPolicyConsumerL(aUri,aConsumerId);
}
TInt CSenWSPolicyManager::RemovePolicyConsumer1L(const TDesC8& aUri, const TDesC8& aConsumerId)
{
return RemovePolicyConsumerL(aUri,aConsumerId);
}
CNormalizedPolicyConatiner* CNormalizedPolicyConatiner::NewL(CSenInternalWsPolicy* aPolicy, const TDesC8& aUri)
{
CNormalizedPolicyConatiner* pNew = CNormalizedPolicyConatiner::NewLC(aPolicy, aUri);
CleanupStack::Pop(pNew);
return(pNew);
}
CNormalizedPolicyConatiner* CNormalizedPolicyConatiner::NewLC(CSenInternalWsPolicy* aPolicy, const TDesC8& aUri)
{
CNormalizedPolicyConatiner* pNew = new (ELeave) CNormalizedPolicyConatiner();
CleanupStack::PushL(pNew);
pNew->ConstructL(aPolicy, aUri);
return pNew;
}
CNormalizedPolicyConatiner::~CNormalizedPolicyConatiner()
{
delete iContract;
delete iEndpoint;
delete iUri;
delete iProviderId;
delete iPolicy;
}
CNormalizedPolicyConatiner::CNormalizedPolicyConatiner()
{
}
void CNormalizedPolicyConatiner::ConstructL(CSenInternalWsPolicy* aPolicy, const TDesC8& aUri)
{
TPtrC8 contract = aPolicy->IdentifierL().ContractL(); //codescannerwarnings
TPtrC8 endpoint = aPolicy->IdentifierL().EndpointL(); //codescannerwarnings
TPtrC8 providerId = aPolicy->IdentifierL().ProviderIdL(); //codescannerwarnings
TTime valid = aPolicy->ValidUntilL(aUri);
iCount = 1;
iContract = contract.AllocL();
iEndpoint = endpoint.AllocL();
iProviderId= providerId.AllocL();
iUri = aUri.AllocL();
iValidUntil = valid;
}
TBool CNormalizedPolicyConatiner::UpdateL(CSenInternalWsPolicy* aInternalPolicy)
{
TTime valid = aInternalPolicy->ValidUntilL(URI());
CSenElement* normPolicy = NULL;
if(valid > iValidUntil ) //we have new expiry time
{
CSenElement* policy = aInternalPolicy->WsPolicyByUriL(URI());
TInt length = 0;
if(policy)
{
CBufFlat* pBuf = NULL;
pBuf = CBufFlat::NewL(KFlatBufSize);
CleanupStack::PushL(pBuf);
RBufWriteStream bufWs(*pBuf);
CleanupClosePushL(bufWs);
policy->WriteAsXMLToL(bufWs);
TPtr8 p8 = pBuf->Ptr(0);
length = p8.Length();
CleanupStack::PopAndDestroy(2); // bufWs (close), pBuf
}
if(length < 100000)
{
CWSPolicy* wspolicy = CWSPolicy::NewLC();
TRAPD(error, normPolicy = wspolicy->NormalizePolicy2L(*policy, NULL);)
CleanupStack::PopAndDestroy(wspolicy);
if(error == KErrNone && normPolicy)
{
if(iPolicy)
delete iPolicy;
iPolicy = normPolicy;
iValidUntil = valid;
return ETrue;
}
//set this policy as new policy
}
}
else if(valid == iValidUntil)
{
if(iPolicy == NULL)
{
CSenElement* policy = aInternalPolicy->WsPolicyByUriL(URI());
TInt length = 0;
if(policy)
{
CBufFlat* pBuf = NULL;
pBuf = CBufFlat::NewL(KFlatBufSize);
CleanupStack::PushL(pBuf);
RBufWriteStream bufWs(*pBuf);
CleanupClosePushL(bufWs);
policy->WriteAsXMLToL(bufWs);
TPtr8 p8 = pBuf->Ptr(0);
length = p8.Length();
CleanupStack::PopAndDestroy(2); // bufWs (close), pBuf
}
if(length < 100000)
{
CWSPolicy* wspolicy = CWSPolicy::NewLC();
TRAPD(error, normPolicy = wspolicy->NormalizePolicy2L(*policy, NULL);)
CleanupStack::PopAndDestroy(wspolicy);
if(error == KErrNone && normPolicy)
{
iPolicy = normPolicy;
iValidUntil = valid;
return ETrue;
}
//set this policy as new policy
}
}
}
return EFalse;
}
TBool CNormalizedPolicyConatiner::IsSameContainer(const TDesC8& aUri)
{
if(aUri.Compare(URI()) == 0)
{
return ETrue;
}
return EFalse;
}
void CNormalizedPolicyConatiner::CountInc()
{
iCount++;
}
void CNormalizedPolicyConatiner::CountDec()
{
iCount--;
if(iCount < 0)
iCount = 0;
}
void CNormalizedPolicyConatiner::SetConsumerCount(TInt aCount)
{
iCount = aCount;
}
TInt CNormalizedPolicyConatiner::ConsumerCount()
{
return iCount;
}
TPtrC8 CNormalizedPolicyConatiner::Contract()
{
return iContract->Des();
}
TPtrC8 CNormalizedPolicyConatiner::Endpoint()
{
return iEndpoint->Des();
}
TPtrC8 CNormalizedPolicyConatiner::ProviderId()
{
return iProviderId->Des();
}
TPtrC8 CNormalizedPolicyConatiner::URI()
{
return iUri->Des();
}
TTime CNormalizedPolicyConatiner::ValidUntil()
{
return iValidUntil;
}
CSenElement* CNormalizedPolicyConatiner::Policy()
{
return iPolicy;
}
CSenWSPolicyLoader* CSenWSPolicyLoader::NewL(MSenCoreServiceManager& aManager)
{
CSenWSPolicyLoader* pNew = NewLC(aManager);
CleanupStack::Pop(pNew);
return(pNew);
}
CSenWSPolicyLoader* CSenWSPolicyLoader::NewLC(MSenCoreServiceManager& aManager)
{
CSenWSPolicyLoader* pNew = new (ELeave) CSenWSPolicyLoader(aManager);
CleanupStack::PushL(pNew);
pNew->ConstructL();
return pNew;
}
CSenWSPolicyLoader::CSenWSPolicyLoader(MSenCoreServiceManager& aManager)
: iManager(aManager),
iLog((RFileLogger*)aManager.Log()),
iMaxPolicyID(0)
{
}
CSenWSPolicyLoader::~CSenWSPolicyLoader()
{
SaveDB();
TInt count = iPolicyArray.Count();
for (TInt i=0; i < count; i++)
{
iPolicyArray[i].Close();
}
iPolicyArray.Close();
delete ipPolicyContainer;
delete ipPolicyIdentifier;
delete ipWSpolicy;
}
void CSenWSPolicyLoader::ConstructL()
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::ConstructL");
BaseConstructL(KSenWsPolicies);
LoadDBL(); //codescannerwarnings
}
RFileLogger* CSenWSPolicyLoader::Log()
{
return iLog;
}
void CSenWSPolicyLoader::StartElementL(const TDesC8& aNsUri,
const TDesC8& aLocalName,
const TDesC8& aQName,
const RAttributeArray& aAttributes)
{
const TPtrC8 localName = aLocalName;
switch (iState)
{
case KSenStateSave:
{
if (aLocalName.Compare(KWsPolicyContainer) == 0)
{
if ( ipPolicyContainer )
{
// CSenElement* element = ipPolicyContainer->ExtractElement();
delete ipPolicyContainer;
ipPolicyContainer = NULL;
}
CSenElement& element = AsElement();
TPtrC8 prefix(KNullDesC8);
if(aQName.Length()>0)
{
TInt colon = aQName.Locate(':');
if(colon>0) // Note: 0 also treated as no prefix
{
prefix.Set(aQName.Ptr(), colon);
}
}
ipPolicyContainer = CSenBaseFragment::NewL(
aNsUri, aLocalName,
aQName, aAttributes,
element);
ipPolicyContainer->AsElement().SetNamespaceL(prefix, aNsUri);
iState = KStateParsingContainer;
}
break;
}
case KStateParsingContainer:
{
if (aLocalName.Compare(KSenWsPolicyIdentifierLocalname) == 0)
{
if ( ipPolicyIdentifier )
{
//CSenElement* element = ipPolicyIdentifier->ExtractElement();
delete ipPolicyIdentifier;
ipPolicyIdentifier = NULL;
}
CSenElement& element = ipPolicyContainer->AsElement();
TPtrC8 prefix(KNullDesC8);
if(aQName.Length()>0)
{
TInt colon = aQName.Locate(':');
if(colon>0) // Note: 0 also treated as no prefix
{
prefix.Set(aQName.Ptr(), colon);
}
}
ipPolicyIdentifier = CSenWSPolicyIdentifier::NewL(
aNsUri, aLocalName,
aQName, aAttributes,
element);
iState = KStateParsingIdentifier;
ipPolicyIdentifier->AsElement().SetNamespaceL(prefix, aNsUri);
DelegateParsingL(*ipPolicyIdentifier);
}
else if(aLocalName.Compare(KSenWSPolicyMetadata) == 0)
{
// Parsing Policy
//
// <=> Container can have only two elements:
// 1) Identifier,
// 2) PolicyMetadata
if ( ipWSpolicy )
{
CSenElement* element = ipWSpolicy->ExtractElement();
delete ipWSpolicy;
ipWSpolicy = NULL;
}
CSenElement& element = ipPolicyContainer->AsElement();
ipWSpolicy = CSenInternalWsPolicy::NewL(
aNsUri, aLocalName,
aQName, aAttributes,
element
);
ipWSpolicy->SetIdentifier(ipPolicyIdentifier);
ipPolicyIdentifier = NULL;
iState = KStateParsingPolicy;
DelegateParsingL(*ipWSpolicy);
}
break;
}
default:
{
if (aLocalName.Compare(KSenWsPolicies) == 0)
{
TInt count(aAttributes.Count());
for (TInt i=0; i<count; i++)
{
TPtrC8 localName = aAttributes[i].Attribute().LocalName().DesC();
TPtrC8 value = aAttributes[i].Value().DesC();
if ( localName == KWsPoliciesMaxID )
{
TLex8 lex;
lex.Assign(value);
lex.Val( iMaxPolicyID );
break;
}
}
}
CSenBaseFragment::StartElementL(aNsUri, aLocalName, aQName, aAttributes);
break;
}
}
}
void CSenWSPolicyLoader::EndElementL(const TDesC8& aNsUri,
const TDesC8& aLocalName,
const TDesC8& aQName)
{
switch(iState)
{
case KStateParsingIdentifier:
{
iState = KStateParsingContainer;
break;
}
case KStateParsingProperties:
{
iState = KStateParsingContainer;
break;
}
case KStateParsingPolicy:
{
RSenWSPolicyPtr policyPtr;
policyPtr.OpenL(ipWSpolicy);
CleanupClosePushL(policyPtr);
iPolicyArray.Append(policyPtr);
CleanupStack::Pop(&policyPtr);
CSenElement& element = this->AsElement().AddElementL(KWsPolicyContainer);
element.AddElementL(ipWSpolicy->IdentifierL().AsElement()); //codescannerwarnings
ipWSpolicy->IdentifierL().AsElement().SetParent(&element); //codescannerwarnings
ipWSpolicy->IdentifierL().SetIdL(NextId()); //codescannerwarnings
element.AddElementL(ipWSpolicy->AsElement());
ipWSpolicy->AsElement().SetParent(&element);
ipWSpolicy = NULL;
iState = KStateParsingContainer;
break;
}
case KStateParsingContainer:
{
if ( ipPolicyContainer )
{
CSenElement& element = ipPolicyContainer->AsElement();
RPointerArray<CSenElement>& children = element.ElementsL();
// Element should always have 2 child elements:
// 1) Identifier and
// 2) PolicyMetadata
if ( children.Count() < 2 )
{
if ( ipPolicyIdentifier )
{
// CSenElement* element = ipPolicyIdentifier->ExtractElement();
delete ipPolicyIdentifier;
ipPolicyIdentifier = NULL;
}
if ( ipWSpolicy )
{
// CSenElement* element = ipWSpolicy->ExtractElement();
delete ipWSpolicy;
ipWSpolicy = NULL;
}
}
delete ipPolicyContainer;
ipPolicyContainer = NULL;
}
iState = KSenStateSave;
break;
}
default:
{
CSenBaseFragment::EndElementL(aNsUri, aLocalName, aQName);
break;
}
}
}
TInt CSenWSPolicyLoader::LoadDBL() //codescannerwarnings
{
TInt retVal(KErrNone);
TRAP(retVal, LoadFromL(KWsPolicyFile));
return retVal;
}
void CSenWSPolicyLoader::LoadFromL(const TDesC& aFile)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::LoadFromL");
RFs fss;
User::LeaveIfError(fss.Connect());
CleanupClosePushL(fss);
TInt leaveCode(KErrNone);
#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )
TBuf<KMaxPath> file;
fss.CreatePrivatePath(EDriveC);
fss.PrivatePath(file);
file.Append(aFile);
RFile xmlFile;
leaveCode = xmlFile.Open(fss , file, EFileRead );
if(leaveCode == KErrNone)
{
TInt size;
xmlFile.Size(size);
HBufC8 *pBuf=HBufC8::NewL(size); //CodeScannerWarnings
CleanupStack::PushL(pBuf);
TPtr8 buf8ptr(pBuf->Des());
xmlFile.Read(buf8ptr,size);
iXmlReader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser
TRAP(leaveCode, ParseL(buf8ptr));
delete iXmlReader;
iXmlReader = NULL; //CodeScannerWarnings
CleanupStack::PopAndDestroy(pBuf);
}
xmlFile.Close();
#else
TRAP(leaveCode, ParseL(fss, aFile, *this));
#endif
iState = KSenStateSave;
#ifdef _SENDEBUG
if(leaveCode == KErrNotFound)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"- The senwspolicies.xml does not exist!");
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"- New file will be generated.");
}
else if(leaveCode != KErrNone)
{
TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel, _L8("- Parsing of senwspolicies.xml leaved: %d"), leaveCode));
}
else
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"- Policy database (senwspolicies.xml) successfully read.");
}
#else
leaveCode=0; // this is a decision: we are not interested
// of invalid input in read/parse phase
#endif
SaveDB(); // Always validatby saving
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::LoadL - End");
CleanupStack::PopAndDestroy(); // fss
}
TInt CSenWSPolicyLoader::SaveDB()
{
TInt retVal(KErrNone);
TRAP(retVal, SaveToL(KWsPolicyFile));
return retVal;
}
TInt CSenWSPolicyLoader::MergeToL()
{
// CSenWSPolicyDBLoader* dbLoader = CSenWSPolicyDBLoader::NewL(iManager);
return KErrNone;
}
TInt CSenWSPolicyLoader::SaveToL(const TDesC& aFile)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::SaveToL");
TInt count = iPolicyArray.Count();
TInt maxId = 0;
for (TInt i=0; i<count; i++)
{
if ( iPolicyArray[i].Policy()->IdentifierL().IdL() > maxId ) //codescannerwarnings
{
maxId = iPolicyArray[i].Policy()->IdentifierL().IdL(); //codescannerwarnings
}
}
iMaxPolicyID = maxId;
// UpdateMaxId();
// First, collect everything into MEMORY
CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);
CleanupStack::PushL(pBuf);
RBufWriteStream bufWs(*pBuf);
CleanupClosePushL(bufWs);
AsElement().WriteAsXMLToL(bufWs);
TPtrC8 p8 = pBuf->Ptr(0);
CleanupStack::PopAndDestroy(1); // bufWs
// Everything in MEMORY ok, prepare to write into file
RFs fss;
User::LeaveIfError(fss.Connect());
CleanupClosePushL(fss);
RFileWriteStream fileOutStream;
CleanupClosePushL(fileOutStream);
if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) )
{
//Data caging 2 implementation
#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )
TBuf<KMaxPath> file;
fss.CreatePrivatePath(EDriveC);
fss.PrivatePath(file);
file.Append(aFile);
fileOutStream.Replace(fss, file, EFileWrite);
#else
fileOutStream.Replace(fss, aFile, EFileWrite);
#endif
// finally write the UTF-8 into the file.
fileOutStream.WriteL(p8);
}
CleanupStack::PopAndDestroy(3); // fileOutStream, fss, pBuf
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::SaveToL - End");
return KErrNone;
}
TInt CSenWSPolicyLoader::InternalWsPoliciesL(RSenWSPolicyArray& aPolicies)
{
TInt retVal(KErrNotFound);
TInt count = iPolicyArray.Count();
for (TInt i=0; i<count; i++)
{
aPolicies.AppendL(iPolicyArray[i].Policy());
}
if ( aPolicies.Count() == 0 )
{
return retVal;
}
return KErrNone;
}
TInt CSenWSPolicyLoader::InternalWsPolicyL(CSenWSDescription& aPattern,
RSenWSPolicyArray& aPolicies)
{
TInt retVal(KErrNotFound);
TInt count = iPolicyArray.Count();
for (TInt i=0; i<count; i++)
{
if ( iPolicyArray[i].Policy()->IsApplicableL(aPattern) ) //codescannerwarnings
{
aPolicies.AppendL(iPolicyArray[i].Policy());
}
}
if ( aPolicies.Count() == 0 )
{
return retVal;
}
return KErrNone;
}
TInt CSenWSPolicyLoader::InternalWsPolicyL(const TDesC8& aUri,
RSenWSPolicyArray& aPolicies)
{
TInt retVal(KErrNotFound);
TInt count = iPolicyArray.Count();
for (TInt i=0; i<count; i++)
{
if ( iPolicyArray[i].Policy()->IsApplicableL(aUri) ) //codescannerwarnings
{
aPolicies.AppendL(iPolicyArray[i].Policy());
}
}
if ( aPolicies.Count() == 0 )
{
return retVal;
}
return KErrNone;
}
TInt CSenWSPolicyLoader::VerifyPolicyContentsL(CSenInternalWsPolicy* apInternalPolicy, TInt& aErrorTo) //codescannerwarnings
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::VerifyPolicyContents Final");
TInt retVal(KErrNotFound);
TInt count = iPolicyArray.Count();
TPtrC8 uri = apInternalPolicy->IdentifierL().MetadataEndpointL();
for (TInt i=0; i<count; i++)
{
CSenInternalWsPolicy* pIntPolicy = iPolicyArray[i].Policy();
if(pIntPolicy)
{
TPtrC8 pUri = pIntPolicy->IdentifierL().MetadataEndpointL();
if(uri == pUri)
{
TPtrC8 contract = apInternalPolicy->IdentifierL().ContractL(); //codescannerwarnings
TPtrC8 endpoint = apInternalPolicy->IdentifierL().EndpointL(); //codescannerwarnings
TPtrC8 pContract = pIntPolicy->IdentifierL().ContractL(); //codescannerwarnings
TPtrC8 pEndpoint = pIntPolicy->IdentifierL().EndpointL(); //codescannerwarnings
if(contract == pContract && endpoint== pEndpoint)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"same policy");
//same do nuthing
}
else
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"different policy");
aErrorTo = KErrNone;
CSenElement* policy = pIntPolicy->WsPolicyByUriL(pUri);
CSenElement* policyNew = apInternalPolicy->WsPolicyByUriL(pUri);
if(policy)
{
if(policyNew == NULL) //no existing policy
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"different policy, add");
retVal = apInternalPolicy->AddMetadataPolicyL(policy);
}
else //existing policy so verify it
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"different policy, update");
retVal = apInternalPolicy->UpdateMetadataPolicyL(policy);
// if the Metadata of Policy (aElement) is already euqal to
}
}
}
}
}
}
return retVal;
}
RSenWSPolicyPtr CSenWSPolicyLoader::AddWsPolicyL(CSenInternalWsPolicy* apInternalPolicy,
TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::AddWsPolicyL Final");
if ( !apInternalPolicy )
{
SENDEBUG_L("AddPolicyL(*) - Illegal argument: NULL");
aErrorTo = KErrArgument;
return RSenWSPolicyPtr();
}
CleanupStack::PushL(apInternalPolicy);
RSenWSPolicyPtr policyPtr;
policyPtr.OpenL(apInternalPolicy);
CleanupStack::Pop(apInternalPolicy);
CleanupClosePushL(policyPtr);
iPolicyArray.AppendL(policyPtr);
CleanupStack::Pop(&policyPtr);
CSenElement& element = this->AsElement().AddElementL(KWsPolicyContainer);
element.AddElementL(apInternalPolicy->IdentifierL().AsElement()); //codescannerwarnings
apInternalPolicy->IdentifierL().AsElement().SetParent(&element); //codescannerwarnings
apInternalPolicy->IdentifierL().SetIdL(NextId()); //codescannerwarnings
element.AddElementL(apInternalPolicy->AsElement());
apInternalPolicy->AsElement().SetParent(&element);
VerifyPolicyContentsL(apInternalPolicy,aErrorTo); //codescannerwarnings
SaveDB();
aErrorTo = KErrNone;
return policyPtr;
}
TInt CSenWSPolicyLoader::AddWsPolicyL(const TDesC8& aUri, CSenElement* aPolicy, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::AddWsPolicyL as Element");
TInt retVal(KErrNotFound);
RSenWSPolicyArray array;
CleanupClosePushL(array);
aErrorTo = InternalWsPolicyL(aUri,array);
//array should have only one policy
TInt count(array.Count());
TPtrC8 metaendpoint = CWSPolicyUtils::PolicyUriL(aPolicy);
for (TInt i = 0; i< count; i++)
{
CSenInternalWsPolicy* ptr = array[i];
CSenWSPolicyIdentifier& identifier = ptr->IdentifierL(); //codescannerwarnings
if(identifier.MetadataEndpointL() == metaendpoint) //codescannerwarnings
{
CSenElement* policy = ptr->WsPolicyByUriL(metaendpoint);
if(policy == NULL) //no existing policy
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::AddWsPolicyL Add");
retVal = ptr->AddMetadataPolicyL(aPolicy);
}
else //existing policy so verify it
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::AddWsPolicyL Replace");
retVal = ptr->UpdateMetadataPolicyL(aPolicy);
// if the Metadata of Policy (aElement) is already euqal to
}
SaveDB();
}
}
CleanupStack::PopAndDestroy(&array);
return retVal;
}
TInt CSenWSPolicyLoader::AddWsPolicyL(CSenWSDescription* /*aPattern*/, const TDesC8& aUri,
const TDesC8& aPolicy, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::AddWsPolicyL");
TInt retVal(KErrNotFound);
CSenElement* policy = CreatePolicyElementL(aUri, aPolicy);
if(policy)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::AddWsPolicyL adding Policy as string");
CleanupStack::PushL(policy);
retVal = AddWsPolicyL(aUri, policy, aErrorTo);
CleanupStack::PopAndDestroy(policy);
policy = NULL;
}
else
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"Not a Valid xml policy to add ");
}
return retVal;
}
TInt CSenWSPolicyLoader::RemoveWsPolicyL( CSenWSDescription* aPattern,
const TDesC8& aUri, TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::RemoveWsPolicyL");
TInt retVal(KErrNotFound);
RSenWSPolicyArray array;
CleanupClosePushL(array);
aErrorTo = InternalWsPolicyL(*aPattern,array);
//array should have only one Entry in array i.e. Matching Service
TInt count(array.Count());
for (TInt i = 0; i< count; i++)
{
CSenInternalWsPolicy* ptr = array[i];
if(aUri.Length() == 0)
{
// delete all policies
//delete all metadatas
}
else
{
CSenElement* policy = ptr->WsPolicyByUriL(aUri);
if(policy) //we have policy so remove it
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"Removing CSenWSPolicyLoader::RemoveWsPolicyL");
aErrorTo = ptr->RemoveMetadataPolicyL(aUri);
retVal = KErrNone;
}
}
}
CleanupStack::PopAndDestroy(&array);
SaveDB();
return retVal;
}
TInt CSenWSPolicyLoader::NextId()
{
iMaxPolicyID++;
UpdateMaxId();
return iMaxPolicyID;
}
void CSenWSPolicyLoader::UpdateMaxId()
{
/*
TBool found = EFalse;
CSenElement& element = AsElement();
RPointerArray<CSenBaseAttribute>& attrs = element.AttributesL();
CSenBaseAttribute* bs = NULL;
TInt ele_count = attrs.Count();
for(TInt j=0; j < ele_count; j++)
{
bs = (attrs)[j];
if(bs)
{
if(bs->Name().Compare(KWsPoliciesMaxID) == 0)
{
TBuf8<KFlatBufSize> buffer;
buffer.Num(iMaxPolicyID);
bs->SetValueL(buffer);
found = ETrue;
}
}
}
if ( !found )
{
TBuf8<KFlatBufSize> buffer;
buffer.Num(iMaxPolicyID);
element.AddAttributeL(KWsPoliciesMaxID, buffer);
}
*/
}
TInt CSenWSPolicyLoader::RegisterWsPolicyL(CSenInternalWsPolicy* aInternalPolicy,
TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::RegisterWsPolicyL2");
if(aInternalPolicy == NULL)
{
aErrorTo = KErrArgument;
return KErrGeneral;
}
TInt count = iPolicyArray.Count();
TInt isPresent(KErrNotFound);
for (TInt i=0; i<count; i++)
{
CSenInternalWsPolicy* internalPolicy = iPolicyArray[i].Policy();
TBool retVal = internalPolicy->IsApplicableL(aInternalPolicy); //codescannerwarnings
if(retVal)
{
isPresent = KErrNone;
break;
}
}
if(isPresent == KErrNotFound)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"Adding CSenWSPolicyLoader::RegisterWsPolicyL");
AddWsPolicyL(aInternalPolicy, aErrorTo);
return KErrNone;
}
return KErrAlreadyExists;
}
TInt CSenWSPolicyLoader::RegisterWsPolicyL(CSenWSDescription* aPattern,
TInt& aErrorTo)
{
//check if the policy is already in DB
//if yes then use that
//else
//create new one
TInt retVal(KErrGeneral);
TInt ret(KErrGeneral);
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::RegisterWsPolicyL");
TPtrC8 cont = aPattern->Contract();
TPtrC8 endpo = aPattern->Endpoint();
CSenElement* providerId = aPattern->AsElement().Element(KProviderIdLocalName);
CSenServicePolicy* pol = (CSenServicePolicy*)aPattern->ServicePolicy();
CSenElement& servicePolicy = pol->AsElement();
CSenElement* clientPolicy = servicePolicy.Element( KClientPolicyLocalName );
if(clientPolicy)
{
RPointerArray<CSenElement> metaDataPoliciesUris;
CleanupClosePushL(metaDataPoliciesUris);
clientPolicy->ElementsL(metaDataPoliciesUris, KMetadataEndpointLocalname);
TInt count(metaDataPoliciesUris.Count());
if(count> 0)
{
CSenElement* metaData = NULL;
for(TInt i=0; i<count; i++)
{
metaData = metaDataPoliciesUris[i];
if(metaData && metaData->HasContent())
{
TPtrC8 uriName = metaData->Content();
CSenInternalWsPolicy* pInternalPolicy = CSenInternalWsPolicy::NewLC();
CSenWSPolicyIdentifier& identifier = pInternalPolicy->IdentifierL(); //codescannerwarnings
identifier.AddMetadataEndpointL(metaData);
if(cont.Length() > 0)
identifier.SetPropertyL(KContractLocalname, cont);
if(endpo.Length() > 0)
identifier.SetPropertyL(KEndpointLocalname, endpo);
if(providerId && providerId->HasContent())
{
TPtrC8 provider = providerId->Content();
identifier.SetPropertyL(KProviderIdLocalName, provider);
}
TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,(uriName));
retVal = RegisterWsPolicyL(pInternalPolicy, aErrorTo);
if(retVal != KErrNone )
{
CleanupStack::PopAndDestroy(pInternalPolicy);
}
else
{
CleanupStack::Pop(pInternalPolicy);
ret = KErrNone;
}
}
}
}
CleanupStack::PopAndDestroy(&metaDataPoliciesUris);
}
return ret;
}
TInt CSenWSPolicyLoader::UnRegisterWsPolicyL(CSenWSDescription* aPattern,
TInt& aErrorTo)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KSenCoreServiceManagerLogLevel,"CSenWSPolicyLoader::UnRegisterWsPolicyL");
TInt isPresent(KErrNotFound);
TInt count = 0;
for (TInt i=0; i<iPolicyArray.Count(); i++)
{
if(iPolicyArray[i].Policy()->IsApplicableL(*aPattern)) //codescannerwarnings
{
count++;
}
}
for(TInt j=0; j<count; j++)
{
for (TInt i=0; i<iPolicyArray.Count(); i++)
{
if(iPolicyArray[i].Policy()->IsApplicableL(*aPattern)) //codescannerwarnings
{
CSenElement& root = this->AsElement();
CSenElement& element = iPolicyArray[i].Policy()->AsElement();
CSenElement* parent = element.Parent();
iPolicyArray[i].Close();
iPolicyArray.Remove(i);
if(parent)
{
CSenElement* removed = root.RemoveElement(*parent);
delete removed;
removed = NULL;
}
aErrorTo = KErrNone;
isPresent= KErrNone;
}
}
}
SaveDB();
return isPresent;
}
CSenElement* CSenWSPolicyLoader::WsPolicyL( CSenWSDescription* /*aPattern*/,
const TDesC8& /*aUri*/, TInt& /*aErrorTo*/)
{
return NULL;
}
CSenElement* CSenWSPolicyLoader::GetExpiryTagL(CSenElement& aPolicy)
{
//if there is no expiry tag in the policy the default expiry time is UTC +7 days
RPointerArray<CSenElement> timeStamps;
CleanupClosePushL(timeStamps);
CSenElement* validity = NULL;
const CSenNamespace* msNsUri = aPolicy.Namespace(MSWSPolicy::KMSNsPrefix);
if(msNsUri)
{
if(aPolicy.ElementsL(timeStamps, msNsUri->URI(), MSWSPolicy::KMetaDataValidity) == KErrNone)
{
TInt validityStampsCount = timeStamps.Count();
if(validityStampsCount > 0)
{
validity = timeStamps[0];//mws:metadatavalidity
CleanupStack::PopAndDestroy();
return validity->Element(msNsUri->URI(), MSWSPolicy::KExpiry);
}
}
}
else
{
if(aPolicy.ElementsL(timeStamps, MSWSPolicy::KMetaDataValidity) == KErrNone)
{
TInt validityStampsCount = timeStamps.Count();
if(validityStampsCount > 0)
{
validity = timeStamps[0];//mws:metadatavalidity
CleanupStack::PopAndDestroy();
return validity->Element(MSWSPolicy::KExpiry);
}
}
}
CleanupStack::PopAndDestroy();
return NULL;
}
CSenElement* CSenWSPolicyLoader::CreatePolicyElementL(const TDesC8& aUri, const TDesC8& aPolicy)
{
TInt retVal(KErrGeneral);
CMyXml* xml = CMyXml::NewLC();
retVal = xml->ReadFromDescL(aPolicy);
CSenElement* ele = NULL;
if(retVal == KErrNone)
{
ele = xml->ExtractElement();
TPtrC8 eleName = ele->LocalName();
TPtrC8 eleNs = ele->NsPrefix();
if(ele)
if((eleName == KWsdlDocument && eleNs == KWsdlNsPrefix) ||
(eleName == KPolicyDocument && eleNs == KPolicyNsPrefix))
{//this is definitely a poliycy or wsdl file
//Add Name, Id, Metaendpoint; validity
ProcessNewPolicyL(aUri, *ele);
}
else
{
delete ele;
ele = NULL;
}
}
CleanupStack::PopAndDestroy();
return ele;
}
TInt CSenWSPolicyLoader::ProcessNewPolicyL( const TDesC8& aUri, CSenElement& aPolicy)
{
TPtrC8 policyUri = CWSPolicyUtils::PolicyUriL(&aPolicy);
if(policyUri.Length() == 0)
SenXmlUtils::AddAttributeL(aPolicy, KMetadataEndpointLocalname, aUri);
TPtrC8 name = CWSPolicyUtils::PolicyNameL(&aPolicy);
if(name.Length() == 0)
SenXmlUtils::AddAttributeL(aPolicy, KName, aUri);
TPtrC8 id = CWSPolicyUtils::PolicyIdL(&aPolicy);
if(id.Length() == 0)
{
CSenGuidGen* pGuidGenerator = CSenGuidGen::NewLC();
HBufC8* iPolicyId = pGuidGenerator->GetRandomGuid8LC();
TPtr8 policyIdDes = iPolicyId->Des();
policyIdDes.LowerCase();
aPolicy.AddAttrL(KWsuId, policyIdDes);
aPolicy.AddNamespaceL(KWsuPrefix, KWsuNsUri);
CleanupStack::PopAndDestroy(iPolicyId);
CleanupStack::PopAndDestroy(pGuidGenerator);
}
CSenElement* expiry = GetExpiryTagL(aPolicy);
TInt addtimeTag(KErrGeneral);
TTime expiryTime = Time::NullTTime();
if(expiry)
{
TInt updateTime = EvaluateExpiryL(expiry, expiryTime);
if(updateTime == KErrNone)
{
addtimeTag = KErrNone;
}
}
if(addtimeTag != KErrNone)
{
expiryTime.UniversalTime();
TTimeIntervalDays interval(KValidityTime);
expiryTime+=interval;
}
TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;
SenDateUtils::ToXmlDateTimeUtf82L(ts, expiryTime);
SenXmlUtils::AddAttributeL(aPolicy, KSenWSPolicyValidUntil, ts);
return KErrNone;
}
TInt CSenWSPolicyLoader::EvaluateExpiryL(CSenElement* aExpiry, TTime& aExpiryTime)
{
TInt updateTime(KErrNotFound);
if(aExpiry && aExpiry->HasContent())
{
TPtrC8 timeTag = aExpiry->Content();
_LIT8(KUtc,"UTC");
_LIT8(KDays,"days");
TInt utc = timeTag.Find(KUtc); //CodeScannerWarnings
TInt days = timeTag.Find(KDays);
if(utc != KErrNotFound && days != KErrNotFound)
{ //We found UTC +x days timestamp
//replace this time stamp with expiry time starting from now
TInt plus = timeTag.Locate('+');
if(plus != KErrNotFound)
{
TInt timeLength = days-plus-2;
TPtrC8 timeValue = timeTag.Mid(plus+2,timeLength-1);
if(timeValue != KNullDesC8)
{
TInt value = 0;
TLex8 lex(timeValue);
TInt retVal = lex.Val(value);
if(retVal != KErrNone)
{
value = KValidityTime;
}
if(value > 0)
{
TTime expiry;
expiry.UniversalTime();
TTimeIntervalDays interval(value);
expiry+=interval;
TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;
TRAP (retVal, SenDateUtils::ToXmlDateTimeUtf82L(ts, expiry));
if(retVal == KErrNone && ts.Length() > 0)
{
aExpiry->SetContentL(ts);
aExpiryTime = expiry;
updateTime = KErrNone;
}
}
}
}
}
if(updateTime != KErrNone)
//the content is not in "UTC +7 days" format so try the XML time format
{
TTime now;
now.UniversalTime();
TTime expiry = Time::NullTTime();
TRAPD(retval, expiry = SenDateUtils::FromXmlDateTimeL(timeTag);)
if(retval == KErrNone)
{
if(expiry > now)
{
aExpiryTime = expiry;
updateTime = KErrNone;
}
else //strange case. the policy provided to us is already expired
{
updateTime = KErrNone;
}
}
else
{
updateTime = KErrGeneral;
}
}
}
return updateTime;
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
EXPORT_C CExpiredPolicy* CExpiredPolicy::NewL(const TDesC8& aContract, const TDesC8& aEndpoint,
const TDesC8& aUri, const TDesC8& aProviderId)
{
CExpiredPolicy* pNew = NewLC(aContract, aEndpoint, aUri, aProviderId);
CleanupStack::Pop(pNew);
return(pNew);
}
EXPORT_C CExpiredPolicy* CExpiredPolicy::NewLC(const TDesC8& aContract, const TDesC8& aEndpoint,
const TDesC8& aUri, const TDesC8& aProviderId)
{
CExpiredPolicy* pNew = new (ELeave) CExpiredPolicy();
CleanupStack::PushL(pNew);
pNew->ConstructL(aContract, aEndpoint, aUri, aProviderId);
return pNew;
}
EXPORT_C CExpiredPolicy::~CExpiredPolicy()
{
delete iContract; //service contract
delete iEndpoint; //service contract
delete iURI; //uri to download
delete iProvideId;
delete iContents; //contents
}
EXPORT_C TPtrC8 CExpiredPolicy::Contract()
{
return iContract->Des();
}
EXPORT_C TPtrC8 CExpiredPolicy::Endpoint()
{
return iEndpoint->Des();
}
EXPORT_C TPtrC8 CExpiredPolicy::Uri()
{
return iURI->Des();
}
TPtrC8 CExpiredPolicy::ProvideId()
{
return iProvideId->Des();
}
EXPORT_C TPtrC8 CExpiredPolicy::Contents()
{
if(iContents)
return iContents->Des();
else
return KNullDesC8();
}
EXPORT_C TInt CExpiredPolicy::SetContentsL(const TDesC8& aContent)
{
if(aContent.Length() > 0)
{
if(iContents)
{
delete iContents;
iContents = NULL;
}
iContents = aContent.AllocL();
return KErrNone;
}
return KErrArgument;
}
CExpiredPolicy::CExpiredPolicy() :iContents(NULL)
{
}
void CExpiredPolicy::ConstructL(const TDesC8& aContract, const TDesC8& aEndpoint, const TDesC8& aUri, const TDesC8& aProviderId)
{
iContract = aContract.AllocL();
iEndpoint = aEndpoint.AllocL();
iProvideId = aProviderId.AllocL();
iURI = aUri.AllocL();
}
CConsumerContainer* CConsumerContainer::NewL(const TDesC8& aUri, const TDesC8& aConsumerId)
{
CConsumerContainer* pNew = NewLC(aUri, aConsumerId);
CleanupStack::Pop(pNew);
return(pNew);
}
CConsumerContainer* CConsumerContainer::NewLC(const TDesC8& aUri, const TDesC8& aConsumerId)
{
CConsumerContainer* pNew = new (ELeave) CConsumerContainer();
CleanupStack::PushL(pNew);
pNew->ConstructL(aUri, aConsumerId);
return pNew;
}
CConsumerContainer::~CConsumerContainer()
{
delete iConsumerId;
delete iURI;
}
TPtrC8 CConsumerContainer::Uri()
{
return iURI->Des();
}
TPtrC8 CConsumerContainer::ConsumerId()
{
return iConsumerId->Des();
}
CConsumerContainer::CConsumerContainer()
{
}
void CConsumerContainer::ConstructL(const TDesC8& aUri, const TDesC8& aConsumerId)
{
iConsumerId = aConsumerId.AllocL();
iURI = aUri.AllocL();
}
// End of file