/*

 * libxml2_error.c: module displaying/handling XML parser errors

 *

 * See Copyright for the status of this software.

 *

 * Daniel Veillard <daniel@veillard.com>

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

 */

#define IN_LIBXML

#include "xmlenglibxml.h"

#include <string.h>

#include <stdarg.h>

#include <stdapis/libxml2/libxml2_globals.h>

#include "libxml2_xmlerror2.h"

void xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,

                 const char *msg,

                 ...);

#define XML_GET_VAR_STR(msg, str)                   \

{                                                   \

    int       size;                                 \

    int       chars;                                \

    char      *larger;                              \

    va_list   ap;                                   \

                                                    \

    str = (char *) xmlMalloc(150);                  \

    if (str != NULL)                                \

    {                                               \

        size = 150;                                 \

                                                    \

        while (1)                                   \

        {                                           \

            va_start(ap, msg);                      \

            chars = vsnprintf(str, size, msg, ap);  \

            va_end(ap);                             \

            if ((chars > -1) && (chars < size))     \

                break;                              \

                                                    \

            size += (chars > -1) ? chars + 1 : 100; \

            larger = (char*) xmlRealloc(str, size); \

            if (!larger)                            \

                break;                              \

                                                    \

            str = larger;                           \

        }                                           \

    }                                               \

}

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

 *                                                                      *

 *          Handling of out of context errors                           *

 *                                                                      *

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

/**

 * xmlGenericErrorDefaultFunc:

 * @param ctx an error context

 * @param msg the message to display/transmit

 * @param # extra parameters for the message display

 *

 * Default handler for out of context error messages.

 */

void

xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {

    return;

}

/**

 * initGenericErrorDefaultFunc:

 * @param handler the handler

 *

 * Set or reset (if NULL) the default handler for generic errors

 * to the builtin error function.

 */

XMLPUBFUNEXPORT void

initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)

{

    xmlGenericError = handler ? (*handler) : xmlGenericErrorDefaultFunc;

}

/**

 * xmlSetGenericErrorFunc:

 * @param ctx the new error handling context

 * @param handler the new handler function

 *

 * Function to reset the handler and the error context for out of

 * context error messages.

 * This simply means that handler will be called for subsequent

 * error messages while not parsing nor validating. And ctx will

 * be passed as first argument to handler

 * One can simply force messages to be emitted to another FILE * than

 * stderr by setting ctx to this file handle and handler to NULL.

 */

XMLPUBFUNEXPORT void

xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {

    xmlGenericErrorContext = ctx;

    xmlGenericError = handler ? handler : xmlGenericErrorDefaultFunc;

}

/**

 * xmlSetStructuredErrorFunc:

 * @param ctx the new error handling context

 * @param handler the new handler function

 *

 * Function to reset the handler and the error context for out of

 * context structured error messages.

 * This simply means that handler will be called for subsequent

 * error messages while not parsing nor validating. And ctx will

 * be passed as first argument to handler

 */

XMLPUBFUNEXPORT void

xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {

	LOAD_GS_DIRECT

    xmlGenericErrorContext = ctx;

    xmlStructuredError = handler;

}

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

 *                                                                      *

 *          Handling of parsing errors                                  *

 *                                                                      *

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

/**

 * xmlParserPrintFileInfo:

 * @param input an xmlParserInputPtr input

 *

 * Displays the associated file and line informations for the current input

 */

XMLPUBFUNEXPORT void

xmlParserPrintFileInfo(xmlParserInputPtr input) {

    if (input) {

        xmlGenericError(

            xmlGenericErrorContext,

            "%s: line %d: ",

            (input->filename ? input->filename : "Entity [no file name]"),

            input->line);

    }

}

/**

 * xmlParserPrintFileContext:

 * @param input an xmlParserInputPtr input

 *

 * Displays current context within the input content for error tracking

 */

static void

xmlParserPrintFileContextInternal(xmlParserInputPtr input ,

        xmlGenericErrorFunc channel, void *data ) {

    const xmlChar *cur, *base;

    unsigned int n, col;    /* GCC warns if signed, because compared with sizeof() */

    xmlChar  content[81]; /* space for 80 chars + line terminator */

    xmlChar *ctnt;

    if (input == NULL) return;

    cur = input->cur;

    base = input->base;

    /* skip backwards over any end-of-lines */

    while ((cur > base) && ((*(cur) == '\n') || (*(cur) == '\r'))) {

    cur--;

    }

    n = 0;

    /* search backwards for beginning-of-line (to max buff size) */

    while ((n++ < (sizeof(content)-1)) && (cur > base) &&

           (*(cur) != '\n') && (*(cur) != '\r'))

        cur--;

    if ((*(cur) == '\n') || (*(cur) == '\r')) cur++;

    /* calculate the error position in terms of the current position */

    col = input->cur - cur;

    /* search forward for end-of-line (to max buff size) */

    n = 0;

    ctnt = content;

    /* copy selected text to our buffer */

    while ((*cur != 0) && (*(cur) != '\n') &&

           (*(cur) != '\r') && (n < sizeof(content)-1)) {

        *ctnt++ = *cur++;

    n++;

    }

    *ctnt = 0;

    /* print out the selected text */

    channel(data ,"%s\n", content);

    /* create blank line with problem pointer */

    n = 0;

    ctnt = content;

    /* (leave buffer space for pointer + line terminator) */

    while ((n<col) && (n++ < sizeof(content)-2) && (*ctnt != 0)) {

    if (*(ctnt) != '\t')

        *(ctnt) = ' ';

    ctnt++;

    }

    *ctnt++ = '^';

    *ctnt = 0;

    channel(data ,"%s\n", content);

}

/**

 * xmlParserPrintFileContext:

 * @param input an xmlParserInputPtr input

 *

 * Displays current context within the input content for error tracking

 */

XMLPUBFUNEXPORT void

xmlParserPrintFileContext(xmlParserInputPtr input) {

   xmlParserPrintFileContextInternal(input, xmlGenericError,

                                     xmlGenericErrorContext);

}

/**

 * xmlReportError:

 * @param err the error

 * @param ctx the parser context or NULL

 * @param str the formatted error message

 *

 * Report an erro with its context, replace the 4 old error/warning

 * routines.

 */

static void

xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,

               xmlGenericErrorFunc channel, void *data)

{

    char *file = NULL;

    int line = 0;

    int code = -1;

    int domain;

    const xmlChar *name = NULL;

    xmlNodePtr node;

    xmlErrorLevel level;

    xmlParserInputPtr input = NULL;

    xmlParserInputPtr cur = NULL;

    if (err == NULL)

        return;

    if (channel == NULL) { 

        channel = xmlGenericError;

        data = xmlGenericErrorContext;

    }

    file = err->file;

#ifdef LIBXML_ENABLE_NODE_LINEINFO

    line = err->line;

#endif

    code = err->code;

    domain = err->domain;

    level = err->level;

    node = (xmlNodePtr)err->node;

    if (code == XML_ERR_OK)

        return;

    if ((node != NULL) && (node->type == XML_ELEMENT_NODE))

        name = node->name;

    /*

     * Maintain the compatibility with the legacy error handling

     */

    if (ctxt != NULL) {

        input = ctxt->input;

        if ((input != NULL) && (input->filename == NULL) &&

            (ctxt->inputNr > 1)) {

            cur = input;

            input = ctxt->inputTab[ctxt->inputNr - 2];

        }

        if (input != NULL) {

            if (input->filename)

                channel(data, "%s:%d: ", input->filename, input->line);

            else if ((line != 0) && (domain == XML_FROM_PARSER))

                channel(data, "Entity: line %d: ", input->line);

        }

    } else {

        if (file != NULL)

            channel(data, "%s:%d: ", file, line);

        else if ((line != 0) && (domain == XML_FROM_PARSER))

            channel(data, "Entity: line %d: ", line);

    }

    if (name != NULL) {

        channel(data, "element %s: ", name);

    }

    if (code == XML_ERR_OK)

        return;

    switch (domain) {

        case XML_FROM_PARSER:

            channel(data, "parser ");

            break;

        case XML_FROM_NAMESPACE:

            channel(data, "namespace ");

            break;

        case XML_FROM_DTD:

        case XML_FROM_VALID:

            channel(data, "validity ");

            break;

        case XML_FROM_HTML:

            channel(data, "HTML parser ");

            break;

        case XML_FROM_MEMORY:

            channel(data, "memory ");

            break;

        case XML_FROM_OUTPUT:

            channel(data, "output ");

            break;

        case XML_FROM_IO:

            channel(data, "I/O ");

            break;

        case XML_FROM_XINCLUDE:

            channel(data, "XInclude ");

            break;

        case XML_FROM_XPATH:

            channel(data, "XPath ");

            break;

        case XML_FROM_XPOINTER:

            channel(data, "parser ");

            break;

        case XML_FROM_REGEXP:

            channel(data, "regexp ");

            break;

        case XML_FROM_SCHEMASV:

            channel(data, "Schemas validity ");

            break;

        case XML_FROM_SCHEMASP:

            channel(data, "Schemas parser ");

            break;

        case XML_FROM_RELAXNGP:

            channel(data, "Relax-NG parser ");

            break;

        case XML_FROM_RELAXNGV:

            channel(data, "Relax-NG validity ");

            break;

        case XML_FROM_CATALOG:

            channel(data, "Catalog ");

            break;

        case XML_FROM_C14N:

            channel(data, "C14N ");

            break;

        case XML_FROM_XSLT:

            channel(data, "XSLT ");

            break;

        default:

            break;

    }

    if (code == XML_ERR_OK)

        return;

    switch (level) {

        case XML_ERR_NONE:

            channel(data, ": ");

            break;

        case XML_ERR_WARNING:

            channel(data, "warning : ");

            break;

        case XML_ERR_ERROR:

            channel(data, "error : ");

            break;

        case XML_ERR_FATAL:

            channel(data, "error : ");

            break;

    }

    if (code == XML_ERR_OK)

        return;

    if (str != NULL) {

        int len;

        len = xmlStrlen((const xmlChar *)str);

        if ((len > 0) && (str[len - 1] != '\n'))

            channel(data, "%s\n", str);

        else

            channel(data, "%s", str);

    } else {

        channel(data, "%s\n", "out of memory error");

    }

    if (code == XML_ERR_OK)

        return;

    if (ctxt != NULL) {

        xmlParserPrintFileContextInternal(input, channel, data);

        if (cur != NULL) {

            if (cur->filename)

                channel(data, "%s:%d: \n", cur->filename, cur->line);

            else if ((line != 0) && (domain == XML_FROM_PARSER))

                channel(data, "Entity: line %d: \n", cur->line);

            xmlParserPrintFileContextInternal(cur, channel, data);

        }

    }

    if ((domain == XML_FROM_XPATH) &&

        (err->str1 != NULL) &&

        (err->int1 < 100) &&

        (err->int1 < xmlStrlen((const xmlChar *)err->str1)))

    {

        xmlChar buf[150];

        int i;

        channel(data, "%s\n", err->str1);

        for (i=0;i < err->int1;i++)

             buf[i] = ' ';

        buf[i++] = '^';

        buf[i] = 0;

        channel(data, "%s\n", buf);

    }

}

/**

 * __xmlRaiseError:

 * @param schannel the structured callback channel

 * @param channel the old callback channel

 * @param data the callback data

 * @param ctx the parser context or NULL

 * @param ctx the parser context or NULL

 * @param domain the domain for the error

 * @param code the code for the error

 * @param level the xmlErrorLevel for the error

 * @param file the file source of the error (or NULL)

 * @param line the line of the error or 0 if N/A

 * @param str1 extra string info

 * @param str2 extra string info

 * @param str3 extra string info

 * @param int1 extra int info

 * @param int2 extra int info

 * @param msg the message to display/transmit

 * @param # extra parameters for the message display

 *

 * Update the appropriate global or contextual error structure,

 * then forward the error message down the parser or generic

 * error callback handler

 */

void

__xmlRaiseError(xmlStructuredErrorFunc schannel,

              xmlGenericErrorFunc channel, void *data, void *ctx,

              void *nod, int domain, int code, xmlErrorLevel level,

              const char *file, int line, const char *str1,

              const char *str2, const char *str3, int int1, int int2,

          const char *msg, ...)

{

	LOAD_GS_DIRECT

	xmlParserCtxtPtr ctxt = NULL;

    xmlNodePtr node = (xmlNodePtr) nod;

    char *str = NULL;

    xmlParserInputPtr input = NULL;

    xmlErrorPtr to = &xmlLastError;

    xmlChar *base = NULL;

    int wasOOM = (code == XML_ERR_NO_MEMORY);

    // Check, whether we must ignore warnings

    if (!xmlGetWarningsDefaultValue && (level == XML_ERR_WARNING))

        return;

    if ((domain == XML_FROM_PARSER)    ||

        (domain == XML_FROM_HTML)      ||

        (domain == XML_FROM_DTD)       ||

        (domain == XML_FROM_NAMESPACE) ||

        (domain == XML_FROM_IO))

    {

        ctxt = (xmlParserCtxtPtr) ctx;

        if ((schannel == NULL) && (ctxt != NULL) &&

            (ctxt->sax != NULL)&& (ctxt->sax->initialized == XML_SAX2_MAGIC))

               schannel = ctxt->sax->serror;

    }

    if (schannel == NULL)

        schannel = xmlStructuredError;

    if ((domain == XML_FROM_VALID) &&

        ((channel == xmlParserValidityError) || (channel == xmlParserValidityWarning)))

    {

        ctxt = (xmlParserCtxtPtr) ctx;

        if ((schannel == NULL) &&

            (ctxt != NULL) &&

            (ctxt->sax != NULL) &&

            (ctxt->sax->initialized == XML_SAX2_MAGIC))

        {

            schannel = ctxt->sax->serror;

        }

    }

    if (code == XML_ERR_OK)

        return;

    /*

     * Formatting the message

     */

#ifndef XMLENGINE_EXCLUDE_EMBED_MSG

    if (msg == NULL || wasOOM) {

#else

    if (msg == NULL || msg == __embedded_errtxt_replacement || wasOOM) {

#endif

        // DONE: do not copy if it was OOM

        str =  (code == XML_ERR_NO_MEMORY) ? NULL :  (char *) xmlStrdup(BAD_CAST "No error message provided");

        str1 = str2 = str3 = NULL;

    } else {

        //XML_GET_VAR_STR(msg, str); //this causes panic when OOM

        str = (char *) xmlStrdup(BAD_CAST msg); // NOTE: message is not filled with data from variable list

    }

    /*

     * specific processing if a parser context is provided

     */

    if (ctxt != NULL) {

        if (file == NULL) {

            input = ctxt->input;

            if ((input != NULL) &&

                (input->filename == NULL) &&

                (ctxt->inputNr > 1))

            {

                input = ctxt->inputTab[ctxt->inputNr - 2];

            }

            if (input != NULL) {

                file = input->filename;

                line = input->line;

            }

        }

        to = &ctxt->lastError;

    } else if ((node != NULL) && (file == NULL)) {

        if(!wasOOM)

        {

            int i;

            if ((node->doc != NULL) && (node->doc->URL != NULL))

                base = xmlStrdup(node->doc->URL);

            for (i = 0;

                ((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));

                i++)

             {

                node = node->parent;

             }

            if (!base  &&  node  &&  node->doc  &&  node->doc->URL)

            {