--- /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 <e32std.h>
+#include <utf.h> // for reading policy from file (utf-8 conversion)
+
+#include <SenServiceConnection.h> // 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<MSenHandlerContext*>(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<CSenWSDescription> 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<CSenWSDescription> 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<CSenWSDescription> 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<CSenWSDescription> 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<CSenElement> metaDataPoliciesUris;
+ CleanupClosePushL(metaDataPoliciesUris);
+ clientPolicy->ElementsL(metaDataPoliciesUris, KMetaDataLocalName);
+ 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();
+ 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
+