diff -r 000000000000 -r 62f9d29f7211 webservices/wsstar/wsstarmessagehandlers/src/wsstaraddressinghandler.cpp
--- /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
+