diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarplugin/src/wsstarpolicymanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsstar/wsstarplugin/src/wsstarpolicymanager.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,702 @@ +/* +* Copyright (c) 2006-2006 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 +#include // for reading policy from file (utf-8 conversion) + +#include // public error codes + +#include "senwspolicymanager.h" +#include "seninternalwspolicy.h" + +#include "wsstarpolicymanager.h" + +#include "senpointermap.h" +#include "wsstarhttpclient.h" +#include "wspolicy.h" +#include "sendebug.h" +#include "wsstardictionary.h" +#include "MSenServicePolicy.h" +#include "wsstarpolicyrequest.h" +#include "senlogger.h" + +class CWSStarHandlerContext; +class CWSStarPolicyHandler; +using namespace MSWSPolicy; + +namespace + { + _LIT8(KHttp, "http"); +/* + TInt IsUriAlreadyExist(const TDesC8& aContract, const TDesC8 aUriName, RPolicyRequestMap& aRequestMap) + { + TInt uriCount(aRequestMap.Count()); + // check this if it is already in aRequestMap + for (TInt j = 0; j< uriCount; j++) + { + CPolicyReqMap* req = aRequestMap[j]; + TPtrC8 contract = req->Contract(); + TPtrC8 uri = req->Uri(); + if(contract.Compare(aContract) == 0 && uri.Compare(aUriName) == 0) + { + return KErrNone; + } + } + return KErrNotFound; + } + */ + } + +//--------------------------------------------------------------------------- +// Create instance of concrete ECOM interface implementation +//--------------------------------------------------------------------------- +// +CWSStarPolicyManager* CWSStarPolicyManager::NewL(TAny* aHandlerCtx) + { + + MSenHandlerContext* handlerCtx = + reinterpret_cast(aHandlerCtx); + CWSStarPolicyManager* self = new (ELeave) CWSStarPolicyManager(*handlerCtx); + CleanupStack::PushL (self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +//--------------------------------------------------------------------------- +// Constructor +//--------------------------------------------------------------------------- +// +CWSStarPolicyManager::CWSStarPolicyManager(MSenHandlerContext& aCtx): iSenHandlerContext(aCtx) + { + } + +//--------------------------------------------------------------------------- +// Destructor +//--------------------------------------------------------------------------- +// +CWSStarPolicyManager::~CWSStarPolicyManager() + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("~CWSStarPolicyManager::~CWSStarPolicyManager()"))); + delete iRegistry; + delete iPolicyManager; +// iPolicyMap.ResetAndDestroy(); + iContracts.ResetAndDestroy(); + delete iDictionary; + + } + +//--------------------------------------------------------------------------- +// Second phase construction. +//--------------------------------------------------------------------------- +// +void CWSStarPolicyManager::ConstructL() + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPolicyManager::ConstructL()"))); + iRegistry = CPolicyRegistry::NewL(); + iDictionary = CWSStarDictionary::NewL(*(CSIF*)iSenHandlerContext.GetAnyL(HandlerContextKey::KSIF()), *Log());//codescannerwarnings + iPolicyManager = CSenWSPolicyManager::NewL(*iSenHandlerContext.GetSenCoreServiceManager()); + } + +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +TInt CWSStarPolicyManager::InvokeL(const TDesC8& aContract) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPolicyManager::InvokeL(const TDesC8& aContract)"); + + + if( aContract.Length() < 1 ) + { + return KErrArgument; + } + if(!IsContractExist(aContract)) + { + HBufC8* cont = aContract.AllocL(); + iContracts.Append(cont); + } + + return KErrNone; + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +TInt CWSStarPolicyManager::IsContractExist(const TDesC8& aContract) + { + + TInt count(iContracts.Count()); + for(TInt i = 0; i< count; i++) + { + + TPtrC8 contract = iContracts[i]->Des(); + if(contract.Compare(aContract) == 0) + { + return ETrue; + } + } + + return EFalse; + } +//--------------------------------------------------------------------------- +// +#if !defined( RD_SEN_WS_STAR_DISABLE_POLICY_HTTP_GET ) +TInt CWSStarPolicyManager::DownloadPolicyL( CSenWSDescription* apSD ) +#else // RD_SEN_WS_STAR_DISABLE_POLICY_HTTP_GET == TRUE +TInt CWSStarPolicyManager::DownloadPolicyL( CSenWSDescription* /* apSD */ ) +#endif // RD_SEN_WS_STAR_DISABLE_POLICY_HTTP_GET + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPolicyManager::DownloadPolicyL()"))); + TInt contCount = iContracts.Count(); + for(TInt j = 0; j< contCount; j++) + { + TPtrC8 ptr = iContracts[j]->Des(); + RegisterWsPolicyL(ptr); + } + + + TInt error(KErrNone); + TInt leaveCode(KErrNone); + + RExpiredPolicyArray list; + CleanupClosePushL(list); + TInt retVal = iPolicyManager->ExpiredPoliciesL(list, error); + if(retVal == KErrNone) + { + TPtrC8 finalUri(KHttp); + if( finalUri != KNullDesC8 ) + { + error = KErrNotFound; // testing + TInt leaveCode(KErrNone); + #if !defined( RD_SEN_WS_STAR_DISABLE_POLICY_HTTP_GET ) + TRAP( leaveCode, error = GetHttpPolicyL( finalUri, list, apSD); ) + #endif + + + + } + } + if( error ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPolicyManager::DownloadPolicyL:"); + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("- GetHttpPolicyL returned error: %d"), error )); + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel," => attempting to read policy from file system.."); + TRAP( leaveCode, error = GetPolicyFromFileL( list ); ) + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("- GetPolicyFromFileL returned: %d"), error )); + } + + CleanupStack::Pop(&list); + + TInt count(list.Count()); + for(TInt i = 0; i< count; i++) + { + CExpiredPolicy* req = list[i]; + if(req->Contents() != KNullDesC8()) + { + RPointerArray serviceDescriptions; + CleanupClosePushL(serviceDescriptions); + TInt retVal(KErrNone); + TInt leaveCode(KErrNone); + TRAP(leaveCode, retVal = iSenHandlerContext.GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, req->Contract())); + if(leaveCode == KErrNone && retVal == KErrNone && serviceDescriptions.Count() > 0) + { + for(TInt j = 0; j < serviceDescriptions.Count(); j++) + { + CSenWSDescription* sD = serviceDescriptions[j]; + + CSenWSDescription* tempSd = CSenWSDescription::NewLC(); + CBufFlat *pBuf = CBufFlat::NewL(64); + CleanupStack::PushL(pBuf); + RBufWriteStream bufWs(*pBuf); + CleanupClosePushL(bufWs); + + if(sD->Contract() == KWSStarSTSContract) + { + CWSStarTrustClient* pTrustClient = (CWSStarTrustClient*)sD; + pTrustClient->WriteAsXMLToL(bufWs); + tempSd->SetReader(*iSenHandlerContext.GetSenCoreServiceManager()->XMLReader()); + TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel,(pBuf->Ptr(0))); + tempSd->ParseL(pBuf->Ptr(0)); + } + else if (sD->DescriptionClassType() == MSenServiceDescription::EWSStarServiceSession) + { + CWSStarServiceSession* pSd = (CWSStarServiceSession*)sD; + pSd->WriteAsXMLToL(bufWs); + tempSd->SetReader(*iSenHandlerContext.GetSenCoreServiceManager()->XMLReader()); + TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel,(pBuf->Ptr(0))); + tempSd->ParseL(pBuf->Ptr(0)); + } + + CleanupStack::PopAndDestroy(&bufWs); + CleanupStack::PopAndDestroy(pBuf); + + TInt errorCode(KErrGeneral); + AddWsPolicy1L(tempSd, req->Uri(), req->Contents(), errorCode ); + iDictionary->InvokeL(&iSenHandlerContext, tempSd); + TSenDataTrafficDetails details; + iDictionary->DataTrafficDetails(details); + iPolicyDetails += details; + CleanupStack::PopAndDestroy(tempSd); + } + } + CleanupStack::PopAndDestroy(&serviceDescriptions); + } + } + list.ResetAndDestroy(); +/* +//This is ONLY working for MS cases. i.e. urn:wstar:sts contract. +//Right now its not parsing any other Sds to find dictionaries becuase +//the search uses MS specifc namespace to dfind the dictioanry elements +#ifndef RD_SEN_WS_STAR_DISABLE_DICTIONARY_FETCHING + iDictionary->InvokeL(&iSenHandlerContext); +#endif // not defined RD_SEN_WS_STAR_DISABLE_DICTIONARY_FETCHING +// } + requestMap.ResetAndDestroy(); + iRegistry->ResetRegistry(); +*/ + return error; + } + +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +TInt CWSStarPolicyManager::GetHttpPolicyL( const TDesC8& aEndpoint, RExpiredPolicyArray& aRequestMap, CSenWSDescription* /*apSD*/ ) + { + TInt retVal(KErrNone); + CSenWSDescription* pInitializer = CSenWSDescription::NewLC(); + pInitializer->SetEndPointL(aEndpoint); + + CWSStarHttpClient* pPolicyClient = CWSStarHttpClient::NewLC(*(CSIF*)iSenHandlerContext.GetAnyL(HandlerContextKey::KSIF()), pInitializer, *Log());//codescannerwarnings + + // Fix the first URI and request part of the request + TInt count( aRequestMap.Count() ); + for (TInt i = 0; i< count; i++) + { + + CExpiredPolicy* req = aRequestMap[i]; + TPtrC8 contract = req->Contract(); + TPtrC8 endpoint = req->Uri(); + + TPtrC8 request(endpoint.Right(endpoint.Length() - aEndpoint.Length())); + + RPointerArray serviceDescriptions; + CleanupClosePushL(serviceDescriptions); + TInt retVal(KErrNone); + TInt leaveCode(KErrNone); + TRAP(leaveCode, retVal = iSenHandlerContext.GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, contract)); + if(leaveCode == KErrNone && retVal == KErrNone && serviceDescriptions.Count() > 0) + { + CSenWSDescription* sD = serviceDescriptions[0]; + + HBufC8* pResponse = NULL; + TInt leaveCode(KErrNone); + TInt submitRetCode(KErrNone); + + TRAP( leaveCode, submitRetCode = pPolicyClient->GetHttpL( request, pResponse, sD ); ) + TSenDataTrafficDetails details; + pPolicyClient->DataTrafficDetails(details); + iPolicyDetails += details; + + if( submitRetCode && retVal == KErrNone ) + { + // Store the error code from the 1st failing request + retVal = submitRetCode; + } + if( leaveCode && retVal == KErrNone ) + { + retVal = leaveCode; + } + if(pResponse && pResponse->Length() > 0) + { + CleanupStack::PushL(pResponse); + TPtrC8 pReq = pResponse->Des(); + req->SetContentsL( pReq ); + CleanupStack::PopAndDestroy(pResponse); + } + else // if(retVal == 404) + { + delete pResponse; + TPtrC8 pReq(KNullDesC8()); + req->SetContentsL( pReq ); + } + + } + CleanupStack::PopAndDestroy(&serviceDescriptions); + + + } // for each request + CleanupStack::PopAndDestroy(pPolicyClient); + CleanupStack::PopAndDestroy(pInitializer); + return retVal; + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +// start of "debug / test method" +TInt CWSStarPolicyManager::GetPolicyFromFileL( RExpiredPolicyArray& aRequestMap ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPolicyManager::GetPolicyFromFileL:"); + + TInt retVal(KErrNone); + + TInt count(aRequestMap.Count()); + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8("- Count: %d"), count)); + + _LIT(KPath, "c:\\"); + for (TInt i = 0; i< count; i++) + { + TFileName filepath(KPath); + + CExpiredPolicy* req = aRequestMap[i]; + TPtrC8 contract = req->Contract(); + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8("- Contract: '%S'"), &contract)); + + TPtrC8 endpoint = req->Uri(); + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8("- Endpoint: '%S'"), &endpoint)); + + TInt namePosition = endpoint.LocateReverse('/'); + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8("- Nameposition: %d"), namePosition)); + + + if(namePosition > 0) + { +// _LIT(KXmlFileExt, ".xml"); + + TPtrC8 name = endpoint.Right( endpoint.Length() - (namePosition+1) ); + + if( name == KNullDesC8 ) + { + // Note: if metadata endpoint ends with '/' -char, USE hardcoded DEFAULT VALUE + _LIT8(KDefaultPolicyFilename, "secpol.xml"); + name.Set( KDefaultPolicyFilename ); + } + + HBufC* nameBuf = HBufC::NewLC(name.Length()); + TPtr nameBufPtr( nameBuf->Des() ); + + retVal = CnvUtfConverter::ConvertToUnicodeFromUtf8( nameBufPtr, name ); + + if(retVal == KErrNone) + { + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8("- Policy file name: '%S'"), nameBuf)); + TFileName filename; + filename.Append( nameBufPtr ); + filepath.Append( filename ); + + RFs fss; + User::LeaveIfError( fss.Connect() ); + CleanupClosePushL( fss ); + + RFile xmlFile; + retVal = xmlFile.Open(fss , filepath, EFileRead ); + if(retVal == KErrNone) + { + TInt size; + xmlFile.Size(size); + if(size > 0) + { + HBufC8 *pBuf=HBufC8::NewLC(size); // CodeScannerWarning + TPtr8 buf8ptr(pBuf->Des()); + xmlFile.Read(buf8ptr, size); + req->SetContentsL(buf8ptr); + CleanupStack::PopAndDestroy(pBuf); + } + } + xmlFile.Close(); + CleanupStack::PopAndDestroy( &fss ); + } + CleanupStack::PopAndDestroy( nameBuf ); + } + } + return retVal; + } +// end of "debug / test method" + +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +CSenElement* CWSStarPolicyManager::PolicyL(MSenServiceDescription* aSD) //codescannerwarnings + { + TInt error(KErrGeneral); + CSenWSDescription* sd = (CSenWSDescription*)aSD; + CSenElement* ele = WsPolicy1L(sd, error); + + if(error == KErrNone) + return ele; + + return NULL; + } + +CSenElement* CWSStarPolicyManager::PolicyL(const TDesC8& aUri) //codescannerwarnings + { + TInt error(KErrGeneral); + + CSenElement* ele = WsPolicy1L(NULL, aUri, error); + + if(error == KErrNone) + return ele; + + return NULL; + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +TInt CWSStarPolicyManager::UpdatePolicyL(CWSStarPolicyHandler* aPolicyHandler) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPolicyManager::UpdatePolicyL "))); + TInt retVal(KErrNone); + + TInt count(iContracts.Count()); + for ( TInt i = 0; i < count; i++ ) + { + TPtrC8 contract = iContracts[i]->Des(); + RPointerArray serviceDescriptions; + CleanupClosePushL(serviceDescriptions); + + TInt leaveCode(KErrNone); + TInt getSDsError(KErrNone); + TRAP(leaveCode, getSDsError = iSenHandlerContext.GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, contract)); + if( getSDsError && retVal == KErrNone ) + { + // store the return code from 1st error: + retVal = getSDsError; + } + + TInt sdCount(serviceDescriptions.Count()); + if( sdCount > 0 && getSDsError == KErrNone && leaveCode == KErrNone ) + { + for ( TInt j = 0; j < sdCount; j++ ) + { + CSenWSDescription* sD = serviceDescriptions[j]; + TInt updateError(KErrNone); + if(sD->Contract() == KWSStarSTSContract) + { + CWSStarTrustClient* pTrustClient = (CWSStarTrustClient*)sD; + updateError = pTrustClient->UpdatePolicyL( aPolicyHandler, pTrustClient ); + } + else if (sD->DescriptionClassType() == MSenServiceDescription::EWSStarServiceSession) + { + CWSStarServiceSession* pWsSession = (CWSStarServiceSession*)sD; + updateError = pWsSession->UpdatePolicyL( aPolicyHandler, pWsSession ); + } + if( updateError && retVal == KErrNone ) + { + // store the code from first update error: + retVal = updateError; + } + } // for each SD + } // if any SD to process + CleanupStack::PopAndDestroy(); //serviceDescriptions + + } // for each item in policy map + return retVal; + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +RFileLogger* CWSStarPolicyManager::Log() const + { + RFileLogger* pLog = NULL; + TRAP_IGNORE( pLog = (RFileLogger*)iSenHandlerContext.GetAnyL(HandlerContextKey::KLogger); ) + return pLog; + } + + +TInt CWSStarPolicyManager::RegisterWsPolicyL( const TDesC8& aContract ) + { + + RPointerArray serviceDescriptions; + CleanupClosePushL(serviceDescriptions); + TInt retVal(KErrNone); + TInt leaveCode(KErrNone); + TInt errorCode(KErrGeneral); + TRAP(leaveCode, retVal = iSenHandlerContext.GetSenCoreServiceManager()->ServiceDescriptionsL(serviceDescriptions, aContract)); + if(leaveCode == KErrNone && retVal == KErrNone && serviceDescriptions.Count() > 0) + { + for(TInt j = 0; j < serviceDescriptions.Count(); j++) + { + CSenWSDescription* sD = serviceDescriptions[j]; + CSenWSDescription* tempSd = CSenWSDescription::NewLC(); + CBufFlat *pBuf = CBufFlat::NewL(64); + CleanupStack::PushL(pBuf); + RBufWriteStream bufWs(*pBuf); + CleanupClosePushL(bufWs); + + if(sD->Contract() == KWSStarSTSContract) + { + CWSStarTrustClient* pTrustClient = (CWSStarTrustClient*)sD; + pTrustClient->WriteAsXMLToL(bufWs); + tempSd->SetReader(*iSenHandlerContext.GetSenCoreServiceManager()->XMLReader()); + TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel,(pBuf->Ptr(0))); + tempSd->ParseL(pBuf->Ptr(0)); + } + else if (sD->DescriptionClassType() == MSenServiceDescription::EWSStarServiceSession) + { + CWSStarServiceSession* pSd = (CWSStarServiceSession*)sD; + pSd->WriteAsXMLToL(bufWs); + tempSd->SetReader(*iSenHandlerContext.GetSenCoreServiceManager()->XMLReader()); + TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase , KMaxLogLevel,(pBuf->Ptr(0))); + tempSd->ParseL(pBuf->Ptr(0)); + } + + CleanupStack::PopAndDestroy(&bufWs); + CleanupStack::PopAndDestroy(pBuf); + + RegisterWsPolicy1L(tempSd, errorCode); + + CleanupStack::PopAndDestroy(tempSd); + + } + } + CleanupStack::PopAndDestroy(&serviceDescriptions); + return KErrNone; + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// +TInt CWSStarPolicyManager::UnRegisterWsPolicyL(MSenServiceDescription& aServiceDescription, + TInt& aErrorTo) + { + CSenWSDescription* sD = (CSenWSDescription*)&aServiceDescription; + return UnRegisterWsPolicy1L(sD, aErrorTo); + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// + +TInt CWSStarPolicyManager::PolicyConsumerAddedL(CSenServiceSession* aNewSession, MSenRemoteServiceConsumer& aRemoteConsumer) + { + + CSenElement* clientPolicy = NULL; + MSenServicePolicy* service = NULL; + TPtrC8 cosumerid = aRemoteConsumer.Id(); + + if(aNewSession->Contract() == KWSStarSTSContract) + { + CWSStarTrustClient* pTrustClient = (CWSStarTrustClient*)aNewSession; + service = pTrustClient->ServicePolicy(); + clientPolicy = service->ClientPolicy(); + } + else if(aNewSession->DescriptionClassType() == MSenServiceDescription::EWSStarServiceSession) + { + service = aNewSession->ServicePolicy(); + clientPolicy = service->ClientPolicy(); + } + + + if(clientPolicy) + { + RPointerArray metaDataPoliciesUris; + CleanupClosePushL(metaDataPoliciesUris); + clientPolicy->ElementsL(metaDataPoliciesUris, KMetaDataLocalName); + TInt count(metaDataPoliciesUris.Count()); + if(count> 0) + { + CSenElement* metaData = NULL; + for(TInt i=0; iHasContent()) + { + TPtrC8 uriName = metaData->Content(); + AddPolicyConsumer1L(uriName,cosumerid); + } + } + } + CleanupStack::PopAndDestroy(&metaDataPoliciesUris); + } + + return KErrNone; + } +//--------------------------------------------------------------------------- +// +//--------------------------------------------------------------------------- +// + +TInt CWSStarPolicyManager::AddWsPolicy1L(CSenWSDescription* aPattern, const TDesC8& aUri, + const TDesC8& aPolicy, TInt& aErrorTo) +{ + return iPolicyManager->AddWsPolicy1L(aPattern, aUri, aPolicy, aErrorTo); +} + +TInt CWSStarPolicyManager::RemoveWsPolicy1L( CSenWSDescription* aPattern, + const TDesC8& aUri, TInt& aErrorTo) +{ + return iPolicyManager->RemoveWsPolicy1L(aPattern, aUri, aErrorTo); +} + +TInt CWSStarPolicyManager::RegisterWsPolicy1L(CSenWSDescription* aPattern, + TInt& aErrorTo) +{ + return iPolicyManager->RegisterWsPolicyL(aPattern, aErrorTo); +} + +TInt CWSStarPolicyManager::UnRegisterWsPolicy1L(CSenWSDescription* aPattern, + TInt& aErrorTo) +{ + return iPolicyManager->UnRegisterWsPolicy1L(aPattern, aErrorTo); +} + +CSenElement* CWSStarPolicyManager::WsPolicy1L( CSenWSDescription* aPattern, + const TDesC8& aUri, TInt& aErrorTo) +{ + return iPolicyManager->WsPolicy1L(aPattern, aUri, aErrorTo); +} + +CSenElement* CWSStarPolicyManager::WsPolicy1L( CSenWSDescription* aPattern, + TInt& aErrorTo) +{ + return iPolicyManager->WsPolicy1L(aPattern, aErrorTo); +} +CSenElement* CWSStarPolicyManager::WsPolicy1L( const TDesC8& aProviderId, TInt& aErrorTo) +{ + return iPolicyManager->WsPolicy1L(aProviderId, aErrorTo); +} +TInt CWSStarPolicyManager::AddPolicyConsumer1L(const TDesC8& aUri, const TDesC8& aConsumerId) +{ + return iPolicyManager->AddPolicyConsumer1L(aUri,aConsumerId); +} + +TInt CWSStarPolicyManager::RemovePolicyConsumer1L(const TDesC8& aUri, const TDesC8& aConsumerId) +{ + return iPolicyManager->RemovePolicyConsumer1L(aUri,aConsumerId); +} +void CWSStarPolicyManager::DataTrafficDetails(TSenDataTrafficDetails& aDetails) +{ + aDetails = iPolicyDetails; +} + +// END OF FILE +