xref: /aosp_15_r20/external/libxml2/error.c (revision 7c5688314b92172186c154356a6374bf7684c3ca)

/*
 * error.c: module displaying/handling XML parser errors
 *
 * See Copyright for the status of this software.
 *
 * Daniel Veillard <[email protected]>
 */

#define IN_LIBXML
#include "libxml.h"

#include <string.h>
#include <stdarg.h>
#include <stdlib.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include <libxml/xmlmemory.h>

#include "private/error.h"
#include "private/globals.h"
#include "private/string.h"

/************************************************************************
 *									*
 *			Error struct					*
 *									*
 ************************************************************************/

static int
xmlVSetError(xmlError *err,
             void *ctxt, xmlNodePtr node,
             int domain, int code, xmlErrorLevel level,
             const char *file, int line,
             const char *str1, const char *str2, const char *str3,
             int int1, int col,
             const char *fmt, va_list ap)
{
    char *message = NULL;
    char *fileCopy = NULL;
    char *str1Copy = NULL;
    char *str2Copy = NULL;
    char *str3Copy = NULL;

    if (code == XML_ERR_OK) {
        xmlResetError(err);
        return(0);
    }

    /*
     * Formatting the message
     */
    if (fmt == NULL) {
        message = xmlMemStrdup("No error message provided");
    } else {
        xmlChar *tmp;
        int res;

        res = xmlStrVASPrintf(&tmp, MAX_ERR_MSG_SIZE, fmt, ap);
        if (res < 0)
            goto err_memory;
        message = (char *) tmp;
    }
    if (message == NULL)
        goto err_memory;

    if (file != NULL) {
        fileCopy = (char *) xmlStrdup((const xmlChar *) file);
        if (fileCopy == NULL)
            goto err_memory;
    }
    if (str1 != NULL) {
        str1Copy = (char *) xmlStrdup((const xmlChar *) str1);
        if (str1Copy == NULL)
            goto err_memory;
    }
    if (str2 != NULL) {
        str2Copy = (char *) xmlStrdup((const xmlChar *) str2);
        if (str2Copy == NULL)
            goto err_memory;
    }
    if (str3 != NULL) {
        str3Copy = (char *) xmlStrdup((const xmlChar *) str3);
        if (str3Copy == NULL)
            goto err_memory;
    }

    xmlResetError(err);

    err->domain = domain;
    err->code = code;
    err->message = message;
    err->level = level;
    err->file = fileCopy;
    err->line = line;
    err->str1 = str1Copy;
    err->str2 = str2Copy;
    err->str3 = str3Copy;
    err->int1 = int1;
    err->int2 = col;
    err->node = node;
    err->ctxt = ctxt;

    return(0);

err_memory:
    xmlFree(message);
    xmlFree(fileCopy);
    xmlFree(str1Copy);
    xmlFree(str2Copy);
    xmlFree(str3Copy);
    return(-1);
}

static int LIBXML_ATTR_FORMAT(14,15)
xmlSetError(xmlError *err,
            void *ctxt, xmlNodePtr node,
            int domain, int code, xmlErrorLevel level,
            const char *file, int line,
            const char *str1, const char *str2, const char *str3,
            int int1, int col,
            const char *fmt, ...)
{
    va_list ap;
    int res;

    va_start(ap, fmt);
    res = xmlVSetError(err, ctxt, node, domain, code, level, file, line,
                       str1, str2, str3, int1, col, fmt, ap);
    va_end(ap);

    return(res);
}

static int
xmlVUpdateError(xmlError *err,
                void *ctxt, xmlNodePtr node,
                int domain, int code, xmlErrorLevel level,
                const char *file, int line,
                const char *str1, const char *str2, const char *str3,
                int int1, int col,
                const char *fmt, va_list ap)
{
    int res;

    /*
     * Find first element parent.
     */
    if (node != NULL) {
        int i;

        for (i = 0; i < 10; i++) {
            if ((node->type == XML_ELEMENT_NODE) ||
                (node->parent == NULL))
                break;
            node = node->parent;
        }
    }

    /*
     * Get file and line from node.
     */
    if (node != NULL) {
        if ((file == NULL) && (node->doc != NULL))
            file = (const char *) node->doc->URL;

        if (line == 0) {
            if (node->type == XML_ELEMENT_NODE)
                line = node->line;
            if ((line == 0) || (line == 65535))
                line = xmlGetLineNo(node);
        }
    }

    res = xmlVSetError(err, ctxt, node, domain, code, level, file, line,
                       str1, str2, str3, int1, col, fmt, ap);

    return(res);
}

/************************************************************************
 *									*
 *			Handling of out of context errors		*
 *									*
 ************************************************************************/

/**
 * xmlGenericErrorDefaultFunc:
 * @ctx:  an error context
 * @msg:  the message to display/transmit
 * @...:  extra parameters for the message display
 *
 * Default handler for out of context error messages.
 */
void
xmlGenericErrorDefaultFunc(void *ctx ATTRIBUTE_UNUSED, const char *msg, ...) {
    va_list args;

    if (xmlGenericErrorContext == NULL)
	xmlGenericErrorContext = (void *) stderr;

    va_start(args, msg);
    vfprintf((FILE *)xmlGenericErrorContext, msg, args);
    va_end(args);
}

/**
 * initGenericErrorDefaultFunc:
 * @handler:  the handler
 *
 * DEPRECATED: Use xmlSetGenericErrorFunc.
 *
 * Set or reset (if NULL) the default handler for generic errors
 * to the builtin error function.
 */
void
initGenericErrorDefaultFunc(xmlGenericErrorFunc * handler)
{
    if (handler == NULL)
        xmlGenericError = xmlGenericErrorDefaultFunc;
    else
        xmlGenericError = (*handler);
}

/**
 * xmlSetGenericErrorFunc:
 * @ctx:  the new error handling context
 * @handler:  the new handler function
 *
 * DEPRECATED: See xmlSetStructuredErrorFunc for alternatives.
 *
 * Set the global "generic" handler and context for error messages.
 * The generic error handler will only receive fragments of error
 * messages which should be concatenated or printed to a stream.
 *
 * If handler is NULL, use the built-in default handler which prints
 * to stderr.
 *
 * Since this is a global setting, it's a good idea to reset the
 * error handler to its default value after collecting the errors
 * you're interested in.
 *
 * For multi-threaded applications, this must be set separately for
 * each thread.
 */
void
xmlSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
    xmlGenericErrorContext = ctx;
    if (handler != NULL)
	xmlGenericError = handler;
    else
	xmlGenericError = xmlGenericErrorDefaultFunc;
}

/**
 * xmlSetStructuredErrorFunc:
 * @ctx:  the new error handling context
 * @handler:  the new handler function
 *
 * DEPRECATED: Use a per-context error handler.
 *
 * It's recommended to use the per-context error handlers instead:
 *
 * - xmlCtxtSetErrorHandler (since 2.13.0)
 * - xmlTextReaderSetStructuredErrorHandler
 * - xmlXPathSetErrorHandler (since 2.13.0)
 * - xmlXIncludeSetErrorHandler (since 2.13.0)
 * - xmlSchemaSetParserStructuredErrors
 * - xmlSchemaSetValidStructuredErrors
 * - xmlRelaxNGSetParserStructuredErrors
 * - xmlRelaxNGSetValidStructuredErrors
 *
 * Set the global "structured" handler and context for error messages.
 * If handler is NULL, the error handler is deactivated.
 *
 * The structured error handler takes precedence over "generic"
 * handlers, even per-context generic handlers.
 *
 * Since this is a global setting, it's a good idea to deactivate the
 * error handler after collecting the errors you're interested in.
 *
 * For multi-threaded applications, this must be set separately for
 * each thread.
 */
void
xmlSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
    xmlStructuredErrorContext = ctx;
    xmlStructuredError = handler;
}

/************************************************************************
 *									*
 *			Handling of parsing errors			*
 *									*
 ************************************************************************/

/**
 * xmlParserPrintFileInfo:
 * @input:  an xmlParserInputPtr input
 *
 * DEPRECATED: Use xmlFormatError.
 *
 * Displays the associated file and line information for the current input
 */

void
xmlParserPrintFileInfo(xmlParserInputPtr input) {
    if (input != NULL) {
	if (input->filename)
	    xmlGenericError(xmlGenericErrorContext,
		    "%s:%d: ", input->filename,
		    input->line);
	else
	    xmlGenericError(xmlGenericErrorContext,
		    "Entity: line %d: ", input->line);
    }
}

/**
 * xmlParserPrintFileContextInternal:
 * @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, *start;
    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) || (input->cur == 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--;
        n++;
    }
    if ((n > 0) && ((*cur == '\n') || (*cur == '\r'))) {
        cur++;
    } else {
        /* skip over continuation bytes */
        while ((cur < input->cur) && ((*cur & 0xC0) == 0x80))
            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;
    start = cur;
    /* copy selected text to our buffer */
    while ((*cur != 0) && (*(cur) != '\n') && (*(cur) != '\r')) {
        int len = input->end - cur;
        int c = xmlGetUTF8Char(cur, &len);

        if ((c < 0) || (n + len > sizeof(content)-1))
            break;
        cur += len;
	n += len;
    }
    memcpy(content, start, n);
    content[n] = 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:
 * @input:  an xmlParserInputPtr input
 *
 * DEPRECATED: Use xmlFormatError.
 *
 * Displays current context within the input content for error tracking
 */
void
xmlParserPrintFileContext(xmlParserInputPtr input) {
   xmlParserPrintFileContextInternal(input, xmlGenericError,
                                     xmlGenericErrorContext);
}

/**
 * xmlFormatError:
 * @err:  the error
 * @channel:  callback
 * @data:  user data for callback
 *
 * Report a formatted error to a printf-like callback.
 *
 * This can result in a verbose multi-line report including additional
 * information from the parser context.
 *
 * Available since 2.13.0.
 */
void
xmlFormatError(const xmlError *err, xmlGenericErrorFunc channel, void *data)
{
    const char *message;
    const char *file;
    int line;
    int code;
    int domain;
    const xmlChar *name = NULL;
    xmlNodePtr node;
    xmlErrorLevel level;
    xmlParserCtxtPtr ctxt = NULL;
    xmlParserInputPtr input = NULL;
    xmlParserInputPtr cur = NULL;

    if ((err == NULL) || (channel == NULL))
        return;

    message = err->message;
    file = err->file;
    line = err->line;
    code = err->code;
    domain = err->domain;
    level = err->level;
    node = err->node;

    if (code == XML_ERR_OK)
        return;

    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
	(domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
	ctxt = err->ctxt;
    }

    if ((node != NULL) && (node->type == XML_ELEMENT_NODE) &&
        (domain != XML_FROM_SCHEMASV))
        name = node->name;

    /*
     * Maintain the compatibility with the legacy error handling
     */
    if ((ctxt != NULL) && (ctxt->input != NULL)) {
        input = ctxt->input;
        if ((input->filename == NULL) &&
            (ctxt->inputNr > 1)) {
            cur = input;
            input = ctxt->inputTab[ctxt->inputNr - 2];
        }
        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) || (domain == XML_FROM_SCHEMASV)||
		  (domain == XML_FROM_SCHEMASP)||(domain == XML_FROM_DTD) ||
		  (domain == XML_FROM_RELAXNGP)||(domain == XML_FROM_RELAXNGV)))
            channel(data, "Entity: line %d: ", line);
    }
    if (name != NULL) {
        channel(data, "element %s: ", name);
    }
    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_MODULE:
            channel(data, "module ");
            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;
        case XML_FROM_I18N:
            channel(data, "encoding ");
            break;
        case XML_FROM_SCHEMATRONV:
            channel(data, "schematron ");
            break;
        case XML_FROM_BUFFER:
            channel(data, "internal buffer ");
            break;
        case XML_FROM_URI:
            channel(data, "URI ");
            break;
        default:
            break;
    }
    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 (message != NULL) {
        int len;
	len = xmlStrlen((const xmlChar *) message);
	if ((len > 0) && (message[len - 1] != '\n'))
	    channel(data, "%s\n", message);
	else
	    channel(data, "%s", message);
    } else {
        channel(data, "%s\n", "No error message provided");
    }

    if (ctxt != NULL) {
        if ((input != NULL) &&
            ((input->buf == NULL) || (input->buf->encoder == NULL)) &&
            (code == XML_ERR_INVALID_ENCODING) &&
            (input->cur < input->end)) {
            int i;

            channel(data, "Bytes:");
            for (i = 0; i < 4; i++) {
                if (input->cur + i >= input->end)
                    break;
                channel(data, " 0x%02X", input->cur[i]);
            }
            channel(data, "\n");
        }

        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);
    }
}

/**
 * xmlRaiseMemoryError:
 * @schannel: the structured callback channel
 * @channel: the old callback channel
 * @data: the callback data
 * @domain: the domain for the error
 * @error: optional error struct to be filled
 *
 * Update the global and optional error structure, then forward the
 * error to an error handler.
 *
 * This function doesn't make memory allocations which are likely
 * to fail after an OOM error.
 */
void
xmlRaiseMemoryError(xmlStructuredErrorFunc schannel, xmlGenericErrorFunc channel,
                    void *data, int domain, xmlError *error)
{
    xmlError *lastError = xmlGetLastErrorInternal();

    xmlResetLastError();
    lastError->domain = domain;
    lastError->code = XML_ERR_NO_MEMORY;
    lastError->level = XML_ERR_FATAL;

    if (error != NULL) {
        xmlResetError(error);
        error->domain = domain;
        error->code = XML_ERR_NO_MEMORY;
        error->level = XML_ERR_FATAL;
    }

    if (schannel != NULL) {
        schannel(data, lastError);
    } else if (xmlStructuredError != NULL) {
        xmlStructuredError(xmlStructuredErrorContext, lastError);
    } else if (channel != NULL) {
        channel(data, "libxml2: out of memory\n");
    }
}

/**
 * xmlVRaiseError:
 * @schannel: the structured callback channel
 * @channel: the old callback channel
 * @data: the callback data
 * @ctx: the parser context or NULL
 * @node: the current node or NULL
 * @domain: the domain for the error
 * @code: the code for the error
 * @level: the xmlErrorLevel for the error
 * @file: the file source of the error (or NULL)
 * @line: the line of the error or 0 if N/A
 * @str1: extra string info
 * @str2: extra string info
 * @str3: extra string info
 * @int1: extra int info
 * @col: column number of the error or 0 if N/A
 * @msg:  the message to display/transmit
 * @ap:  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
 *
 * Returns 0 on success, -1 if a memory allocation failed.
 */
int
xmlVRaiseError(xmlStructuredErrorFunc schannel,
               xmlGenericErrorFunc channel, void *data, void *ctx,
               xmlNode *node, int domain, int code, xmlErrorLevel level,
               const char *file, int line, const char *str1,
               const char *str2, const char *str3, int int1, int col,
               const char *msg, va_list ap)
{
    xmlParserCtxtPtr ctxt = NULL;
    /* xmlLastError is a macro retrieving the per-thread global. */
    xmlErrorPtr lastError = xmlGetLastErrorInternal();
    xmlErrorPtr to = lastError;

    if (code == XML_ERR_OK)
        return(0);
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    if (code == XML_ERR_INTERNAL_ERROR)
        xmlAbort("Unexpected error: %d\n", code);
#endif
    if ((xmlGetWarningsDefaultValue == 0) && (level == XML_ERR_WARNING))
        return(0);

    if ((domain == XML_FROM_PARSER) || (domain == XML_FROM_HTML) ||
        (domain == XML_FROM_DTD) || (domain == XML_FROM_NAMESPACE) ||
	(domain == XML_FROM_IO) || (domain == XML_FROM_VALID)) {
	ctxt = (xmlParserCtxtPtr) ctx;

        if (ctxt != NULL)
            to = &ctxt->lastError;
    }

    if (xmlVUpdateError(to, ctxt, node, domain, code, level, file, line,
                        str1, str2, str3, int1, col, msg, ap))
        return(-1);

    if (to != lastError) {
        if (xmlCopyError(to, lastError) < 0)
            return(-1);
    }

    if (schannel != NULL) {
	schannel(data, to);
    } else if (xmlStructuredError != NULL) {
        xmlStructuredError(xmlStructuredErrorContext, to);
    } else if (channel != NULL) {
        /* Don't invoke legacy error handlers */
        if ((channel == xmlGenericErrorDefaultFunc) ||
            (channel == xmlParserError) ||
            (channel == xmlParserWarning) ||
            (channel == xmlParserValidityError) ||
            (channel == xmlParserValidityWarning))
            xmlFormatError(to, xmlGenericError, xmlGenericErrorContext);
        else
	    channel(data, "%s", to->message);
    }

    return(0);
}

/**
 * xmlRaiseError:
 * @schannel: the structured callback channel
 * @channel: the old callback channel
 * @data: the callback data
 * @ctx: the parser context or NULL
 * @nod: the node or NULL
 * @domain: the domain for the error
 * @code: the code for the error
 * @level: the xmlErrorLevel for the error
 * @file: the file source of the error (or NULL)
 * @line: the line of the error or 0 if N/A
 * @str1: extra string info
 * @str2: extra string info
 * @str3: extra string info
 * @int1: extra int info
 * @col: column number of the error or 0 if N/A
 * @msg:  the message to display/transmit
 * @...:  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
 *
 * Returns 0 on success, -1 if a memory allocation failed.
 */
int
xmlRaiseError(xmlStructuredErrorFunc schannel,
              xmlGenericErrorFunc channel, void *data, void *ctx,
              xmlNode *node, int domain, int code, xmlErrorLevel level,
              const char *file, int line, const char *str1,
              const char *str2, const char *str3, int int1, int col,
              const char *msg, ...)
{
    va_list ap;
    int res;

    va_start(ap, msg);
    res = xmlVRaiseError(schannel, channel, data, ctx, node, domain, code,
                         level, file, line, str1, str2, str3, int1, col, msg,
                         ap);
    va_end(ap);

    return(res);
}

static void
xmlVFormatLegacyError(void *ctx, const char *level,
                      const char *fmt, va_list ap) {
    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
    xmlParserInputPtr input = NULL;
    xmlParserInputPtr cur = NULL;
    xmlChar *str = NULL;

    if (ctxt != NULL) {
	input = ctxt->input;
	if ((input != NULL) && (input->filename == NULL) &&
	    (ctxt->inputNr > 1)) {
	    cur = input;
	    input = ctxt->inputTab[ctxt->inputNr - 2];
	}
	xmlParserPrintFileInfo(input);
    }

    xmlGenericError(xmlGenericErrorContext, "%s: ", level);

    xmlStrVASPrintf(&str, MAX_ERR_MSG_SIZE, fmt, ap);
    if (str != NULL) {
        xmlGenericError(xmlGenericErrorContext, "%s", (char *) str);
	xmlFree(str);
    }

    if (ctxt != NULL) {
	xmlParserPrintFileContext(input);
	if (cur != NULL) {
	    xmlParserPrintFileInfo(cur);
	    xmlGenericError(xmlGenericErrorContext, "\n");
	    xmlParserPrintFileContext(cur);
	}
    }
}

/**
 * xmlParserError:
 * @ctx:  an XML parser context
 * @msg:  the message to display/transmit
 * @...:  extra parameters for the message display
 *
 * Display and format an error messages, gives file, line, position and
 * extra parameters.
 */
void
xmlParserError(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
{
    va_list ap;

    va_start(ap, msg);
    xmlVFormatLegacyError(ctx, "error", msg, ap);
    va_end(ap);
}

/**
 * xmlParserWarning:
 * @ctx:  an XML parser context
 * @msg:  the message to display/transmit
 * @...:  extra parameters for the message display
 *
 * Display and format a warning messages, gives file, line, position and
 * extra parameters.
 */
void
xmlParserWarning(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
{
    va_list ap;

    va_start(ap, msg);
    xmlVFormatLegacyError(ctx, "warning", msg, ap);
    va_end(ap);
}

/**
 * xmlParserValidityError:
 * @ctx:  an XML parser context
 * @msg:  the message to display/transmit
 * @...:  extra parameters for the message display
 *
 * Display and format an validity error messages, gives file,
 * line, position and extra parameters.
 */
void
xmlParserValidityError(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
{
    va_list ap;

    va_start(ap, msg);
    xmlVFormatLegacyError(ctx, "validity error", msg, ap);
    va_end(ap);
}

/**
 * xmlParserValidityWarning:
 * @ctx:  an XML parser context
 * @msg:  the message to display/transmit
 * @...:  extra parameters for the message display
 *
 * Display and format a validity warning messages, gives file, line,
 * position and extra parameters.
 */
void
xmlParserValidityWarning(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
{
    va_list ap;

    va_start(ap, msg);
    xmlVFormatLegacyError(ctx, "validity warning", msg, ap);
    va_end(ap);
}


/************************************************************************
 *									*
 *			Extended Error Handling				*
 *									*
 ************************************************************************/

/**
 * xmlGetLastError:
 *
 * Get the last global error registered. This is per thread if compiled
 * with thread support.
 *
 * Returns a pointer to the error
 */
const xmlError *
xmlGetLastError(void)
{
    const xmlError *error = xmlGetLastErrorInternal();

    if (error->code == XML_ERR_OK)
        return(NULL);
    return(error);
}

/**
 * xmlResetError:
 * @err: pointer to the error.
 *
 * Cleanup the error.
 */
void
xmlResetError(xmlErrorPtr err)
{
    if (err == NULL)
        return;
    if (err->code == XML_ERR_OK)
        return;
    if (err->message != NULL)
        xmlFree(err->message);
    if (err->file != NULL)
        xmlFree(err->file);
    if (err->str1 != NULL)
        xmlFree(err->str1);
    if (err->str2 != NULL)
        xmlFree(err->str2);
    if (err->str3 != NULL)
        xmlFree(err->str3);
    memset(err, 0, sizeof(xmlError));
    err->code = XML_ERR_OK;
}

/**
 * xmlResetLastError:
 *
 * Cleanup the last global error registered. For parsing error
 * this does not change the well-formedness result.
 */
void
xmlResetLastError(void)
{
    xmlError *error = xmlGetLastErrorInternal();

    if (error->code != XML_ERR_OK)
        xmlResetError(error);
}

/**
 * xmlCopyError:
 * @from:  a source error
 * @to:  a target error
 *
 * Save the original error to the new place.
 *
 * Returns 0 in case of success and -1 in case of error.
 */
int
xmlCopyError(const xmlError *from, xmlErrorPtr to) {
    const char *fmt = NULL;

    if ((from == NULL) || (to == NULL))
        return(-1);

    if (from->message != NULL)
        fmt = "%s";

    return(xmlSetError(to, from->ctxt, from->node,
                       from->domain, from->code, from->level,
                       from->file, from->line,
                       from->str1, from->str2, from->str3,
                       from->int1, from->int2,
                       fmt, from->message));
}

/**
 * xmlErrString:
 * @code:  an xmlParserErrors code
 *
 * Returns an error message for a code.
 */
const char *
xmlErrString(xmlParserErrors code) {
    const char *errmsg;

    switch (code) {
        case XML_ERR_INVALID_HEX_CHARREF:
            errmsg = "CharRef: invalid hexadecimal value";
            break;
        case XML_ERR_INVALID_DEC_CHARREF:
            errmsg = "CharRef: invalid decimal value";
            break;
        case XML_ERR_INVALID_CHARREF:
            errmsg = "CharRef: invalid value";
            break;
        case XML_ERR_INTERNAL_ERROR:
            errmsg = "internal error";
            break;
        case XML_ERR_PEREF_AT_EOF:
            errmsg = "PEReference at end of document";
            break;
        case XML_ERR_PEREF_IN_PROLOG:
            errmsg = "PEReference in prolog";
            break;
        case XML_ERR_PEREF_IN_EPILOG:
            errmsg = "PEReference in epilog";
            break;
        case XML_ERR_PEREF_NO_NAME:
            errmsg = "PEReference: no name";
            break;
        case XML_ERR_PEREF_SEMICOL_MISSING:
            errmsg = "PEReference: expecting ';'";
            break;
        case XML_ERR_ENTITY_LOOP:
            errmsg = "Detected an entity reference loop";
            break;
        case XML_ERR_ENTITY_NOT_STARTED:
            errmsg = "EntityValue: \" or ' expected";
            break;
        case XML_ERR_ENTITY_PE_INTERNAL:
            errmsg = "PEReferences forbidden in internal subset";
            break;
        case XML_ERR_ENTITY_NOT_FINISHED:
            errmsg = "EntityValue: \" or ' expected";
            break;
        case XML_ERR_ATTRIBUTE_NOT_STARTED:
            errmsg = "AttValue: \" or ' expected";
            break;
        case XML_ERR_LT_IN_ATTRIBUTE:
            errmsg = "Unescaped '<' not allowed in attributes values";
            break;
        case XML_ERR_LITERAL_NOT_STARTED:
            errmsg = "SystemLiteral \" or ' expected";
            break;
        case XML_ERR_LITERAL_NOT_FINISHED:
            errmsg = "Unfinished System or Public ID \" or ' expected";
            break;
        case XML_ERR_MISPLACED_CDATA_END:
            errmsg = "Sequence ']]>' not allowed in content";
            break;
        case XML_ERR_URI_REQUIRED:
            errmsg = "SYSTEM or PUBLIC, the URI is missing";
            break;
        case XML_ERR_PUBID_REQUIRED:
            errmsg = "PUBLIC, the Public Identifier is missing";
            break;
        case XML_ERR_HYPHEN_IN_COMMENT:
            errmsg = "Comment must not contain '--' (double-hyphen)";
            break;
        case XML_ERR_PI_NOT_STARTED:
            errmsg = "xmlParsePI : no target name";
            break;
        case XML_ERR_RESERVED_XML_NAME:
            errmsg = "Invalid PI name";
            break;
        case XML_ERR_NOTATION_NOT_STARTED:
            errmsg = "NOTATION: Name expected here";
            break;
        case XML_ERR_NOTATION_NOT_FINISHED:
            errmsg = "'>' required to close NOTATION declaration";
            break;
        case XML_ERR_VALUE_REQUIRED:
            errmsg = "Entity value required";
            break;
        case XML_ERR_URI_FRAGMENT:
            errmsg = "Fragment not allowed";
            break;
        case XML_ERR_ATTLIST_NOT_STARTED:
            errmsg = "'(' required to start ATTLIST enumeration";
            break;
        case XML_ERR_NMTOKEN_REQUIRED:
            errmsg = "NmToken expected in ATTLIST enumeration";
            break;
        case XML_ERR_ATTLIST_NOT_FINISHED:
            errmsg = "')' required to finish ATTLIST enumeration";
            break;
        case XML_ERR_MIXED_NOT_STARTED:
            errmsg = "MixedContentDecl : '|' or ')*' expected";
            break;
        case XML_ERR_PCDATA_REQUIRED:
            errmsg = "MixedContentDecl : '#PCDATA' expected";
            break;
        case XML_ERR_ELEMCONTENT_NOT_STARTED:
            errmsg = "ContentDecl : Name or '(' expected";
            break;
        case XML_ERR_ELEMCONTENT_NOT_FINISHED:
            errmsg = "ContentDecl : ',' '|' or ')' expected";
            break;
        case XML_ERR_PEREF_IN_INT_SUBSET:
            errmsg =
                "PEReference: forbidden within markup decl in internal subset";
            break;
        case XML_ERR_GT_REQUIRED:
            errmsg = "expected '>'";
            break;
        case XML_ERR_CONDSEC_INVALID:
            errmsg = "XML conditional section '[' expected";
            break;
        case XML_ERR_INT_SUBSET_NOT_FINISHED:
            errmsg = "Content error in the internal subset";
            break;
        case XML_ERR_EXT_SUBSET_NOT_FINISHED:
            errmsg = "Content error in the external subset";
            break;
        case XML_ERR_CONDSEC_INVALID_KEYWORD:
            errmsg =
                "conditional section INCLUDE or IGNORE keyword expected";
            break;
        case XML_ERR_CONDSEC_NOT_FINISHED:
            errmsg = "XML conditional section not closed";
            break;
        case XML_ERR_XMLDECL_NOT_STARTED:
            errmsg = "Text declaration '<?xml' required";
            break;
        case XML_ERR_XMLDECL_NOT_FINISHED:
            errmsg = "parsing XML declaration: '?>' expected";
            break;
        case XML_ERR_EXT_ENTITY_STANDALONE:
            errmsg = "external parsed entities cannot be standalone";
            break;
        case XML_ERR_ENTITYREF_SEMICOL_MISSING:
            errmsg = "EntityRef: expecting ';'";
            break;
        case XML_ERR_DOCTYPE_NOT_FINISHED:
            errmsg = "DOCTYPE improperly terminated";
            break;
        case XML_ERR_LTSLASH_REQUIRED:
            errmsg = "EndTag: '</' not found";
            break;
        case XML_ERR_EQUAL_REQUIRED:
            errmsg = "expected '='";
            break;
        case XML_ERR_STRING_NOT_CLOSED:
            errmsg = "String not closed expecting \" or '";
            break;
        case XML_ERR_STRING_NOT_STARTED:
            errmsg = "String not started expecting ' or \"";
            break;
        case XML_ERR_ENCODING_NAME:
            errmsg = "Invalid XML encoding name";
            break;
        case XML_ERR_STANDALONE_VALUE:
            errmsg = "standalone accepts only 'yes' or 'no'";
            break;
        case XML_ERR_DOCUMENT_EMPTY:
            errmsg = "Document is empty";
            break;
        case XML_ERR_DOCUMENT_END:
            errmsg = "Extra content at the end of the document";
            break;
        case XML_ERR_NOT_WELL_BALANCED:
            errmsg = "chunk is not well balanced";
            break;
        case XML_ERR_EXTRA_CONTENT:
            errmsg = "extra content at the end of well balanced chunk";
            break;
        case XML_ERR_VERSION_MISSING:
            errmsg = "Malformed declaration expecting version";
            break;
        case XML_ERR_NAME_TOO_LONG:
            errmsg = "Name too long";
            break;
        case XML_ERR_INVALID_ENCODING:
            errmsg = "Invalid bytes in character encoding";
            break;
        case XML_ERR_RESOURCE_LIMIT:
            errmsg = "Resource limit exceeded";
            break;
        case XML_ERR_ARGUMENT:
            errmsg = "Invalid argument";
            break;
        case XML_ERR_SYSTEM:
            errmsg = "Out of system resources";
            break;
        case XML_ERR_REDECL_PREDEF_ENTITY:
            errmsg = "Invalid redeclaration of predefined entity";
            break;
        case XML_ERR_UNSUPPORTED_ENCODING:
            errmsg = "Unsupported encoding";
            break;
        case XML_ERR_INVALID_CHAR:
            errmsg = "Invalid character";
            break;

        case XML_IO_UNKNOWN:
            errmsg = "Unknown IO error"; break;
        case XML_IO_EACCES:
            errmsg = "Permission denied"; break;
        case XML_IO_EAGAIN:
            errmsg = "Resource temporarily unavailable"; break;
        case XML_IO_EBADF:
            errmsg = "Bad file descriptor"; break;
        case XML_IO_EBADMSG:
            errmsg = "Bad message"; break;
        case XML_IO_EBUSY:
            errmsg = "Resource busy"; break;
        case XML_IO_ECANCELED:
            errmsg = "Operation canceled"; break;
        case XML_IO_ECHILD:
            errmsg = "No child processes"; break;
        case XML_IO_EDEADLK:
            errmsg = "Resource deadlock avoided"; break;
        case XML_IO_EDOM:
            errmsg = "Domain error"; break;
        case XML_IO_EEXIST:
            errmsg = "File exists"; break;
        case XML_IO_EFAULT:
            errmsg = "Bad address"; break;
        case XML_IO_EFBIG:
            errmsg = "File too large"; break;
        case XML_IO_EINPROGRESS:
            errmsg = "Operation in progress"; break;
        case XML_IO_EINTR:
            errmsg = "Interrupted function call"; break;
        case XML_IO_EINVAL:
            errmsg = "Invalid argument"; break;
        case XML_IO_EIO:
            errmsg = "Input/output error"; break;
        case XML_IO_EISDIR:
            errmsg = "Is a directory"; break;
        case XML_IO_EMFILE:
            errmsg = "Too many open files"; break;
        case XML_IO_EMLINK:
            errmsg = "Too many links"; break;
        case XML_IO_EMSGSIZE:
            errmsg = "Inappropriate message buffer length"; break;
        case XML_IO_ENAMETOOLONG:
            errmsg = "Filename too long"; break;
        case XML_IO_ENFILE:
            errmsg = "Too many open files in system"; break;
        case XML_IO_ENODEV:
            errmsg = "No such device"; break;
        case XML_IO_ENOENT:
            errmsg = "No such file or directory"; break;
        case XML_IO_ENOEXEC:
            errmsg = "Exec format error"; break;
        case XML_IO_ENOLCK:
            errmsg = "No locks available"; break;
        case XML_IO_ENOMEM:
            errmsg = "Not enough space"; break;
        case XML_IO_ENOSPC:
            errmsg = "No space left on device"; break;
        case XML_IO_ENOSYS:
            errmsg = "Function not implemented"; break;
        case XML_IO_ENOTDIR:
            errmsg = "Not a directory"; break;
        case XML_IO_ENOTEMPTY:
            errmsg = "Directory not empty"; break;
        case XML_IO_ENOTSUP:
            errmsg = "Not supported"; break;
        case XML_IO_ENOTTY:
            errmsg = "Inappropriate I/O control operation"; break;
        case XML_IO_ENXIO:
            errmsg = "No such device or address"; break;
        case XML_IO_EPERM:
            errmsg = "Operation not permitted"; break;
        case XML_IO_EPIPE:
            errmsg = "Broken pipe"; break;
        case XML_IO_ERANGE:
            errmsg = "Result too large"; break;
        case XML_IO_EROFS:
            errmsg = "Read-only file system"; break;
        case XML_IO_ESPIPE:
            errmsg = "Invalid seek"; break;
        case XML_IO_ESRCH:
            errmsg = "No such process"; break;
        case XML_IO_ETIMEDOUT:
            errmsg = "Operation timed out"; break;
        case XML_IO_EXDEV:
            errmsg = "Improper link"; break;
        case XML_IO_NETWORK_ATTEMPT:
            errmsg = "Attempt to load network entity"; break;
        case XML_IO_ENCODER:
            errmsg = "encoder error"; break;
        case XML_IO_FLUSH:
            errmsg = "flush error"; break;
        case XML_IO_WRITE:
            errmsg = "write error"; break;
        case XML_IO_NO_INPUT:
            errmsg = "no input"; break;
        case XML_IO_BUFFER_FULL:
            errmsg = "buffer full"; break;
        case XML_IO_LOAD_ERROR:
            errmsg = "loading error"; break;
        case XML_IO_ENOTSOCK:
            errmsg = "not a socket"; break;
        case XML_IO_EISCONN:
            errmsg = "already connected"; break;
        case XML_IO_ECONNREFUSED:
            errmsg = "connection refused"; break;
        case XML_IO_ENETUNREACH:
            errmsg = "unreachable network"; break;
        case XML_IO_EADDRINUSE:
            errmsg = "address in use"; break;
        case XML_IO_EALREADY:
            errmsg = "already in use"; break;
        case XML_IO_EAFNOSUPPORT:
            errmsg = "unknown address family"; break;
        case XML_IO_UNSUPPORTED_PROTOCOL:
            errmsg = "unsupported protocol"; break;

        default:
            errmsg = "Unregistered error message";
    }

    return(errmsg);
}

void
xmlVPrintErrorMessage(const char *fmt, va_list ap) {
    vfprintf(stderr, fmt, ap);
}

void
xmlPrintErrorMessage(const char *fmt, ...) {
    va_list ap;

    va_start(ap, fmt);
    xmlVPrintErrorMessage(fmt, ap);
    va_end(ap);
}

void
xmlAbort(const char *fmt, ...) {
    va_list ap;

    va_start(ap, fmt);
    xmlVPrintErrorMessage(fmt, ap);
    va_end(ap);

    abort();
}