diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarplugin/src/wsstarplugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsstar/wsstarplugin/src/wsstarplugin.cpp Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,1174 @@ +/* +* 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 "wsstarplugin.h" +#include "SenServiceConnection.h" // framework IDs, error codes +#include "sendebug.h" +#include "senlogger.h" +#include "MSenServiceDescription.h" +#include "wsstarservicesession.h" +#include "SenXmlUtils.h" +#include "wsstarpolicy.h" +#include "senguidgen.h" + +#include "wsstarpolicyhandler.h" +using namespace WSStarConfig; + +// Local CONSTANTS +const TInt KMaxLengthXml = 1280; + +// --------------------------------------------------------------------------- +// Create instance of concrete ECOM interface implementation +// --------------------------------------------------------------------------- +// +CWSStarPlugin* CWSStarPlugin::NewL(TAny* aManager) + { + MSenCoreServiceManager* manager = + reinterpret_cast(aManager); + + CWSStarPlugin* self = new (ELeave) CWSStarPlugin(*manager); + CleanupStack::PushL (self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CWSStarPlugin::CWSStarPlugin(MSenCoreServiceManager& aManager) + : iManager(aManager), + iVersions(ETrue, ETrue), + iDbReadDone(EFalse) + { + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +CWSStarPlugin::~CWSStarPlugin() + { + iMsgHandlers.ResetAndDestroy(); + iSessionHandlers.ResetAndDestroy(); + iHandlerContexts.ResetAndDestroy(); + iVersions.Reset(); + delete iDeviceId; + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::~CWSStarPlugin()"))); + } + +// --------------------------------------------------------------------------- +// Second phase construction. +// --------------------------------------------------------------------------- +// +void CWSStarPlugin::ConstructL() + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ConstructL"))); + + BaseConstructL(KFrameworkXMLNS, KFrameworkLocalName); + GenerateDeviceIdL(); + //load default setup of handlers + AddHandlerL(KValidateValue, KNullDesC8, SenHandler::ESessionHandler);//old http://schemas.xmlsoap.org/ws/2004/04/trust + AddHandlerL(KRegisterValue, KNullDesC8, SenHandler::ESessionHandler); + AddHandlerL(KServiceUpdateValue, KNullDesC8, SenHandler::ESessionHandler);//new http://schemas.xmlsoap.org/ws/2004/08/addressing + + AddHandlerL(KEnveloperValue, KNullDesC8, SenHandler::EMessageHandler);//old http://schemas.xmlsoap.org/soap/envelope + AddHandlerL(KCredentialCollectorValue, KNullDesC8, SenHandler::EMessageHandler); + AddHandlerL(KAddressingValue, KNullDesC8, SenHandler::EMessageHandler);//new http://schemas.xmlsoap.org/ws/2004/08/addressing + AddHandlerL(KPassportValue, KNullDesC8, SenHandler::EMessageHandler); + AddHandlerL(KSecurityValue, KNullDesC8, SenHandler::EMessageHandler); + AddHandlerL(KPolicyValue, KNullDesC8, SenHandler::ESessionHandler); //Initalize policy +#ifdef RD_SEN_VTCP_SUPPORT + AddHandlerL(KCoBrandingValue, KNullDesC8, SenHandler::ESessionHandler); //Initalize co-branding +#endif//RD_SEN_VTCP_SUPPORT + } + +// --------------------------------------------------------------------------- +// Getter for logger. Works only in debug mode. +// --------------------------------------------------------------------------- +// +/*RFileLogger* CWSStarPlugin::Log() const + { + return iManager.Log(); + } +*/ + +//======================================================== +// MSIF SPecific +//======================================================== + +//--------------------------------------------------------------------------- +// Attempt to register the ServiceDescription to the ServiceManager +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::RegisterServiceDescriptionL( + MSenServiceDescription& aServiceDescription ) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::RegisterServiceDescriptionL(.)"))); + TInt error(KErrNone); + + CWSStarPolicyHandler* pPolicyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + CWSStarSessionContext* pSessionRegisterCtx = CWSStarSessionContext::NewLC(Manager().XMLReader(), &aServiceDescription, pPolicyHandler); + pSessionRegisterCtx->Add(WSStarContextKeys::KServiceDescription(), + (CSenWSDescription*)&aServiceDescription); + pSessionRegisterCtx->Add(WSStarContextKeys::KRegisterAction(), + WSStarContextValues::KActionRegister()); +//policy initalization + TPtrC8 contract = aServiceDescription.Contract(); + TRAPD(policyError, pPolicyHandler->InvokeL(contract)); + if (policyError!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::RegisterServiceDescriptionL() !!!!leave from PolicyHandler"))); + } + +//SOA for S60 Composable Handler Framework v0.1 - 7.5.3.1 point 1) + CSenSessionHandler* pregisterHandler = + (CSenSessionHandler*)Handler(KRegisterValue()); + + TRAPD(errorL,error= pregisterHandler->InvokeL(*pSessionRegisterCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::RegisterServiceDescriptionL() !!!!leave from RegisterHandler"))); + error = errorL; + } + CleanupStack::PopAndDestroy(pSessionRegisterCtx); + return error; + } + +//--------------------------------------------------------------------------- +// Attempt to unregister the ServiceDescription from the ServiceManager +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::UnregisterServiceDescriptionL( + MSenServiceDescription& aServiceDescription) + { + + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::UnRegisterServiceDescriptionL(.)"))); +//SOA for S60 Composable Handler Framework v0.1 - 7.5.3.1 point 1) + TInt error(KErrNone); + CSenSessionHandler* pregisterHandler = + (CSenSessionHandler*)Handler(KRegisterValue()); + + CWSStarSessionContext* pSessionRegisterCtx = CWSStarSessionContext::NewLC(Manager().XMLReader(), &aServiceDescription); + pSessionRegisterCtx->Add(WSStarContextKeys::KServiceDescription(), + (CSenWSDescription*)&aServiceDescription); + pSessionRegisterCtx->Add(WSStarContextKeys::KRegisterAction(), + WSStarContextValues::KActionUnregister()); + CWSStarPolicyHandler* pPolicyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + TRAPD(policyError, pPolicyHandler->UnRegisterWsPolicyL(aServiceDescription)); + if (policyError!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::UnRegisterServiceDescriptionL() !!!!leave from PolicyHandler"))); + } + + TRAPD(errorL,error = pregisterHandler->InvokeL(*pSessionRegisterCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::UnregisterServiceDescriptionL() !!!!leave from RegisterHandler"))); + error = errorL; + } + CleanupStack::PopAndDestroy(pSessionRegisterCtx); + return error; + } + +//--------------------------------------------------------------------------- +// Getter of framework (like "WS-STAR") +//--------------------------------------------------------------------------- +// +const TDesC8& CWSStarPlugin::Id() + { + return KDefaultWSStarFrameworkID(); + } + +//--------------------------------------------------------------------------- +// Try to find one or more services that match the given ServiceDescription. +// Adding is only invoked if NO! session in cache. +// Its mean that we have create new one. +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::AddServiceDescriptionL( MSenServiceDescription& aPattern, + MSenRemoteServiceConsumer& aRemoteConsumer, + HBufC8*& aErrorMessage ) + { + TInt addedSD(0); + //-----1.no disco phase + //-----2.establish credential and put to session + //-----3.set validator. Enables re-auth for cases when credential is expired between init and send + if(aPattern.FrameworkId() != KDefaultWSStarFrameworkID) + { + CSLOG_L(aRemoteConsumer.ConnectionId(),KNormalLogLevel ,"CWSStarPlugin::AddServiceDescriptionL - this is not KDefaultWSStarFrameworkID"); + addedSD = 0; // zero added + } + else if( aPattern.Endpoint().Length() > 0 && aPattern.Contract().Length() > 0 ) + { + CWSStarServiceSession* pNewSession = CWSStarServiceSession::NewL(*this); + CleanupStack::PushL(pNewSession); + + // InitializeFromL copies the contract and endpoint of concrete service + // also context will be set + CWSStarPolicyHandler* policyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + pNewSession->InitializeFromL(aPattern, policyHandler); + pNewSession->AddConsumerL(aRemoteConsumer); + TSenDataTrafficDetails policyDetails; + policyHandler->DataTrafficDetails(policyDetails); + aRemoteConsumer.SetDataTrafficDetails(policyDetails); + pNewSession->SessionContext()->Update(WSStarContextKeys::KOnlySharing, EFalse); +//SOA for S60 Composable Handler Framework v0.1 - 7.5.3.1 point 3) + TInt error = ProcessOutboundValidationL( aPattern, + (MSenRemoteServiceSession*)pNewSession, + aErrorMessage ); + CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("CWSStarPlugin::AddServiceDescriptionL - ProcessOutboundValidation returned: %d"), error)); + if ( !error ) + { + CWSStarSessionContext* pSessionRegisterCtx = pNewSession->SessionContext(); + TPtrC8 cont = aPattern.Contract(); + TInt policyLeaveCode(KErrNone); + TRAP( policyLeaveCode, error = policyHandler->InvokeL(cont); ) + if ( policyLeaveCode ) + { + CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("CWSStarPlugin::AddServiceDescriptionL - PolicyHandler->Invoke() leaved: %d"), policyLeaveCode)); + CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::AddServiceDescriptionL() - FATAL: leave from PolicyHandler->Invoke()"); + error = policyLeaveCode; + } +#ifdef _SENDEBUG + else + { + CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("CWSStarPlugin::AddServiceDescriptionL - PolicyHandler->Invoke() returned: %d"), error)); + } +#endif // _SENDEBUG + } + if ( error ) + { + addedSD = error; + CleanupStack::PopAndDestroy(pNewSession); + } + else // BOTH outbound validation and policy handler invokation OK(!): + { + Manager().AddServiceDescriptionL((CSenWSDescription*)pNewSession); + addedSD = 1; + CleanupStack::Pop(pNewSession); //now session is owned by Core / XML DAO + } + } + else + { + CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::AddServiceDescriptionL - No endpoint AND no contract; new session could not be added."); + addedSD = 0; // zero added + } + return addedSD; + } + +//--------------------------------------------------------------------------- +// Create a ServiceSession based upon the given ServiceDescription. +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::CreateServiceSessionL( MSenServiceDescription& aServiceDescription, + MSenServiceDescription& aPattern, + CSenServiceSession*& aNewSession, + MSenRemoteServiceConsumer& aRemoteConsumer, + HBufC8*& aErrorMessage ) + { + TInt error(KErrNone); + if( aServiceDescription.DescriptionClassType() == MSenServiceDescription::EWSStarServiceSession ) + { + //example: when init connection with not registered description, nothing in db + //example: when bootup and description was already in db (registered during parsing db.file) + aNewSession = (CWSStarServiceSession*) &aServiceDescription; + CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::ServiceDescription is already a ServiceSession"); + } + else + { + aNewSession = (CWSStarServiceSession*) NewServiceDescriptionL(); + error = ((CWSStarServiceSession*)aNewSession)->InitializeFromL( aServiceDescription ); + CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("CWSStarPlugin::ServiceDescription is not a ServiceSession, creating new one returned: %d"), error)); + } + if(aNewSession && !error)//if session was just created, its possible that its not validate + { + //((CWSStarServiceSession*)aNewSession)->DetachCredentialsL() ; //invalidating session to recompute the status + TBool isHostlet = ((CWSStarServiceSession*)aNewSession)->AmIHostletSession() ; + TInt credentialValidityError = KErrNone ; + TBool delegateToSTS = EFalse ; + if (!isHostlet) + { + credentialValidityError = ((CWSStarServiceSession*)aNewSession)->TryToSearchValidCredentialL() ; + if (KErrNone == credentialValidityError) + { + CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::CreateServiceSessionL() Valid credential found"); + } + else + { + delegateToSTS = ETrue ; + CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("CWSStarPlugin::CreateServiceSessionL() No Valid credential found credentialValidityError = [%d]"), credentialValidityError)); + } + } + if(!aNewSession->IsReadyL()) + { + delegateToSTS = ETrue ; + CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::CreateServiceSessionL() ServiceSession is not ready !!"); + } + else + { + CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::CreateServiceSessionL() ServiceSession is ready"); + } + +// if(!aNewSession->IsReadyL()) + if(delegateToSTS) + { +// CSLOG_L(aRemoteConsumer.ConnectionId(),KMinLogLevel ,"CWSStarPlugin::ServiceSession is not ready"); + //example: when credentail was parsed(exist) and additionally expired. + // We dont need revalidate if credentials doesnt exist at all + + + CWSStarSessionContext* pSessionValidateCtx = ((CWSStarServiceSession*)aNewSession)->SessionContext(); + if (!pSessionValidateCtx) //sessionCts exist if revalidation is processing + { + CWSStarPolicyHandler* policyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + pSessionValidateCtx = CWSStarSessionContext::NewLC(Manager().XMLReader(), &aPattern, policyHandler); + pSessionValidateCtx->Add(WSStarContextKeys::KServiceSession(), *(MSenRemoteServiceSession*)aNewSession); + ((CWSStarServiceSession*)aNewSession)->SetSessionContext(pSessionValidateCtx); + CleanupStack::Pop(pSessionValidateCtx); + } + + pSessionValidateCtx->Update(WSStarContextKeys::KRemoteConsumer(), + &aRemoteConsumer); + aNewSession->AddConsumerL(aRemoteConsumer); + pSessionValidateCtx->Update(WSStarContextKeys::KOnlySharing, EFalse); + error = ProcessOutboundValidationL( aPattern, + (MSenRemoteServiceSession*)aNewSession, + aErrorMessage ); + if (error) aNewSession->RemoveConsumerL(aRemoteConsumer); + } + } + return error; + } + +TInt CWSStarPlugin::IssuePolicyDownloadL( CSenWSDescription* apSession ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::IssuePolicyDownloadL"); + TInt retCode(KErrNone); + CWSStarPolicyHandler* pPolicyHandler = (CWSStarPolicyHandler*)Handler(KPolicyValue()); + TInt policyLeave(KErrNone); + TRAP(policyLeave, retCode = pPolicyHandler->DownloadPolicyL( apSession )); + if (policyLeave!=KErrNone) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::IssuePolicyDownloadL - FATAL: leave from PolicyHandler"); + retCode = policyLeave; + } + retCode = pPolicyHandler->UpdatePolicyL(); + return retCode; + } + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::OnEvent( const TInt aEvent, TAny* apArgument ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::OnEvent"); + TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KNormalLogLevel, _L8(" -event code: %d"), aEvent)); + TInt retCode(KErrNone); + TInt leaveCode( KErrNone ); + + switch( aEvent) + { + + case KSenEventConsumerAdded: + { + ++iConsumerCount; + CSenWSDescription* pSD = NULL; // not required + TRAP( leaveCode, retCode = IssuePolicyDownloadL( pSD ); ) + if( leaveCode ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::OnEvent( KSenEventConsumerAdded ) - leave from IssuePolicyDownloadL"); + if( !retCode ) + { + retCode = leaveCode; + } + } + break; + } + + case KSenEventConsumerRemoved: + { + --iConsumerCount; + break; + } + + case KSenEventWsfReady: + { + iDbReadDone = ETrue; + } + break; + + case KSenEventRegisterNewServiceDescription: + { + if( iDbReadDone/* && iConsumerCount > 0*/ ) + { + CSenWSDescription* pSD = (CSenWSDescription*)apArgument; + TInt policyLeave(KErrNone); + TRAP(policyLeave, retCode = IssuePolicyDownloadL( pSD ); ) + if ( policyLeave & !retCode ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::OnEvent( KSenEventSessionsDbReadComplete ) - leave from IssuePolicyDownloadL"); + retCode = policyLeave; + } + } + } + break; + + case KSenEventSessionsDbReadComplete: + { + // Current implementation downloads policy independent of (whether or not) + // the session database has been read or not + if( iConsumerCount > 0 ) + { + CSenWSDescription* pSD = (CSenWSDescription*)apArgument; + TInt policyLeave(KErrNone); + TRAP(policyLeave, retCode = IssuePolicyDownloadL( pSD ); ) + if ( policyLeave & !retCode ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::OnEvent( KSenEventSessionsDbReadComplete ) - leave from IssuePolicyDownloadL"); + if( !retCode ) + { + retCode = policyLeave; + } + } + } + } + break; + + case KSenEventRegisterIdentityProvider: + case KSenEventUnregisterIdentityProvider: + { + TInt policyLeave(KErrNone); + TRAP(policyLeave, VerifyPermissionOnEachSessionL(); ) + if ( policyLeave & !retCode ) + { + TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CWSStarPlugin::OnEvent( KSenEventSessionsDbReadComplete ) - leave from VerifyPermissionOnEachSessionL"); + if( !retCode ) + { + retCode = policyLeave; + } + } + } + break; + + default: + { + // do nothing + } + } + return retCode; + } + + +void CWSStarPlugin::VerifyPermissionOnEachSessionL() + { +//-- LOG_WRITE_L("CWSStarPlugin::VerifyPermissionOnEachSessionL"); + + CSenWSDescription* pOpenMask = CSenWSDescription::NewLC( KNullDesC8, KNullDesC8 ); // this matches with *any* ServDescription + pOpenMask->SetFrameworkIdL(KDefaultWSStarFrameworkID); // now it matches with any WS-* session + + RWSDescriptionArray all; + iManager.ServiceDescriptionsL(all, *pOpenMask); + CleanupStack::PopAndDestroy(pOpenMask); + CleanupClosePushL(all); + + TInt count(all.Count()); + +//-- LOG_WRITEFORMAT((_L("- %d WS-* service session(s) found."), count)); + +#ifdef _SENDEBUG +//-- TInt verified = 0; +#endif // _SENDEBUG + + for(TInt i=0; iDescriptionClassType() == MSenServiceDescription::EWSStarServiceSession) + { + CWSStarServiceSession* pSession = (CWSStarServiceSession*)pSD; + pSession->VerifyPermissionL(); // accessible through friendship +#ifdef _SENDEBUG +//-- verified++; +//-- LOG_WRITEFORMAT((_L("- Verified a session (#%d)"), verified)); +#endif // _SENDEBUG + } + } + CleanupStack::PopAndDestroy(&all); + } + +//--------------------------------------------------------------------------- +// There is no extended interface in WSStar framework at the moment. +//--------------------------------------------------------------------------- +// +TAny* CWSStarPlugin::ExtendedInterface() + { + return NULL; + } + +//--------------------------------------------------------------------------- +// Return a new instance of a framework specific class that +// implements the ServiceDesccription interface. +//--------------------------------------------------------------------------- +// +CSenWSDescription* CWSStarPlugin::NewServiceDescriptionL() + { + CWSStarServiceSession* pSD = + CWSStarServiceSession::NewL(*this); + CleanupStack::PushL(pSD); + pSD->SetFrameworkIdL(KDefaultWSStarFrameworkID); + CleanupStack::Pop(pSD); + return pSD; + } + +//--------------------------------------------------------------------------- +// Getter for manager +//--------------------------------------------------------------------------- +// +MSenCoreServiceManager& CWSStarPlugin::Manager() + { + return iManager; + } +//--------------------------------------------------------------------------- +// Setter for manager +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::SetManager(MSenCoreServiceManager& aServiceManager) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::SetManager(.)"))); + iManager = aServiceManager; + } +//--------------------------------------------------------------------------- +// Getter for configParser +//--------------------------------------------------------------------------- +// +CSenBaseFragment& CWSStarPlugin::ConfigParser() + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ConfigParser()"))); + return *this; + //return callbacks which will be invoked during parsing rest of config + //this callbacks will be responsible for loading features + } + +//--------------------------------------------------------------------------- +// UCS2 serializer +//--------------------------------------------------------------------------- +HBufC* CWSStarPlugin::AsXmlUnicodeL() + { + HBufC8* pUtf8 = AsXmlL(); + CleanupStack::PushL(pUtf8); + HBufC* pAsAxlInUnicode = SenXmlUtils::ToUnicodeLC(*pUtf8); + CleanupStack::Pop(pAsAxlInUnicode); + CleanupStack::PopAndDestroy(pUtf8); + return pAsAxlInUnicode; + } + +//--------------------------------------------------------------------------- +// UTF8 serializer +//--------------------------------------------------------------------------- +HBufC8* CWSStarPlugin::AsXmlL() + { + HBufC8* retVal = HBufC8::NewLC(KMaxLengthXml); + TPtr8 ptr = retVal->Des(); + ptr.Append(KSenLessThan); + ptr.Append(KFrameworkLocalName); + ptr.Append(KSenSpace); + ptr.Append(KSenSpaceXmlns); + ptr.Append(KSenEqualsDblQuot); + ptr.Append(KFrameworkXMLNS); + ptr.Append(KSenDblQuot); + + ptr.Append(KSenSpace); + ptr.Append(KClassAttr); + ptr.Append(KSenEqualsDblQuot); + ptr.Append(KFrameworkCue); + ptr.Append(KSenDblQuot); + ptr.Append(KSenGreaterThan); + + +//deviceId + ptr.Append(KSenLessThan); + ptr.Append(KDeviceIdLocalName); + ptr.Append(KSenGreaterThan); + if (iDeviceId) + { + ptr.Append(*iDeviceId); + } + ptr.Append(KSenLessThanSlash); + ptr.Append(KDeviceIdLocalName); + ptr.Append(KSenGreaterThan); + +//--message handlers + for (TInt i=0; i < iMsgHandlers.Count(); i++) + { + AddHandlerTag(ptr, iMsgHandlers[i]->Name()); + } +//--session handlers + for (TInt i=0; i < iSessionHandlers.Count(); i++) + { + AddHandlerTag(ptr, iSessionHandlers[i]->Name()); + } + + ptr.Append(KSenLessThanSlash); + ptr.Append(KFrameworkLocalName); + ptr.Append(KSenGreaterThan); + CleanupStack::Pop(retVal); + return retVal; + } + + + +//--------------------------------------------------------------------------- +// used during reading configuration of WSStar framework in order to load +// proper handlers. +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::StartElementL(const TDesC8& /*aNsUri*/, + const TDesC8& aLocalName, + const TDesC8& /*aQName*/, + const RAttributeArray& aAttrs) + { + if(aLocalName.Compare(KDeviceIdLocalName)==0) + { + ResetContentL(); + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::Found deviceId tag"))); + } + else if(aLocalName.Compare(KHandlerLocalName) == 0) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::Found handler"))); + TPtrC8 pClass = SenXmlUtils::AttrValue(aAttrs, KClassAttr); + TPtrC8 pVersion = SenXmlUtils::AttrValue(aAttrs, KVersionAttr); + + //message handlers + if ((pClass == KAddressingValue) || + (pClass == KEnveloperValue) || + (pClass == KCredentialCollectorValue )|| + (pClass == KSecurityValue) || + (pClass == KPassportValue)) + { + AddHandlerL(pClass, pVersion, SenHandler::EMessageHandler); + } + //session handlers + else if((pClass == KValidateValue) || + (pClass == KServiceUpdateValue) || + (pClass == KRegisterValue) || + (pClass == KPolicyValue) ) + { + AddHandlerL(pClass, pVersion, SenHandler::ESessionHandler); + } + else + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin but can not load it"))); + } + + } + } +//--------------------------------------------------------------------------- +// used during reading configuration of WSStar framework +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::EndElementL(const TDesC8& aNsUri, + const TDesC8& aLocalName, + const TDesC8& aQName) + { + if(aLocalName.Compare(KDeviceIdLocalName)==0) + { + TPtrC8 content = Content(); + if (content.Length()>0) + { + delete iDeviceId; + iDeviceId = NULL; + iDeviceId = HBufC8::NewL(content.Length()); + TPtr8 deviceIdDes = iDeviceId->Des(); + deviceIdDes.Copy(content); + } + else + { + GenerateDeviceIdL(); + } + } + else + { + CSenBaseFragment::EndElementL(aNsUri,aLocalName,aQName); + } + } + +//--------------------------------------------------------------------------- +// getter of handler, using its cue +//--------------------------------------------------------------------------- +// + +MSenHandler* CWSStarPlugin::Handler(const TDesC8& aCue) + { + TInt count = iMsgHandlers.Count(); + for(TInt i=0;iName() == aCue) + { + return iMsgHandlers[i]; + } + } + count = iSessionHandlers.Count(); + for(TInt i=0;iName() == aCue) + { + return iSessionHandlers[i]; + } + } + return NULL; + } +//--------------------------------------------------------------------------- +// remove handler by cue, used during reloading (another version of handler is +// used than deafault setup) +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::RemoveHandler(const TDesC8& aCue) + { + TInt count = iMsgHandlers.Count(); + for(TInt i=0;iName() == aCue) + { + delete iMsgHandlers[i]; + iMsgHandlers.Remove(i); + return; + } + } + count = iSessionHandlers.Count(); + for(TInt i=0;iName() == aCue) + { + delete iSessionHandlers[i]; + iSessionHandlers.Remove(i); + return; + } + } + } + + + +//--------------------------------------------------------------------------- +// Process Outbound validation phase +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::ProcessOutboundValidationL( MSenServiceDescription& aPattern, + MSenRemoteServiceSession* aRemoteServiceSession, + HBufC8*& aErrorMessage ) + { + CSenSessionHandler* pSTShandler = (CSenSessionHandler*)Handler(KValidateValue); + CWSStarSessionContext* pSessionValidateCtx = ((CWSStarServiceSession*)aRemoteServiceSession)->SessionContext(); + if (!pSessionValidateCtx) //sessionCts exist if revalidation is processing + { + CWSStarPolicyHandler* policyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + pSessionValidateCtx = CWSStarSessionContext::NewLC(Manager().XMLReader(), &aPattern, policyHandler); + pSessionValidateCtx->Add(WSStarContextKeys::KServiceSession(), *(MSenRemoteServiceSession*)aRemoteServiceSession); + ((CWSStarServiceSession*)aRemoteServiceSession)->SetSessionContext(pSessionValidateCtx); + CleanupStack::Pop(pSessionValidateCtx); + } + else + { + pSessionValidateCtx->Update(WSStarContextKeys::KServiceSession(), *(MSenRemoteServiceSession*)aRemoteServiceSession); + } + TInt error(KErrNone); + TRAPD(errorL, error = pSTShandler->InvokeL(*pSessionValidateCtx)); + if ( error ) + { + const TDesC8* pNotOwnedErrorMsg = pSessionValidateCtx->GetDesC8L(WSStarContextKeys::KErrMessage); + if ( pNotOwnedErrorMsg ) + { + aErrorMessage = pNotOwnedErrorMsg->AllocL(); + } + } + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundValidationL() !!!!leave from validate handler"))); + error = errorL; + } +#ifdef RD_SEN_VTCP_SUPPORT + if(error) + { + return error; + } + CSenSessionHandler* pCoBrandinghandler = (CSenSessionHandler*)Handler(KCoBrandingValue); + CWSStarSessionContext* pSessionCoBrandingCtx = ((CWSStarServiceSession*)aRemoteServiceSession)->SessionContext(); + if (!pSessionCoBrandingCtx) //sessionCts exist if revalidation is processing + { + CWSStarPolicyHandler* policyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + pSessionCoBrandingCtx = CWSStarSessionContext::NewLC(Manager().XMLReader(), &aPattern, policyHandler); + pSessionCoBrandingCtx->Add(WSStarContextKeys::KServiceSession(), *(MSenRemoteServiceSession*)aRemoteServiceSession); + ((CWSStarServiceSession*)aRemoteServiceSession)->SetSessionContext(pSessionCoBrandingCtx); + CleanupStack::Pop(pSessionCoBrandingCtx); + } + else + { + pSessionCoBrandingCtx->Update(WSStarContextKeys::KServiceSession(), *(MSenRemoteServiceSession*)aRemoteServiceSession); + } + + TRAPD(cberrorL, error = pCoBrandinghandler->InvokeL(*pSessionCoBrandingCtx)); + if ( error ) + { + const TDesC8* pNotOwnedErrorMsg = pSessionCoBrandingCtx->GetDesC8L(WSStarContextKeys::KErrMessage); + if ( pNotOwnedErrorMsg ) + { + aErrorMessage = pNotOwnedErrorMsg->AllocL(); + } + } + + + + if (cberrorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundValidationL() !!!!leave from validate handler"))); + error = cberrorL; + } +#endif//RD_SEN_VTCP_SUPPORT + return error; + } + + + +//--------------------------------------------------------------------------- +// Process Outbound message phase +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::ProcessOutboundMessageL( CWSStarMessageContext*& aMsgCtx, + const TDesC8* aBody, + CSenSoapMessage*& aReadyMsg ) + { +//----------------enveloper + TInt error(KErrNone); + CSenMessageHandler* pHandler = NULL; + aMsgCtx->Update(WSStarContextKeys::KBody, *aBody); + if (aReadyMsg) + { + aMsgCtx->Update(SenContext::KSenCurrentSoapMessageCtxKey, aReadyMsg); + } + else + { + pHandler = (CSenMessageHandler*)Handler(KEnveloperValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundMessageL() !!!!leave from enveloper handler"))); + error = errorL; + } + } + aReadyMsg = aMsgCtx->GetCurrentSoapMessage(); + } + +//----------------passport + if (error) return error; + pHandler = (CSenMessageHandler*)Handler(KPassportValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundMessageL() !!!!leave from passport handler"))); + error = errorL; + } + } + if (error) return error; +//----------------addresing +//some logic which will load oall hanlders and in iteration will produce whole messge +// see axis2\axis2-M2-src\modules\core\src\org\apache\axis\engine\Phase.java +// now just addressing + pHandler = (CSenMessageHandler*)Handler(KAddressingValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundMessageL() !!!!leave from addressing handler"))); + error = errorL; + } + } + if (error) return error; +//--------------------credential collector handler +//adding credentials + pHandler = (CSenMessageHandler*)Handler(KCredentialCollectorValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundMessageL() !!!!leave from credentail collector handler"))); + error = errorL; + } + } + if (error) return error; + +//--------------------signatureContext handler +//getting pop and sign + pHandler = (CSenMessageHandler*)Handler(KSecurityValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessOutboundMessageL() !!!!leave from security handler"))); + error = errorL; + } + } + return error; + } + + + + +//--------------------------------------------------------------------------- +// Process Ibound message phase (body as element) +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::ProcessInboundMessageL(CWSStarMessageContext*& aMsgCtx, + CSenSoapMessage*& aMsg) + { + TInt error(KErrNone); + aMsgCtx->Add(SenContext::KSenCurrentSoapMessageCtxKey, aMsg); + CSenMessageHandler* pHandler(NULL); + +//----------------addresing +//some logic which will load oall hanlders and in iteration will produce whole messge +// see axis2\axis2-M2-src\modules\core\src\org\apache\axis\engine\Phase.java +// now just addressing + pHandler = (CSenMessageHandler*)Handler(KAddressingValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler ->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessInboundMessageL() !!!!leave from addressing handler"))); + error = errorL; + } + } + //----------------passport + if (error) return error; + pHandler = (CSenMessageHandler*)Handler(KPassportValue); + if (pHandler) + { + TRAPD(errorL, error = pHandler->InvokeL(*aMsgCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessInboundMessageL() !!!!leave from passport handler"))); + error = errorL; + } + } + return error; + } + + +//--------------------------------------------------------------------------- +// Process Ibound dispatch phase (in fact updatinf session) +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::ProcessInboundDispatchL(MSenRemoteServiceSession* aRemoteServiceSession, + CSenSoapMessage*& aMsg) + { + CSenSessionHandler* pServiceUpdate = + (CSenSessionHandler*)Handler(KServiceUpdateValue); + CWSStarSessionContext* pSessionCtx = ((CWSStarServiceSession*)aRemoteServiceSession)->SessionContext(); + if (pSessionCtx) + { + if (!pSessionCtx->GetSenRemoteServiceSessionL(WSStarContextKeys::KServiceSession)) + { + pSessionCtx->Add(WSStarContextKeys::KServiceSession, *(MSenRemoteServiceSession*)aRemoteServiceSession); + } + pSessionCtx->Update(SenContext::KSenCurrentSoapMessageCtxKey, aMsg); + TInt error(KErrNone); + TRAPD(errorL, error = pServiceUpdate->InvokeL(*pSessionCtx)); + if (errorL!=KErrNone) + { + TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarPlugin::ProcessInboundDispatchL() !!!!leave from Servide Update handler"))); + error = errorL; + } + return error; + } + else + { + //in STS session , sessionContext is not set, no dispatching yet in STS session + return KErrNotFound; + } + /* + handle error will know after that revalidateNeeded=ETrue and make ValidateOutboud again + this call Create session in WS*Plugin which checking credential*/ + + } + + +//--------------------------------------------------------------------------- +// Getter for Device Id. +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::DeviceId(TPtrC8& aValue) + { + if (iDeviceId) + { + aValue.Set(*iDeviceId); + return KErrNone; + } + else + { + return KErrNotFound; + } + } + +//--------------------------------------------------------------------------- +// Generate Device Id +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::GenerateDeviceIdL() + { + CSenGuidGen* pGuidGenerator = CSenGuidGen::NewLC(); + delete iDeviceId; + iDeviceId = NULL; + iDeviceId = pGuidGenerator->GetRandomGuid8LC(); + TPtr8 deviceIdDes = iDeviceId->Des(); + deviceIdDes.LowerCase(); + CleanupStack::Pop(iDeviceId); + CleanupStack::PopAndDestroy(pGuidGenerator); + } +//--------------------------------------------------------------------------- +// Add handler tag into session.xml +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::AddHandlerTag(TPtr8& aXml, const TDesC8& aHandlerClassName) + { + aXml.Append(KSenLessThan); + aXml.Append(KHandlerLocalName); + aXml.Append(KSenSpace); + //class attr + aXml.Append(KClassAttr); + aXml.Append(KSenEqualsDblQuot); + aXml.Append(aHandlerClassName); + aXml.Append(KSenDblQuot); + TInt index = iVersions.Find(aHandlerClassName); + if (index != KErrNotFound) + { + HBufC8* value = (HBufC8*)iVersions.ValueAt(index); + if (value->Length()) + { + aXml.Append(KSenSpace); + aXml.Append(KVersionAttr); + aXml.Append(KSenEqualsDblQuot); + aXml.Append(*value); + aXml.Append(KSenDblQuot); + } + } + aXml.Append(KSenSlashGreaterThan); + } + +//--------------------------------------------------------------------------- +// Add handler into array, WS* SIF implementation keep handlers after loading +//--------------------------------------------------------------------------- +// +void CWSStarPlugin::AddHandlerL(const TDesC8& aHandlerClassName, const TDesC8& aVersion, SenHandler::THandlerType aType) + { + TInt index = iVersions.Find(aHandlerClassName); + if (index == KErrNotFound) + { + MSenHandler* handler = NULL; + CWSStarHandlerContext* ctx = NULL; + ctx = CWSStarHandlerContext::NewL(); + CleanupStack::PushL(ctx); + //ctx->Add(HandlerContextKey::KLogger, Log()); + ctx->Add(iManager); + ctx->Update(HandlerContextKey::KVersion, aVersion); + iVersions.Append(aHandlerClassName.AllocL(), aVersion.AllocL()); + if(aType == SenHandler::EMessageHandler) + { + TRAPD(loadError, handler = CSenMessageHandler::NewL(aHandlerClassName, *ctx)); + if (loadError != KErrNone) + { + User::Leave(loadError); + } + else + { + iMsgHandlers.Append((CSenMessageHandler*)handler); + } + } + else if (aType == SenHandler::ESessionHandler) + { + ctx->Add(HandlerContextKey::KSIF, this); + TRAPD(loadError, handler = CSenSessionHandler::NewL(aHandlerClassName, *ctx)); + if (loadError != KErrNone) + { + User::Leave(loadError); + } + else + { + iSessionHandlers.Append((CSenSessionHandler*)handler); + } + } + CleanupStack::Pop(ctx); + iHandlerContexts.Append(ctx); + } + else + //reload handler. + //user info from session.xml (in fact this is only for testing , nobody can have access to session.xml) + { + HBufC8* value = (HBufC8*)iVersions.ValueAt(index); + if (*value != aVersion) + {//reload + iVersions.RemoveByKey(aHandlerClassName); + RemoveHandler(aHandlerClassName); + //potentail infinitve reccurence! + AddHandlerL(aHandlerClassName, aVersion, aType); + } + } + } + +//--------------------------------------------------------------------------- +// SetTransportPropertiesL +//--------------------------------------------------------------------------- +// +TInt CWSStarPlugin::SetTransportPropertiesL(MSenTransport& /* aTransport */) + { + return KErrNotSupported; + } + +MSenHandler* CWSStarPlugin::PolicyHandler() +{ + MSenHandler* pPolicyHandler = Handler(KPolicyValue()); + if(pPolicyHandler) + return pPolicyHandler; + else + return NULL; +} +TInt CWSStarPlugin::PolicyConsumerAddedL(CSenServiceSession* aNewSession, MSenRemoteServiceConsumer& aRemoteConsumer) +{ + CWSStarPolicyHandler* policyHandler = (CWSStarPolicyHandler*)Handler(WSStarConfig::KPolicyValue); + return policyHandler->PolicyConsumerAddedL(aNewSession,aRemoteConsumer); + +} +// END OF FILE +