--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsstar/wsstarmessagehandlers/src/wsstaraddressinghandler.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,802 @@
+/*
+* 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 "wsstaraddressinghandler.h"
+#include "wsstarmessageutils.h"
+#include "SenXmlUtils.h"
+#include "sensaxutils.h"
+#include "senlogger.h" // private Utils\inc
+
+using namespace WSStarAddressing;
+using namespace WSStarAddressingFault;
+
+// Create instance of concrete ECOM interface implementation
+CWSStarAddressingHandler* CWSStarAddressingHandler::NewL(TAny* aHandlerCtx)
+ {
+ MSenHandlerContext* ctx =
+ reinterpret_cast<MSenHandlerContext*>( aHandlerCtx);
+ CWSStarAddressingHandler* self = new (ELeave) CWSStarAddressingHandler(*ctx);
+ CleanupStack::PushL (self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+TInt CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx)")));
+ CSenSoapEnvelope* message =
+ const_cast<CSenSoapEnvelope*>(aCtx.GetSenSoapEnvelopeL(
+ SenContext::KSenCurrentSoapMessageCtxKey)
+ );
+ TPtrC8 txtMessage = aCtx.GetMessageL();
+ InitVersionL(aCtx.GetDesC8L(WSStarContextKeys::KAddressingVersion));
+ if (message)
+ {
+ const CSenNamespace* nmSpace = message->Namespace(KAddressingPrefix);
+ if (nmSpace)
+ {
+ InitVersionL(&nmSpace->URI());
+ }
+ if (aCtx.Direction() == SenContext::EOutgoing)
+ {
+ return HandleOutboundL(aCtx, message);
+ }
+ else if (aCtx.Direction()==SenContext::EIncoming)
+ {
+ return HandleInboundL(aCtx, message);
+ }
+ else
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \
+ strange direction")));
+ return KErrNotFound;
+ }
+ }
+ else if (txtMessage.Length())
+ {
+//---------------idea based on method
+/*
+TInt CSenWebServiceSession::HandleBodyWithoutParsingL(CSenSoapMessage& aMessage,
+ const TDesC8& aResponse)
+*/
+ TInt ret(KErrNone);
+ TInt endTagStart;
+ TInt endTagEnd;
+ TInt startTagStart;
+ TInt startTagEnd;
+ TPtrC8 prefix;
+
+ ret = SenSaxUtils::SearchEndTagL(txtMessage,KSenSoapEnvelopeBodyName,
+ endTagStart, endTagEnd, prefix);
+ if ( ret != KErrNotFound )
+ {
+ ret = SenSaxUtils::SearchStartTagL(txtMessage,prefix,KSenSoapEnvelopeBodyName,
+ startTagStart, startTagEnd);
+ if ( ret != KErrNotFound )
+ {
+ TPtrC8 startPart(txtMessage.Ptr(),startTagEnd+1);
+ TPtrC8 endPart(txtMessage.Ptr()+endTagStart,txtMessage.Size()-endTagStart);
+ HBufC8* pXmlWithoutBody = HBufC8::NewLC(startPart.Length()+endPart.Length());
+ pXmlWithoutBody->Des().Append(startPart);
+ pXmlWithoutBody->Des().Append(endPart);
+
+ CWSStarAddressingHeaderInbound* inbound =
+ CWSStarAddressingHeaderInbound::NewLC(iVersion);
+ inbound->SetMessageContext(aCtx);
+ CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());
+ inbound->SetReader(reader);
+ inbound->BuildFrom(*pXmlWithoutBody);
+ CleanupStack::PopAndDestroy(inbound);
+
+
+ CleanupStack::PopAndDestroy(pXmlWithoutBody);
+
+ }
+ }
+ else//case with empty body - <S:Body/>, so we can parse all
+ {
+ CWSStarAddressingHeaderInbound* inbound =
+ CWSStarAddressingHeaderInbound::NewLC(iVersion);
+ inbound->SetMessageContext(aCtx);
+ CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());
+ inbound->SetReader(reader);
+ inbound->BuildFrom(txtMessage);
+ CleanupStack::PopAndDestroy(inbound);
+ }
+
+ return ret;
+ }
+ else
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \
+ Soap message in message context not exists")));
+ return KErrNotFound;
+ }
+ }
+TInt CWSStarAddressingHandler::HandleInboundL(MSenMessageContext& aCtx, CSenSoapEnvelope* aMessage)
+ {
+/*
+ CWSStarAddressingHeaderInbound* inbound = CWSStarAddressingHeaderInbound::NewLC(iVersion);
+ inbound->SetMessageContext(aCtx);
+ CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());
+ inbound->SetReader(reader);
+ HBufC8* buf = aMessage->AsXmlL();
+ CleanupStack::PushL(buf);
+ inbound->BuildFrom(*buf);
+*/
+ CSenElement& header = aMessage->HeaderL();
+
+ CSenElement* elem = NULL;
+ CSenElement* addressElem = NULL;
+
+ elem = CWSStarMessageUtils::FindElementL(KToName, header);
+ if (elem)
+ {
+ const TDesC8& nsUri = elem->NamespaceURI();
+ if (!iVersion && (nsUri == KAddressingXmlns200408 ||
+ nsUri == KAddressingXmlns200403 ||
+ nsUri == KAddressingXmlns200412 ||
+ nsUri == KAddressingXmlns200502 ||
+ nsUri == KAddressingXmlns200503 ||
+ nsUri == KAddressingXmlns200508))
+ {
+ iVersion = nsUri.AllocL();
+ }
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KTo, elem->Content());
+ }
+ elem = CWSStarMessageUtils::FindElementL(KRelatesToName, header);
+ if (elem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KRelatesTo, elem->Content());
+ }
+ elem = CWSStarMessageUtils::FindElementL(KMessageIDName, header);
+ if (elem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KMessageID, elem->Content());
+ }
+ elem = CWSStarMessageUtils::FindElementL(KActionName, header);
+ if (elem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KAction, elem->Content());
+ }
+ elem = CWSStarMessageUtils::FindElementL(WSStarAddressingEPR::KDeviceAddressName, header);
+ if (elem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyToDeviceAddress, elem->Content());
+ }
+
+ elem = CWSStarMessageUtils::FindElementL(KReplyToName, header);
+ if (elem)
+ {
+ addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem);
+ if (addressElem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyTo, addressElem->Content());
+ }
+ }
+ elem = CWSStarMessageUtils::FindElementL(KFaultToName, header);
+ if (elem)
+ {
+ addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem);
+ if (addressElem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KFaultTo, addressElem->Content());
+ }
+ }
+ elem = CWSStarMessageUtils::FindElementL(KFromName, header);
+ if (elem)
+ {
+ addressElem = CWSStarMessageUtils::FindElementL(KAddressName, *elem);
+ if (addressElem)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KFrom, addressElem->Content());
+ }
+ }
+ _LIT8(Kpp, "pp");
+ _LIT8(KCredProperties, "credProperties");
+ _LIT8(KCredProperty, "credProperty");
+ _LIT8(KName, "Name");
+ CWSStarMessageUtils::RArraySenElements credPropertiesElements;
+ CSenElement* ppElem = CWSStarMessageUtils::FindElementL(Kpp, header);
+ if(ppElem)
+ {
+ CSenElement* credPropertiesElem = CWSStarMessageUtils::FindElementL(KCredProperties, *ppElem);//Naga
+ if(credPropertiesElem)
+ {
+ CWSStarMessageUtils::FindElementL(KCredProperty, *credPropertiesElem, credPropertiesElements);
+ TInt count = credPropertiesElements.Count();
+ for(TInt i=0; i<count; i++)
+ {
+ elem = credPropertiesElements[i];
+ const TDesC8* ptr = elem->AttrValue(WSStarContextKeys::KName);
+ if ( *ptr == WSStarContextKeys::KMainBrandID )
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KMainBrandID, elem->Content());
+ }
+ if (*ptr == WSStarContextKeys::KBrandIDList)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KBrandIDList, elem->Content());
+ }
+ }
+ }
+ }
+
+/*
+ if (!iVersion && inbound->Version())
+ {
+ iVersion = inbound->Version()->AllocL();
+ }
+*/
+ if (!aCtx.GetDesC8L(WSStarContextKeys::KRelatesTo))
+ {
+ TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel,
+ WSStarAddressingFault::KInvalidHeaderFormatString8,
+ &KRelatesToQName(),&WSStarAddressingFault::KMissingTag()));
+
+ }
+ if (!aCtx.GetDesC8L(WSStarContextKeys::KTo))
+ {
+ TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8,
+ &KToQName()));
+
+ }
+ if (!aCtx.GetDesC8L(WSStarContextKeys::KAction))
+ {
+ TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8,
+ &KActionQName()));
+
+ }
+ if (aCtx.GetDesC8L(WSStarContextKeys::KReplyTo) || aCtx.GetDesC8L(WSStarContextKeys::KFaultTo))
+ {
+ if (!aCtx.GetDesC8L(WSStarContextKeys::KMessageID))
+ {
+ TLSLOG_FORMAT((KSenFaultsLogChannel, KSenFaultsLogLevel, KRequiredHeaderFormatString8,
+ &KMessageIDQName()));
+
+ }
+ }
+
+ // CleanupStack::PopAndDestroy(buf);
+// CleanupStack::PopAndDestroy(inbound);
+ CSenElement& body = aMessage->BodyL();
+ ShareMyLiterals(aCtx);
+ if (aMessage->IsFault())
+ {
+ TPtrC8 errorCode(KNullDesC8);
+ CSenSoapFault* faultElement = aMessage->FaultL();
+ if (faultElement)
+ {
+ TPtrC8 code;
+ if (aMessage->NsUri() == KSenSoapEnvelopeXmlns)
+ {
+ TPtrC8 code = faultElement->FaultCode();
+ const CSenNamespace* nmSpace = faultElement->Namespace(SenXmlUtils::NsPrefix(code),
+ ETrue);
+ code.Set(SenXmlUtils::LocalName(code));
+ if (nmSpace)
+ {
+ if (!iVersion)
+ {
+ InitVersionL(&nmSpace->URI());
+ }
+ if (iVersion &&
+ nmSpace->URI() == *iVersion)
+ {
+ errorCode.Set(code);
+ }
+ }
+ }
+ else if (aMessage->NsUri() == KSenSoap12EnvelopeXmlns)
+ {
+ code.Set(faultElement->FaultCode());
+ const CSenNamespace* nmSpaceCode =
+ faultElement->Namespace(SenXmlUtils::NsPrefix(code), ETrue);
+ code.Set(SenXmlUtils::LocalName(code));
+ if ((nmSpaceCode &&
+ nmSpaceCode->URI() == KSenSoap12EnvelopeXmlns) &&
+ (code == KSender || code == KReceiver))
+ {
+ TPtrC8 subcode = faultElement->FaultSubcode();
+ const CSenNamespace* nmSpace =
+ faultElement->Namespace(SenXmlUtils::NsPrefix(subcode), ETrue);
+ subcode.Set(SenXmlUtils::LocalName(subcode));
+ if (nmSpace)
+ {
+ if (!iVersion)
+ {
+ InitVersionL(&nmSpace->URI());
+ }
+ if (iVersion &&
+ nmSpace->URI() == *iVersion)
+ {
+ errorCode.Set(subcode);
+ }
+ }
+ }
+ }
+ if (errorCode.Length()>0)
+ {
+ if (errorCode == WSStarAddressingFault::KInvalidHeader ||
+ errorCode == WSStarAddressingFault::KRequiredHeader ||
+ errorCode == WSStarAddressingFault::KDestinationUnreachable ||
+ errorCode == WSStarAddressingFault::KActionNotSupported )
+ {
+ ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer,
+ WSStarSession::EAddressing);
+ }
+ if ((errorCode == WSStarAddressingFault::KEndpointUnavailable)
+ && (code == KReceiver))
+ {
+ ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer,
+ WSStarSession::EAddressing);
+ CSenElement* detailElement = faultElement->Element(KFault12DetailLocalname);
+ if (detailElement)
+ {
+ CSenElement* retryElement = detailElement->Element(*iVersion,
+ KRetryAfterName);
+ if (retryElement)
+ {
+ TPtrC8 retryAfter = retryElement->Content();
+ TLex8 num;
+ TInt retryInt;
+ num.Assign(retryAfter);
+ TInt ret = num.Val(retryInt);
+ if (ret == KErrNone)
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KRetryAfter,
+ retryInt);
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \
+ Fault element not exists")));
+ return KErrNotFound;
+ }
+ }
+ return KErrNone;
+ }
+TInt CWSStarAddressingHandler::HandleOutboundL(MSenMessageContext& aCtx,
+ CSenSoapEnvelope* aMessage)
+ {
+ if (!iVersion)
+ {
+ iVersion = KAddressingXmlns200508().AllocL();
+ }
+ TPtrC8 anonymous(KNullDesC8);
+ if (!iVersion->Compare(KAddressingXmlns200403()))
+ {
+ anonymous.Set(KReplyToAnonymous200403());
+ }
+ else if(!iVersion->Compare(KAddressingXmlns200408()))
+ {
+ anonymous.Set(KReplyToAnonymous200408());
+ }
+ else if(!iVersion->Compare(KAddressingXmlns200412()))
+ {
+ anonymous.Set(KReplyToAnonymous200412());
+ }
+ else if(!iVersion->Compare(KAddressingXmlns200502()))
+ {
+ anonymous.Set(KReplyToAnonymous200502());
+ }
+ else if(!iVersion->Compare(KAddressingXmlns200503()))
+ {
+ anonymous.Set(KReplyToAnonymous200503());
+ }
+ else if(!iVersion->Compare(KAddressingXmlns200508()))
+ {
+ anonymous.Set(KReplyToAnonymous200508());
+ }
+ CSenElement& element = aMessage->AsElement();
+ element.AddNamespaceL(KAddressingPrefix, *iVersion);
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingNsHolder, *iVersion);
+///////////////
+ const TDesC8* value = NULL;
+ const TInt* isPassportEnabled = aCtx.GetIntL(WSStarContextKeys::KPassportEnabled);
+ value = aCtx.GetDesC8L(WSStarContextKeys::KMessageID);
+ if (!value)
+ {
+ SetMessageIDL(aCtx);
+ }
+
+ if (!isPassportEnabled || (isPassportEnabled && *isPassportEnabled == FALSE))
+ {
+ CSenElement& header = aMessage->HeaderL();
+ value = aCtx.GetDesC8L(WSStarContextKeys::KMessageID);
+ if (value)
+ {
+ CreateElementAddressingL(header, KMessageIDName, *value, EFalse);
+ }
+ else
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \
+ MessageId in message context not exists")));
+ return KErrNotFound;
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KTo);
+ if (value)
+ {
+ CreateElementAddressingL(header, KToName, *value, EFalse);
+ }
+ else
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \
+ Endpoint in message context not exists")));
+ return KErrNotFound;
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KAction);
+ if (value)
+ {
+ CreateElementAddressingL(header, KActionName, *value, EFalse);
+ }
+ else
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InvokeL(MSenMessageContext& aCtx) - \
+ Action in message context not exists")));
+ return KErrNotFound;
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KRelatesTo);
+ if (value)
+ {
+ CreateElementAddressingL(header, KRelatesToName, *value, EFalse);
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KFrom);
+ if (value)
+ {
+ CreateElementAddressingL(header, KFromName, *value, ETrue);
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KReplyTo);
+ if (value)
+ {
+ CSenElement* element = CreateElementAddressingL(header, KReplyToName, *value, ETrue);
+ const TDesC8* mwsNs = NULL;
+ mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace);
+ if (mwsNs)
+ {
+ const TDesC8* deviceId = NULL;
+ deviceId = aCtx.GetDesC8L(WSStarContextKeys::KReplyToDeviceAddress);
+ if (deviceId && element)
+ {
+ ((CWSStarAddressingEPR*)element)->AddDeviceAddressL(*mwsNs,*deviceId);
+ }
+ }
+ }
+ else
+ {
+ CSenElement* element = CreateElementAddressingL(header, KReplyToName,
+ anonymous, ETrue);
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KReplyTo, anonymous);
+ const TDesC8* mwsNs = NULL;
+ mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace);
+ if (mwsNs)
+ {
+ const TDesC8* deviceId = NULL;
+ deviceId = aCtx.GetDesC8L(WSStarContextKeys::KReplyToDeviceAddress);
+ if (deviceId && element)
+ {
+ ((CWSStarAddressingEPR*)element)->AddDeviceAddressL(*mwsNs,*deviceId);
+ }
+ }
+ }
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KFaultTo);
+ if (value)
+ {
+ CreateElementAddressingL(header, KFaultToName, *value, ETrue);
+ }
+ if(aCtx.GetIntL(WSStarContextKeys::KAppInfoPresent))
+ {
+ AddAppInfoHeaderL(aCtx,header);
+ }
+ }
+
+ CSenElement& body = aMessage->BodyL();
+ CSenElement* addressHolderEl = NULL;
+ do
+ {
+ addressHolderEl =
+ CWSStarMessageUtils::GetMarkedElementL(body, WSStarContextKeys::KAddressAttrMark);
+ if (addressHolderEl)
+ {
+ value = addressHolderEl->AttrValue(WSStarContextKeys::KAddressAttrMark);
+ CreateElementAddressingL(*addressHolderEl, KEndpointReferenceName,
+ *value, ETrue);
+ //removing marker
+ CSenBaseAttribute* marker =
+ SenXmlUtils::RemoveAttributeL(*addressHolderEl, WSStarContextKeys::KAddressAttrMark);
+ delete marker;
+ marker = NULL;
+ }
+
+ }while(addressHolderEl);
+ HBufC8* bodyString = body.AsXmlL();
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KBody, *bodyString);
+ ((MSenContext&)aCtx).Remove(WSStarContextKeys::KBodyElement);
+ delete bodyString;
+ bodyString = NULL;
+ return KErrNone;
+ }
+void CWSStarAddressingHandler::AddAppInfoHeaderL(MSenMessageContext& aCtx,
+ CSenElement& aHeader)
+{
+ const TDesC8* value = NULL;
+
+ const TDesC8* mwsNs = NULL;
+ mwsNs = aCtx.GetDesC8L(WSStarContextKeys::KMwsNamespace);
+ if (mwsNs)
+ {
+ //CreateElementAddressingL(header, WSStarContextKeys::KApplication, *value,EFalse);
+ CSenElement& aaplication = aHeader.AddElementL(*mwsNs,
+ WSStarContextKeys::KApplication,
+ WSStarContextKeys::KNsPApplication);
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KApplicationName);
+ if(value)
+ {
+ CSenElement& name = aaplication.AddElementL(*mwsNs,
+ WSStarContextKeys::KName,
+ WSStarContextKeys::KNsPName);
+ name.SetContentL(*value);
+ }
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KApplicationVendor);
+ if(value)
+ {
+ CSenElement& vendor = aaplication.AddElementL(*mwsNs,
+ WSStarContextKeys::KVendor,
+ WSStarContextKeys::KNsPVendor);
+ vendor.SetContentL(*value);
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KApplicationVersion);
+ if(value)
+ {
+ CSenElement& version = aaplication.AddElementL(*mwsNs,
+ WSStarContextKeys::KVersion,
+ WSStarContextKeys::KNsPVersion);
+ version.SetContentL(*value);
+ }
+
+ CSenElement& deviceoption = aHeader.AddElementL(*mwsNs,
+ WSStarContextKeys::KDeviceOptions,
+ WSStarContextKeys::KNsPDeviceOptions);
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KLocale);
+ if(value)
+ {
+ CSenElement& local = deviceoption.AddElementL(*mwsNs,
+ WSStarContextKeys::KLocale,
+ WSStarContextKeys::KNsPLocale);
+ local.SetContentL(*value);
+ }
+
+ CSenElement& useragent = deviceoption.AddElementL(*mwsNs,
+ WSStarContextKeys::KUserAgent,
+ WSStarContextKeys::KNsPUserAgent);
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KManufacturer);
+ if(value)
+ {
+ CSenElement& manufacturer = useragent.AddElementL(*mwsNs,
+ WSStarContextKeys::KManufacturer,
+ WSStarContextKeys::KNsPManufacturer);
+ manufacturer.SetContentL(*value);
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KModel);
+ if(value)
+ {
+ CSenElement& model = useragent.AddElementL(*mwsNs,
+ WSStarContextKeys::KModel,
+ WSStarContextKeys::KNsPModel);
+ model.SetContentL(*value);
+ }
+
+ CSenElement& os = useragent.AddElementL(*mwsNs,
+ WSStarContextKeys::KOS,
+ WSStarContextKeys::KNsPOS);
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KDeviceName);
+ if(value)
+ {
+ CSenElement& name = os.AddElementL(*mwsNs,
+ WSStarContextKeys::KName,
+ WSStarContextKeys::KNsPName);
+ name.SetContentL(*value);
+ }
+ value = aCtx.GetDesC8L(WSStarContextKeys::KDeviceVersion);
+ if(value)
+ {
+ CSenElement& version = os.AddElementL(*mwsNs,
+ WSStarContextKeys::KVersion,
+ WSStarContextKeys::KNsPVersion);
+ version.SetContentL(*value);
+ }
+
+
+ value = aCtx.GetDesC8L(WSStarContextKeys::KIMSI);
+ if(value)
+ {
+ CSenElement& imsi = useragent.AddElementL(*mwsNs,
+ WSStarContextKeys::KIMSI,
+ WSStarContextKeys::KNsPIMSI);
+ imsi.SetContentL(*value);
+ }
+ }
+ return;
+ }
+
+SenHandler::THandlerDirection CWSStarAddressingHandler::Direction() const
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::Direction()")));
+ return SenHandler::EBoth;
+ }
+SenHandler::THandlerPhase CWSStarAddressingHandler::Phase()
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::Phase()")));
+ return SenHandler::EMessage;
+ }
+
+// Constructor
+CWSStarAddressingHandler::CWSStarAddressingHandler(MSenHandlerContext& aCtx)
+:CSenMessageHandler(aCtx)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::\
+ CWSStarAddressingHandler(MSenHandlerContext& aCtx)")));
+ }
+
+// Destructor
+CWSStarAddressingHandler::~CWSStarAddressingHandler()
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::~CWSStarAddressingHandler()")));
+ delete iVersion;
+ }
+
+// Second phase construction.
+void CWSStarAddressingHandler::ConstructL()
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::ConstructL()")));
+
+ InitVersionL(NULL);
+ }
+void CWSStarAddressingHandler::InitVersionL(const TDesC8* aVersion)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InitVersion()")));
+ const TDesC8* version = iHandlerContext.GetDesC8L(HandlerContextKey::KVersion);
+ if (aVersion &&
+ (*aVersion == KAddressingXmlns200408 ||
+ *aVersion == KAddressingXmlns200403 ||
+ *aVersion == KAddressingXmlns200412 ||
+ *aVersion == KAddressingXmlns200502 ||
+ *aVersion == KAddressingXmlns200503 ||
+ *aVersion == KAddressingXmlns200508))
+ {
+ delete iVersion;
+ iVersion = NULL;
+ iVersion = aVersion->AllocL();
+ }
+ else if(version &&
+ (*version == KAddressingXmlns200408 ||
+ *version == KAddressingXmlns200403 ||
+ *version == KAddressingXmlns200412 ||
+ *version == KAddressingXmlns200502 ||
+ *version == KAddressingXmlns200503 ||
+ *version == KAddressingXmlns200508))
+ {
+ delete iVersion;
+ iVersion = NULL;
+ iVersion = version->AllocL();
+ }
+ else
+ {//no version from handler config
+ //no version from user
+ //so it means some default behavior (new addressing),
+ //only allocate if differen (to safe time)
+ if ((!iVersion) || (*iVersion != KAddressingXmlns200508()))
+ {
+ delete iVersion;
+ iVersion = NULL;
+ //iVersion = KAddressingXmlns200508().AllocL();
+ }
+ //else - just leave ai it is
+ }
+ }
+CSenElement* CWSStarAddressingHandler::CreateElementAddressingL(CSenElement& aParentElement, const TDesC8& aLocalName,
+ const TDesC8& aContent, TBool aUseAddress)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::CreateElementAddressing(CSenElement& aParentElement,\
+ const TDesC8& aLocalName, const TDesC8& aContent, TBool aUseAddress)")));
+
+ CSenElement* newelement = NULL;
+ if (!aUseAddress)
+ {
+ newelement = aParentElement.CreateElementL(KAddressingPrefix(),
+ aLocalName);
+ CleanupStack::PushL(newelement);
+ newelement->SetContentL(aContent);
+ }
+ else
+ {
+ newelement = CWSStarAddressingEPR::NewL(aParentElement, aLocalName, aContent, *iVersion);
+ CleanupStack::PushL(newelement);
+ }
+ if (newelement)
+ {
+ aParentElement.AddElementL(*newelement);
+ CleanupStack::Pop(newelement);
+ }
+/*
+ if (aUseAddress)
+ {
+ CSenElement& element = *newelement;
+ CreateElementAddressingL(element,KAddressName,aContent,EFalse);
+ }
+ else
+ {
+ newelement->SetContentL(aContent);
+ }*/
+ return newelement;
+ }
+
+void CWSStarAddressingHandler::SetMessageIDL(MSenMessageContext& aCtx)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::SetMessageID(MSenMessageContext& aCtx)")));
+ CSenGuidGen* pGuidGenerator = CSenGuidGen::NewLC();
+ HBufC8* messageId = pGuidGenerator->GetRandomGuid8LC();
+ TPtr8 messageIdDes = messageId->Des();
+ messageIdDes.LowerCase();
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KMessageID,*messageId);
+ CleanupStack::PopAndDestroy(messageId);
+ CleanupStack::PopAndDestroy(pGuidGenerator);
+ }
+void CWSStarAddressingHandler::ShareMyLiterals(MSenMessageContext& aCtx)
+ {
+ if (iVersion)
+ {
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingNsHolder,
+ *iVersion);
+ ((MSenContext&)aCtx).Update(WSStarContextKeys::KAddressingEndpointTagHolder, KAddressName);
+ }
+ }
+TInt CWSStarAddressingHandler::InitL(MSenHandlerContext& aCtx)
+ {
+ TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("CWSStarAddressingHandler::InitL(MSenHandlerContext& aCtx)")));
+ iHandlerContext = aCtx;
+ return KErrNone;
+ }
+
+RFileLogger* CWSStarAddressingHandler::Log() const
+ {
+ RFileLogger* pLog = NULL;
+ TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); )
+ return pLog;
+ }
+
+// END OF FILE
+