/*

 * libxml2_xinclude.c : Code to implement XInclude processing

 *

 * World Wide Web Consortium W3C Last Call WorkingDraft 10 November 2003

 * http://www.w3.org/TR/2003/WD-xinclude-20031110

 *

 * See Copyright for the status of this software.

 *

 * daniel@veillard.com

 * Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

 */

#define IN_LIBXML

#include "xmlenglibxml.h"

#ifdef LIBXML_XINCLUDE_ENABLED

#include <stdapis/libxml2/libxml2_globals.h>

#include <stdapis/libxml2/libxml2_tree.h>

#include <stdapis/libxml2/libxml2_parser.h>

#include <stdapis/libxml2/libxml2_uri.h>

#include <stdapis/libxml2/libxml2_xpointer.h>

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <stdapis/libxml2/libxml2_xmlerror.h>

#include "libxml2_xmlerror2.h"

#include <stdapis/libxml2/libxml2_encoding.h>

#include "libxml2_xinclude.h"

#include <string.h>

#define XINCLUDE_MAX_DEPTH 40

// #define DEBUG_XINCLUDE

#ifdef DEBUG_XINCLUDE

#  ifdef LIBXML_DEBUG_ENABLED

#    include "Libxml2_debugXML.h"

#  endif

#endif

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

 *                                                                      *

 *                      XInclude context handling                       *

 *                                                                      *

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

/*

 * An XInclude context

 */

typedef xmlChar *xmlURL;

typedef struct _xmlXIncludeRef xmlXIncludeRef;

typedef xmlXIncludeRef *xmlXIncludeRefPtr;

struct _xmlXIncludeRef {

    xmlChar              *URI; /* the fully resolved resource URL */

    xmlChar         *fragment; /* the fragment in the URI */

    xmlDocPtr             doc; /* the parsed document */

    xmlNodePtr            ref; /* the node making the reference in the source */

    xmlNodePtr            inc; /* the included copy */

    int                   xml; /* xml or txt */

    int                 count; /* how many refs use that specific doc */

    xmlXPathObjectPtr    xptr; /* the xpointer if needed */

    int               emptyFb; /* flag to show fallback empty */

};

struct _xmlXIncludeCtxt {

    xmlDocPtr             doc; /* the source document */

    int               incBase; /* the first include for this document */

    int                 incNr; /* number of includes */

    int                incMax; /* size of includes tab */

    xmlXIncludeRefPtr *incTab; /* array of included references */

    int                 txtNr; /* number of unparsed documents */

    int                txtMax; /* size of unparsed documents tab */

    xmlNodePtr        *txtTab; /* array of unparsed text nodes */

    xmlURL         *txturlTab; /* array of unparsed text URLs */

    xmlChar *             url; /* the current URL processed */

    int                 urlNr; /* number of URLs stacked */

    int                urlMax; /* size of URL stack */

    xmlChar *         *urlTab; /* URL stack */

    int              nbErrors; /* the number of errors detected */

    int                legacy; /* using XINCLUDE_OLD_NS */

    int            parseFlags; /* the flags used for parsing XML documents */

};

static int

xmlXIncludeDoProcess(xmlXIncludeCtxtPtr ctxt, xmlDocPtr doc, xmlNodePtr tree);

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

 *                                                                      *

 *                      XInclude error handler                          *

 *                                                                      *

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

/**

 * xmlXIncludeErrMemory:

 * @param extra extra information

 *

 * Handle an out of memory condition

 */

static void

xmlXIncludeErrMemory(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node,

                     const char *extra)

{

    if (ctxt != NULL)

        ctxt->nbErrors++;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,

                    XML_ERR_NO_MEMORY, XML_ERR_ERROR, NULL, 0,

                    extra, NULL, NULL, 0, 0,

                    "Memory allocation failed : %s\n", extra);

}

/**

 * xmlXIncludeErr:

 * @param ctxt the XInclude context

 * @param node the context node

 * @param msg the error message

 * @param extra extra information

 *

 * Handle an XInclude error

 */

static void

xmlXIncludeErr(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,

               const char *msg, const xmlChar *extra)

{

    if (ctxt != NULL)

        ctxt->nbErrors++;

    __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,

                    error, XML_ERR_ERROR, NULL, 0,

                    (const char *) extra, NULL, NULL, 0, 0,

                    msg, (const char *) extra);

}

#if 0

/**

 * xmlXIncludeWarn:

 * @param ctxt the XInclude context

 * @param node the context node

 * @param msg the error message

 * @param extra extra information

 *

 * Emit an XInclude warning.

 */

static void

xmlXIncludeWarn(xmlXIncludeCtxtPtr ctxt, xmlNodePtr node, int error,

               const char *msg, const xmlChar *extra)

{

    __xmlRaiseError(NULL, NULL, NULL, ctxt, node, XML_FROM_XINCLUDE,

                    error, XML_ERR_WARNING, NULL, 0,

                    (const char *) extra, NULL, NULL, 0, 0,

                    msg, (const char *) extra);

}

#endif

/**

 * xmlXIncludeGetProp:

 * @param ctxt the XInclude context

 * @param cur the node

 * @param name the attribute name

 *

 * Get an XInclude attribute

 *

 * Returns the value (to be freed) or NULL if not found

 */

static xmlChar *

xmlXIncludeGetProp(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur,

                   const xmlChar *name) {

    xmlChar *ret;

    ret = xmlGetNsProp(cur, XINCLUDE_NS, name);

    if (ret != NULL)

        return(ret);

    if (ctxt->legacy != 0) {

        ret = xmlGetNsProp(cur, XINCLUDE_OLD_NS, name);

        if (ret != NULL)

            return(ret);

    }

    ret = xmlGetProp(cur, name);

    return(ret);

}

/**

 * xmlXIncludeFreeRef:

 * @param ref the XInclude reference

 *

 * Free an XInclude reference

 */

static void

xmlXIncludeFreeRef(xmlXIncludeRefPtr ref) {

    if (ref == NULL)

        return;

#ifdef DEBUG_XINCLUDE

    xmlGenericError(xmlGenericErrorContext, "Freeing ref\n");

#endif

    if (ref->doc != NULL) {

#ifdef DEBUG_XINCLUDE

        xmlGenericError(xmlGenericErrorContext, "Freeing doc %s\n", ref->URI);

#endif

        xmlFreeDoc(ref->doc);

    }

    if (ref->URI != NULL)

        xmlFree(ref->URI);

    if (ref->fragment != NULL)

        xmlFree(ref->fragment);

    if (ref->xptr != NULL)

        xmlXPathFreeObject(ref->xptr);

    xmlFree(ref);

}

/**

 * xmlXIncludeNewRef:

 * @param ctxt the XInclude context

 * @param URI the resource URI

 *

 * Creates a new reference within an XInclude context

 *

 * Returns the new set

 */

static xmlXIncludeRefPtr

xmlXIncludeNewRef(xmlXIncludeCtxtPtr ctxt, const xmlChar* URI, xmlNodePtr ref)

{

    xmlXIncludeRefPtr ret;

#ifdef DEBUG_XINCLUDE

    xmlGenericError(xmlGenericErrorContext, "New ref %s\n", URI);

#endif

    ret = (xmlXIncludeRefPtr) xmlMalloc(sizeof(xmlXIncludeRef));

    if (!ret)

        goto OOM_exit;

    memset(ret, 0, sizeof(xmlXIncludeRef));

    ret->URI = URI ? xmlStrdup(URI) : (xmlChar*) /* NULL */ URI;

    // DONE: remove unnecessary initialization to NULL

    //ret->fragment = NULL;

    ret->ref = ref;

    //ret->doc = 0;

    //ret->count = 0;

    //ret->xml = 0;

    //ret->inc = NULL;

    if (ctxt->incMax == 0) {

        xmlXIncludeRefPtr* tmp;

        tmp = (xmlXIncludeRefPtr*) xmlMalloc(4 * sizeof(ctxt->incTab[0]));

        if (!tmp)

            goto OOM;

        ctxt->incTab = tmp;

        ctxt->incMax = 4;

    }

    if (ctxt->incNr >= ctxt->incMax) {

        xmlXIncludeRefPtr* tmp;

        ctxt->incMax *= 2;

        tmp = (xmlXIncludeRefPtr*) xmlRealloc(ctxt->incTab, // DONE: Fix xmlRealloc

                        ctxt->incMax * sizeof(ctxt->incTab[0]));

        if (!tmp) {

            ctxt->incMax /= 2;

OOM:

            xmlXIncludeFreeRef(ret);

OOM_exit:

            xmlXIncludeErrMemory(ctxt, ref, "growing XInclude context");

            return(NULL);

        }

        ctxt->incTab = tmp;

    }

    ctxt->incTab[ctxt->incNr++] = ret;

    return(ret);

}

/**

 * xmlXIncludeNewContext:

 * @param doc an XML Document

 *

 * Creates a new XInclude context

 *

 * Returns the new set

 */

XMLPUBFUNEXPORT xmlXIncludeCtxtPtr

xmlXIncludeNewContext(xmlDocPtr doc) {

    xmlXIncludeCtxtPtr ret;

#ifdef DEBUG_XINCLUDE

    xmlGenericError(xmlGenericErrorContext, "New context\n");

#endif

    if (doc == NULL)

        return(NULL);

    ret = (xmlXIncludeCtxtPtr) xmlMalloc(sizeof(xmlXIncludeCtxt));

    if (ret == NULL) {

        xmlXIncludeErrMemory(NULL, (xmlNodePtr) doc,

                             "creating XInclude context");

        return(NULL);

    }

    memset(ret, 0, sizeof(xmlXIncludeCtxt));

    ret->doc = doc;

    ret->incNr = 0;

    ret->incBase = 0;

    ret->incMax = 0;

    ret->incTab = NULL;

    ret->nbErrors = 0;

    return(ret);

}

/**

 * xmlXIncludeURLPush:

 * @param ctxt the parser context

 * @param value the url

 *

 * Pushes a new url on top of the url stack

 *

 * Returns -1 in case of error, the index in the stack otherwise

 */

static int

xmlXIncludeURLPush(xmlXIncludeCtxtPtr ctxt, const xmlChar* value)

{

    xmlChar* vcopy;

    if (ctxt->urlNr > XINCLUDE_MAX_DEPTH) {

        xmlXIncludeErr(ctxt, NULL, XML_XINCLUDE_RECURSION,

                       "detected a recursion in %s\n", value);

        return(-1);

    }

    if (ctxt->urlTab == NULL) {

        ctxt->urlMax = 0;

        ctxt->urlNr = 0;

        ctxt->urlTab = (xmlChar**) xmlMalloc(4 * sizeof(ctxt->urlTab[0]));

        if (!ctxt->urlTab)

            goto OOM_exit;

        ctxt->urlMax = 4;

    }

    if (ctxt->urlNr >= ctxt->urlMax) {

        xmlChar** tmp;

        ctxt->urlMax *= 2;

        tmp =  (xmlChar**) xmlRealloc(ctxt->urlTab, // DONE: Fix xmlRealloc

                                      ctxt->urlMax *

                                      sizeof(ctxt->urlTab[0]));

        if (!tmp) {

            ctxt->urlMax /= 2;

OOM_exit:

            xmlXIncludeErrMemory(ctxt, NULL, "adding URL");

            return (-1);

        }

        ctxt->urlTab = tmp;

    }

    vcopy = value ? xmlStrdup(value) : (xmlChar*) value /* NULL */;

    if(vcopy || !value)

        {

        ctxt->url = ctxt->urlTab[ctxt->urlNr] = vcopy;

        return (ctxt->urlNr++);

        }

    else // OOM!

        goto OOM_exit;

}

/**

 * xmlXIncludeURLPop:

 * @param ctxt the parser context

 *

 * Pops the top URL from the URL stack

 */

static void

xmlXIncludeURLPop(xmlXIncludeCtxtPtr ctxt)

{

    xmlChar * ret;

    if (ctxt->urlNr <= 0)

        return;

    ctxt->urlNr--;

    if (ctxt->urlNr > 0)

        ctxt->url = ctxt->urlTab[ctxt->urlNr - 1];

    else

        ctxt->url = NULL;

    ret = ctxt->urlTab[ctxt->urlNr];

    ctxt->urlTab[ctxt->urlNr] = 0;

    if (ret != NULL)

        xmlFree(ret);

}

/**

 * xmlXIncludeFreeContext:

 * @param ctxt the XInclude context

 *

 * Free an XInclude context

 */

XMLPUBFUNEXPORT void

xmlXIncludeFreeContext(xmlXIncludeCtxtPtr ctxt) {

    int i;

#ifdef DEBUG_XINCLUDE

    xmlGenericError(xmlGenericErrorContext, "Freeing context\n");

#endif

    if (ctxt == NULL)

        return;

    while (ctxt->urlNr > 0)

        xmlXIncludeURLPop(ctxt);

    if (ctxt->urlTab != NULL)

        xmlFree(ctxt->urlTab);

    for (i = 0;i < ctxt->incNr;i++) {

        if (ctxt->incTab[i] != NULL)

            xmlXIncludeFreeRef(ctxt->incTab[i]);

    }

    for (i = 0;i < ctxt->txtNr;i++) {

        if (ctxt->txturlTab[i] != NULL)

            xmlFree(ctxt->txturlTab[i]);

    }

    if (ctxt->incTab != NULL)

        xmlFree(ctxt->incTab);

    if (ctxt->txtTab != NULL)

        xmlFree(ctxt->txtTab);

    if (ctxt->txturlTab != NULL)

        xmlFree(ctxt->txturlTab);

    xmlFree(ctxt);

}

/**

 * xmlXIncludeParseFile:

 * @param ctxt the XInclude context

 * @param URL the URL or file path

 *

 * parse a document for XInclude

 */

static xmlDocPtr

xmlXIncludeParseFile(xmlXIncludeCtxtPtr ctxt, const char *URL) {

    xmlDocPtr         ret;

    xmlParserCtxtPtr  pctxt;

    // 'directory' was removed during optimization

    xmlParserInputPtr inputStream;

    xmlInitParser();

    pctxt = xmlNewParserCtxt();

    if (!pctxt) {

        xmlXIncludeErrMemory(ctxt, NULL, "cannot allocate parser context");

        return(NULL);

    }

    /*

     * try to ensure that new documents included are actually

     * built with the same dictionary as the including document.

     */

    if (ctxt->doc       &&

        ctxt->doc->dict &&

        pctxt->dict)

    {

        xmlDictFree(pctxt->dict);

        pctxt->dict = ctxt->doc->dict;

        xmlDictReference(pctxt->dict);

    }

    xmlCtxtUseOptions(pctxt, ctxt->parseFlags | XML_PARSE_DTDLOAD);

    inputStream = xmlLoadExternalEntity(URL, NULL, pctxt);

    if (!inputStream) {

        xmlFreeParserCtxt(pctxt);

        return(NULL);

    }

    inputPush(pctxt, inputStream);

    if (!pctxt->directory)

        pctxt->directory = xmlParserGetDirectory(URL);

    pctxt->loadsubset = XML_DETECT_IDS;

    xmlParseDocument(pctxt);

    if (pctxt->wellFormed) {

        ret = pctxt->myDoc;

    } else {

        ret = NULL;

        if (pctxt->myDoc){

            xmlFreeDoc(pctxt->myDoc);

            pctxt->myDoc = NULL;

        }

    }

    xmlFreeParserCtxt(pctxt);

    return(ret);

}

/**

 * xmlXIncludeAddNode:

 * @param ctxt the XInclude context

 * @param cur the new node

 *

 * Add a new node to process to an XInclude context

 */

static int

xmlXIncludeAddNode(xmlXIncludeCtxtPtr ctxt, xmlNodePtr cur) {

    xmlXIncludeRefPtr ref;

    xmlURIPtr uri;

    xmlChar *URL;

    xmlChar *fragment = NULL;

    xmlChar *href;

    xmlChar *parse;

    xmlChar *base;

    xmlChar *URI;

    int xml = 1, i; /* default Issue 64 */

    int local = 0;

    if (ctxt == NULL)

        return(-1);

    if (cur == NULL)

        return(-1);

#ifdef DEBUG_XINCLUDE

    xmlGenericError(xmlGenericErrorContext, "Add node\n");

#endif

    /*

     * read the attributes

     */

    href = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_HREF);

    if (href == NULL) {

        href = xmlStrdup(BAD_CAST ""); /* @@@@ href is now optional */

        if (href == NULL)

            return(-1);

        local = 1;

    }

    if (href[0] == '#')

        local = 1;

    parse = xmlXIncludeGetProp(ctxt, cur, XINCLUDE_PARSE);

    if (parse != NULL) {

        if (xmlStrEqual(parse, XINCLUDE_PARSE_XML))

            xml = 1;

        else if (xmlStrEqual(parse, XINCLUDE_PARSE_TEXT))

            xml = 0;

        else {

            xmlXIncludeErr(ctxt, cur, XML_XINCLUDE_PARSE_VALUE,

                           "invalid value %s for 'parse'\n", parse);

            if (href != NULL)

                xmlFree(href);

            if (parse != NULL)