/*

* Copyright (c) 2002-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:        Class implements XML base fragment using libxml2 classes

*

*/

// INCLUDE FILES

#include <flogger.h>

#include <utf.h>

#include <s32mem.h>

#include "SenFragmentBase.h"

#include "SenParser.h"

#include "wslibxml2utils.h"

#include <SenXmlConstants.h>

#include <xml/attribute.h>               // needed for RAttributeArray

#include <xml/parserfeature.h>           // for TParserFeature enumeration

typedef unsigned char xmlChar; // from "libxml/Libxml2_xmlstring.h"

using namespace Xml;

// ***************************************************************************

// Fragment class state constants are as following (declared in subclasses):

// KSenStateNotSet                  = -1;

// KSenStateIgnore                  =  0; // even ones ignore(0),

// KSenStateSave                    =  1; // and odd ones save(1)

// KSenStateResume                  =  2;

// KStateParsingFramework           =  4;

// KStateParsingSoapFault           =  5;  // odd, save

// KStateParsingServiceDescription  =  6;

// KStateParsingResourceOffering    =  11; // odd, save

// KStateParsingCredentials         =  12;

// KStateParsingService             =  13; // odd state, saves content

// KStateParsingPwTransforms        =  14;

// KStateParsingSoapHeader          =  20; // ignore state (even num)

// KStateParsingSoapBody            =  40; // ignore state (even num)

// KStateParsingSingleCredential    =  122;

// KStateParsingProviderPolicy      =  1222;

namespace

    {

    const TInt KFlatBufSize = 128;

    _LIT(KSenFragmentPanic, "SenFragment");

    TBool EncodeXmlEscapesL( const TDesC8& aOriginal, HBufC8*& aEncoded )

        {

        TBool retVal = EFalse;

        delete aEncoded;

        aEncoded = NULL;

        if (aOriginal == KNullDesC8)

            {

            return retVal;

            }

        TPtrC8 tokens[] =

            {

            KSenEscapedAmp(),

            KSenEscapedApos(),

            KSenEscapedDblQuot(),

            KSenEscapedGt(),

            KSenEscapedLt()  

            };

        TText16 tokenChars[] =

            {

            '&',

            '\'',

            '\"',

            '>',

            '<'

            };

        // Replace escaped characters, if any

        for (TInt i = 0; i < aOriginal.Length(); i++)

            {

            TBool foundChar = EFalse;

            //for (TInt j = 0; j < (sizeof(tokenChars) / sizeof(TText16)); j++)

            for (TInt j = 0; j < 5; j++)

                {

                if (aOriginal[i] == tokenChars[j])

                    {

                    if ( !aEncoded )

                        {

                        aEncoded =

                            HBufC8::NewL(aOriginal.Length() * KSenMaxXmlEscapedLength);

                        aEncoded->Des().Append(aOriginal.Left(i));

                        }

                    foundChar = ETrue;

                    aEncoded->Des().Append(tokens[j]);

                    retVal = ETrue; // indicate, that encoding was done

                    break;

                    }

                }

            if (!foundChar)

                {

                if (aEncoded)

                    {

                    aEncoded->Des().Append(aOriginal[i]);

                    }

                }

            }

        return retVal;

        }

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TXmlEngElement& aElement)

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aElement);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aLocalName)

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aLocalName);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,

                                                  const TDesC8& aLocalName

    )

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,

                                                  const TDesC8& aLocalName,

                                                  const TDesC8& aPrefix,

                                                  const RAttributeArray& aAttrs

    )

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix, aAttrs);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,

                                                  const TDesC8& aLocalName,

                                                  const TDesC8& aPrefix,

                                                  const RAttributeArray& aAttrs,

                                                  TXmlEngElement& aParent

    )

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix, aAttrs, aParent);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,

                                                  const TDesC8& aLocalName,

                                                  const TDesC8& aPrefix,

                                                  const RAttributeArray& aAttrs,

                                                  TXmlEngElement& aParent,

                                                  RSenDocument& aOwnerDocument

    )

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix, aAttrs, aParent,

                         aOwnerDocument);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(const TDesC8& aNsUri,

                                                  const TDesC8& aLocalName,

                                                  const TDesC8& aPrefix

    )

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aPrefix);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase* CSenFragmentBase::NewL(TXmlEngElement& aRootElement,

                                                  RSenDocument& aOwnerDocument)

    {

    CSenFragmentBase* pNew = new (ELeave) CSenFragmentBase;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aRootElement, aOwnerDocument);

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenFragmentBase::~CSenFragmentBase()

    {

    if ( ipNamespaceArray )

        {

        ipNamespaceArray->ResetAndDestroy();

        delete ipNamespaceArray;

        }

    iDocument.Close();

    if ( ipContentBuf )

    	{

        delete ipContentBuf;

        ipContentBuf = NULL;

        delete ipContentWriteStream;

        ipContentWriteStream = NULL;

        }

     if ( ipDelegate )

        {

        delete ipDelegate;

        ipDelegate = NULL;

        }   

    }

EXPORT_C CSenFragmentBase::CSenFragmentBase()

:   iState(KSenStateIgnore),

    ipParser(NULL),

    ipOwner(NULL),

    ipDelegate(NULL)

    {

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(const TXmlEngElement& aSrc)

    {

    iElement = aSrc.CopyL();

    iDocument = RSenDocument::NewL();

    iDocument.SetDocumentElement(iElement);

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aLocalName)

    {

    iDocument = RSenDocument::NewL();

    if ( aLocalName != KNullDesC8 )

        {

        iDocument.CreateDocumentElementL(aLocalName);

        iElement = iDocument.DocumentElement();

        }

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aNsUri,

                                               const TDesC8& aLocalName

    )

    {

    iDocument = RSenDocument::NewL();

    iDocument.CreateDocumentElementL(aLocalName, aNsUri);

    iElement = iDocument.DocumentElement();

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aNsUri,

                                               const TDesC8& aLocalName,

                                               const TDesC8& aPrefix,

                                               const RAttributeArray& aAttrs

    )

    {

    iDocument = RSenDocument::NewL();

    if (aPrefix == KNullDesC8)

        {

        iDocument.CreateDocumentElementL(aLocalName, aNsUri);

        }

    else

        {

        iDocument.CreateDocumentElementL(aLocalName, aNsUri, aPrefix);

        }

    iElement = iDocument.DocumentElement();

    AddAttributesL(aAttrs);

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName,

    const TDesC8& aPrefix,

    const RAttributeArray& aAttributes,

    TXmlEngElement& aParent

    )

    {

    iDocument = RSenDocument::NewL();

    iElement = aParent.AddNewElementL(aLocalName);

    if (aNsUri != KNullDesC8 || aPrefix != KNullDesC8)

        {

        if (aPrefix == KNullDesC8)

            {

            // Check if namespace declaration for the root tag

            // is already defined in parent element.

            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);

            if ( ns.IsNull() )

                {

                // Namespace declaration will be added to iElement

                iElement.AddNamespaceDeclarationL(aNsUri, KNullDesC8);

                }

            WsXmlUtils domUtils;       

            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, KNullDesC8);

            }

        else

            {

            // Check if namespace declaration for the root tag

            // is already defined in parent element.

            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);

            if ( ns.IsNull() )

                {

                // Namespace declaration will be added to iElement

                iElement.AddNamespaceDeclarationL(aNsUri, aPrefix);

                }

            WsXmlUtils domUtils;

            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, aPrefix);

            }

        }

    aParent.AppendChildL(iElement);

    AddAttributesL(aAttributes);

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName,

    const TDesC8& aPrefix,

    const RAttributeArray& aAttributes,

    TXmlEngElement& aParent,

    RSenDocument& aOwnerDocument

    )

    {

    iDocument = aOwnerDocument.Copy();

    iElement = aParent.AddNewElementL(aLocalName);

    if ( aNsUri != KNullDesC8 || aPrefix != KNullDesC8 )

        {

        if ( aPrefix == KNullDesC8 )

            {

            // Check if namespace declaration for the root tag

            // is already defined in parent element.

            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);

            if ( ns.IsNull() )

                {

                // Namespace declaration will be added to iElement

                iElement.AddNamespaceDeclarationL(aNsUri, KNullDesC8);

                }

            WsXmlUtils domUtils;

            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, KNullDesC8);

            }

        else

            {

            // Check if namespace declaration for the root tag

            // is already defined in parent element.

            TXmlEngNamespace ns = aParent.LookupNamespaceByUriL(aNsUri);

            if ( ns.IsNull() )

                {

                // Namespace declaration will be added to iElement

                iElement.AddNamespaceDeclarationL(aNsUri, aPrefix);

                }

            WsXmlUtils domUtils;

            domUtils.XmlEngRenameElementL(iElement, aLocalName, aNsUri, aPrefix);

            }

        }

    aParent.AppendChildL(iElement);

    AddAttributesL(aAttributes);

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(const TDesC8& aNsUri,

                                               const TDesC8& aLocalName,

                                               const TDesC8& aPrefix

    )

    {

    iDocument = RSenDocument::NewL();

    if ( aNsUri == KNullDesC8 && aPrefix == KNullDesC8 )

        {

        iDocument.CreateDocumentElementL(aLocalName);

        }

    else

        {

        if ( aPrefix == KNullDesC8 )

            {

            iDocument.CreateDocumentElementL(aLocalName, aNsUri, KNullDesC8);

            }

        else

            {

            iDocument.CreateDocumentElementL(aLocalName, aNsUri, aPrefix);

            }

        }

    iElement = iDocument.DocumentElement();

    }

EXPORT_C void CSenFragmentBase::BaseConstructL(TXmlEngElement& aRootElement,

                                               RSenDocument& aOwnerDocument)

    {

    iDocument = aOwnerDocument.Copy();

    iElement = aRootElement;

    }

EXPORT_C void CSenFragmentBase::AddNamespacesL()

    {

    if (ipParser)

        {

        if ( ipParser->IsFeatureEnabled(EReportNamespaceMapping) )

            {

            // Add namespaces, if any

            if ( ipNamespaceArray )

                {

                TInt count = ipNamespaceArray->Count();

                for (TInt i=0; i < count; i++)

                    {

                    CSenNamespaceData* pNamespace = (*ipNamespaceArray)[i];

                    TXmlEngNamespace ns =

                                AsElementL().LookupNamespaceByUriL(*pNamespace->ipNamespaceUri);

                    if ( ns.IsNull() )

                        {

                        if (pNamespace->ipPrefix == NULL)

                            {

                            AsElementL().AddNamespaceDeclarationL(*pNamespace->ipNamespaceUri,

                                                                  KNullDesC8);

                            }

                        else

                            {

                            AsElementL().AddNamespaceDeclarationL(*pNamespace->ipNamespaceUri,

                                                                  *pNamespace->ipPrefix);

                            }

                        }

                    }

                ipNamespaceArray->ResetAndDestroy();

                }

            }

        }

    }

EXPORT_C void CSenFragmentBase::AddAttributesToElementL(TXmlEngElement aElement,

                                               const RAttributeArray& apAttrs)

    {

    TInt count(apAttrs.Count());

    for(TInt i=0; i<count; i++)

        {

        TPtrC8 localName = apAttrs[i].Attribute().LocalName().DesC();

        TPtrC8 value = apAttrs[i].Value().DesC();

        if (apAttrs[i].Attribute().Uri().DesC() == KNullDesC8)

            {

            aElement.AddNewAttributeL(localName, value);

            }

        else

            {

            TPtrC8 namespaceUri = apAttrs[i].Attribute().Uri().DesC();

            TPtrC8 prefix(KNullDesC8);

            if ( apAttrs[i].Attribute().Prefix().DesC() != KNullDesC8 )

                {

                prefix.Set(apAttrs[i].Attribute().Prefix().DesC());

                }

            TXmlEngNamespace ns = aElement.LookupNamespaceByUriL(namespaceUri);

            if ( ns.NotNull() )

                {

                if (ns.Prefix() == KNullDesC8 && prefix == KNullDesC8)

                    {

                    aElement.AddNewAttributeWithNsL(localName, value, namespaceUri);

                    }

                else if ( ns.Prefix() == prefix )

                    {

                    aElement.AddNewAttributeL(localName, value, ns);

                    }

                else

                    {

                    aElement.AddNewAttributeL(localName, value, namespaceUri, prefix);

                    }

                }

            else

                {

                if ( prefix == KNullDesC8 )

                    {

                    aElement.AddNamespaceDeclarationL(namespaceUri, KNullDesC8);

                    aElement.AddNewAttributeWithNsL(localName, value, namespaceUri);

                    }

                else

                    {

                    aElement.AddNewAttributeL(localName, value, namespaceUri, prefix);

                    }

                }

            }

        }

    }

EXPORT_C void CSenFragmentBase::AddAttributesL(const RAttributeArray& apAttrs)

    {

    AddAttributesToElementL(AsElementL(), apAttrs);

    }

EXPORT_C RSenDocument& CSenFragmentBase::AsDocumentL()

    {

    return iDocument;

    }