/*

* Copyright (c) 2002-2005 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 FILES

#include <xmlengnodelist.h>

#include <badesca.h>

#include <SenXmlReader.h>

#include <s32mem.h>

#include <utf.h>

#include "SenWsSecurityHeader2.h"

#include "SenSoapMessage2.h"

#include "sendebug.h"

#include "senlogger.h"

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL()");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC();

    CleanupStack::Pop(pNew);

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC()");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL();

    return pNew;

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(TSOAPVersion aVersion)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aVersion)");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aVersion);

    CleanupStack::Pop(pNew);

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(TSOAPVersion aVersion)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aVersion)");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aVersion);

    return pNew;

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(TSOAPVersion aVersion,

                                                  const TDesC8& aSecurityNs)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aVersion,aSecurityNs)");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aVersion, aSecurityNs);

    CleanupStack::Pop(pNew);

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(TSOAPVersion aVersion,

                                                   const TDesC8& aSecurityNs)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aVersion,aSecurityNs)");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aVersion, aSecurityNs);

    return pNew;

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(MSenMessageContext& aContext)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aContext)");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aContext);

    CleanupStack::Pop(pNew);

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(MSenMessageContext& aContext)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aContext)");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aContext);

    return pNew;

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(MSenMessageContext& aContext,

                                                  TSOAPVersion aVersion)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aContext,aVersion)");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aContext, aVersion);

    CleanupStack::Pop(pNew);

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(MSenMessageContext& aContext,

                                                   TSOAPVersion aVersion)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aContext,aVersion)");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aContext, aVersion);

    return pNew;

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(MSenMessageContext& aContext,

                                                  TSOAPVersion aVersion,

                                                  const TDesC8& aSecurityNs)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aContext,aVersion,aSecurityNs)");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aContext,

                                                      aVersion,

                                                      aSecurityNs);

    CleanupStack::Pop(pNew);

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(MSenMessageContext& aContext,

                                                  TSOAPVersion aVersion,

                                                  const TDesC8& aSecurityNs)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aContext,aVersion,aSecurityNs)");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aContext, aVersion, aSecurityNs);

    return pNew;

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewL(CSenSoapMessage2& aMessage)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewL(aMessage)");

    CSenSoapMessage2* pNew = CSenSoapMessage2::NewLC(aMessage);

    CleanupStack::Pop(pNew); // pNew

    return pNew;    

    }

EXPORT_C CSenSoapMessage2* CSenSoapMessage2::NewLC(CSenSoapMessage2& aMessage)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewLC(aMessage)");

    CSenSoapMessage2* pNew = new (ELeave) CSenSoapMessage2();

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aMessage);

    return pNew;

    }

EXPORT_C CSenSoapMessage2::~CSenSoapMessage2()

    {

    if (ipSecurityHeader)

        {

        // We do not own the element, so remove it from the fragment.

        ipSecurityHeader->ExtractElement();

        delete ipSecurityHeader;

        }

    }

EXPORT_C CSenSoapMessage2::CSenSoapMessage2()

: ipSecurityHeader(NULL)

    {

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL()

    {

    CSenSoapEnvelope2::BaseConstructL();

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL(TSOAPVersion aVersion)

    {

    CSenSoapEnvelope2::BaseConstructL(aVersion);

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL(TSOAPVersion aVersion, const TDesC8& aSecurityNs)

    {

    BaseConstructL(aVersion);

    if ( ( aSecurityNs == KSecuritySchemeXmlNs ) || ( aSecurityNs == KSecurityXmlNs ) )

        {

        TXmlEngElement element = AsElementL();

        RSenDocument document = AsDocumentL();

        ipSecurityHeader = CSenWsSecurityHeader2::NewL(KNullDesC8,

                                                       aSecurityNs,

                                                       document,

                                                       element);

        this->AddHeaderL(ipSecurityHeader->AsElementL());

        }

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL(MSenMessageContext& aContext)

    {

    CSenSoapEnvelope2::BaseConstructL(aContext);

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL(MSenMessageContext& aContext,

                                               TSOAPVersion aVersion)

    {

    CSenSoapEnvelope2::BaseConstructL(aContext, aVersion);

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL(MSenMessageContext& aContext,

                                               TSOAPVersion aVersion,

                                               const TDesC8& aSecurityNs)

    {

    BaseConstructL(aContext, aVersion);

    if ( ( aSecurityNs == KSecuritySchemeXmlNs ) || ( aSecurityNs == KSecurityXmlNs ) )

        {

        TXmlEngElement element = AsElementL();

        RSenDocument document = AsDocumentL();

        ipSecurityHeader = CSenWsSecurityHeader2::NewL(KNullDesC8,

                                                       aSecurityNs,

                                                       document,

                                                       element);

        this->AddHeaderL(ipSecurityHeader->AsElementL());

        }

    }

EXPORT_C void CSenSoapMessage2::BaseConstructL(CSenSoapMessage2& aMessage)

    {

    CSenSoapEnvelope2::BaseConstructL(aMessage);

    }

EXPORT_C void CSenSoapMessage2::SetSecurityHeaderL(const TDesC8& aData)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::SetSecurityHeaderL(aData)");

    CSenWsSecurityHeader2* pTemp = NULL;

    TXmlEngElement element = AsElementL();

    RSenDocument document = AsDocumentL();

    if ( aData == KNullDesC8 )

        {

        // we don't have credential

        pTemp = NewSecurityHeaderLC(NULL, document, element);

        }

    else

        {

        // there is a credential to add..

        pTemp = NewSecurityHeaderLC(&aData, document, element);

        }

    TXmlEngElement header = HeaderL();

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    header.GetElementsByTagNameL(list, KSecurityName,

                                       pTemp->XmlNs());

    while ( list.HasNext() )

        {

        TXmlEngElement element = list.Next();

        element.Remove();

        }

    if ( ipSecurityHeader )

        {

        delete ipSecurityHeader;

        ipSecurityHeader = NULL;

        }

    CleanupStack::PopAndDestroy(&list);

    ipSecurityHeader = pTemp;

    CleanupStack::Pop(); // pTemp

    this->AddHeaderL(ipSecurityHeader->AsElementL());

    }

EXPORT_C void CSenSoapMessage2::ParseHeaderL( const RTagInfo& aElement,

                                              const RAttributeArray& aAttributes)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::ParseHeaderL");

    const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

    const TPtrC8 saxNsUri       = aElement.Uri().DesC();

    const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

    TXmlEngElement element = AsElementL();

    RSenDocument document = AsDocumentL();

    CSenWsSecurityHeader2* pTemp = NewSecurityHeaderLC(NULL, document, element);

    if ((pTemp->XmlNs() == saxNsUri) && (KSecurityName() == saxLocalName))

        {

        // Remove existing <Security> header

        TXmlEngElement header = HeaderL();

        RXmlEngNodeList<TXmlEngElement> list;

        CleanupClosePushL(list);

        header.GetElementsByTagNameL(list, KSecurityName, pTemp->XmlNs());

        while ( list.HasNext() )

            {

            TXmlEngElement element = list.Next();

            element.Remove();

            }

        CleanupStack::PopAndDestroy(&list);

        if ( ipSecurityHeader )

            {

            delete ipSecurityHeader;

            ipSecurityHeader = NULL;

            }

        ipSecurityHeader = pTemp;

        CleanupStack::Pop(); // pTemp

        TXmlEngElement wsSecurityHeader = ipSecurityHeader->AsElementL();

        wsSecurityHeader.MoveTo(header);

        OnDelegateParsingL(*ipSecurityHeader);        

        }

    else

        {

        TXmlEngElement rootElement = pTemp->AsElementL();

        rootElement.Remove();

        CleanupStack::PopAndDestroy(); // pTemp

        CSenSoapEnvelope2::ParseHeaderL(aElement, aAttributes);

        }

    }

EXPORT_C TInt CSenSoapMessage2::AddSecurityTokenL(const TDesC8& aNewToken)

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::AddSecurityTokenL(aNewToken)");

    TXmlEngElement element = AsElementL();

    RSenDocument document = AsDocumentL();

    TXmlEngElement soapHeader = HeaderL();

    TXmlEngElement wsSecurityHeader;

    // Create <wsse:Security> element into wrong place

    // <=> into a root element = Envelope.

    // <S:Envelope>

    //   ...

    //   <wsse:Security>

    // That's because we don't want following search to find

    // this new header inside <S:Header> element.

    CSenWsSecurityHeader2* pHeader = NewSecurityHeaderLC(NULL, document, element);

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    soapHeader.GetElementsByTagNameL(list, KSecurityName,

                                           pHeader->XmlNs());

    if ( !list.HasNext() )

        {

        // <wsse:Security> element was not found from <S:Header> element.

        // => Add new header by moving header from (root) <S:Envelope>

        //    element into <S:Header> element.

        wsSecurityHeader = pHeader->ExtractElement();

        wsSecurityHeader.MoveTo(soapHeader);

        }

    else

        {

        // <wsse:Security> element was found from <S:Header> element.

        // => Delete new header element from SoapMessage DOM tree by

        //    removing header from (root) <S:Envelope> element.

        wsSecurityHeader = pHeader->ExtractElement();

        wsSecurityHeader.Remove();

        // Select found <wsse:Security> element to be edited

        wsSecurityHeader = list.Next();

        }

    CleanupStack::PopAndDestroy(&list);

    CleanupStack::PopAndDestroy(); // pHeader // safe to delete

    TPtrC8 content = wsSecurityHeader.Text();

    HBufC8* pContent = HBufC8::NewLC( content.Length() + aNewToken.Length() );

    TPtr8 ptrContent = pContent->Des();

    ptrContent.Append(content);

    ptrContent.Append(aNewToken);

    wsSecurityHeader.SetTextNoEncL(*pContent);

    CleanupStack::PopAndDestroy(pContent);    

    return KErrNone;

    }

EXPORT_C CSenWsSecurityHeader2* CSenSoapMessage2::NewSecurityHeaderLC( const TDesC8* aData,

                                                                       RSenDocument aDocument,

                                                                       TXmlEngElement element )

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::NewSecurityHeaderLC");

    CSenWsSecurityHeader2* pNew = NULL;

    if ( aData )

        {

        if ( ipSecurityHeader )

            {

            pNew = CSenWsSecurityHeader2::NewL(*aData, ipSecurityHeader->XmlNs(), aDocument, element);

            }

        else

            {

            pNew = CSenWsSecurityHeader2::NewL(*aData, aDocument, element);

            }

        }

    else

        {

        if ( ipSecurityHeader )

            {

            pNew = CSenWsSecurityHeader2::NewL(KNullDesC8, ipSecurityHeader->XmlNs(), aDocument, element);

            }

        else

            {

            pNew = CSenWsSecurityHeader2::NewL(aDocument, element);

            }

        }

    CleanupStack::PushL(pNew);

    return pNew;

    }

EXPORT_C MSenMessage::TClass CSenSoapMessage2::Type()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::Type");

    return MSenMessage::ESoapMessage2;

    }

EXPORT_C MSenMessage* CSenSoapMessage2::CloneL()

    {

    TLSLOG_L(KSenMessagesLogChannel, KMinLogLevel, "CSenSoapMessage2::CloneL");

    CSenSoapMessage2* pMessage = CSenSoapMessage2::NewL(*this);

    return pMessage;

    }

// End of File