mirror of
https://gitlab.gnome.org/GNOME/libxml2
synced 2025-03-28 21:33:13 +00:00
error: Refactor error reporting
Introduce xmlStrVASPrintf, trying to handle buggy snprintf implementations. Introduce xmlSetError to set errors atomically. Introduce xmlUpdateError to set an error, fixing up node, file and line. Introduce helper function xmlRaiseMemoryError. Make legacy error handlers call xmlReportError, avoiding checks in xmlVRaiseError. Remove fragile support for getting file and line info from XInclude nodes.
This commit is contained in:
Nick Wellnhofer
parent
ed3ad3e173
commit
c5a8aef2f6
644
error.c
644
error.c
@ -16,62 +16,163 @@
|
||||
#include <libxml/xmlmemory.h>
|
||||
|
||||
#include "private/error.h"
|
||||
#include "private/string.h"
|
||||
|
||||
#ifndef va_copy
|
||||
#ifdef __va_copy
|
||||
#define va_copy(dest, src) __va_copy(dest, src)
|
||||
#else
|
||||
#define va_copy(dest, src) memcpy(dest, src, sizeof(va_list))
|
||||
#endif
|
||||
#endif
|
||||
/************************************************************************
|
||||
* *
|
||||
* Error struct *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
#define XML_GET_VAR_STR(msg, str) \
|
||||
do { \
|
||||
va_list ap; \
|
||||
va_start(ap, msg); \
|
||||
str = xmlVsnprintf(msg, ap); \
|
||||
va_end(ap); \
|
||||
} while (0);
|
||||
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;
|
||||
|
||||
static char *
|
||||
xmlVsnprintf(const char *msg, va_list ap) {
|
||||
int size, prev_size = -1;
|
||||
int chars;
|
||||
char *larger;
|
||||
char *str;
|
||||
if (code == XML_ERR_OK) {
|
||||
xmlResetError(err);
|
||||
return(0);
|
||||
}
|
||||
|
||||
str = (char *) xmlMalloc(150);
|
||||
if (str == NULL)
|
||||
return(NULL);
|
||||
|
||||
size = 150;
|
||||
|
||||
while (size < 64000) {
|
||||
va_list copy;
|
||||
|
||||
va_copy(copy, ap);
|
||||
chars = vsnprintf(str, size, msg, copy);
|
||||
va_end(copy);
|
||||
if ((chars > -1) && (chars < size)) {
|
||||
if (prev_size == chars) {
|
||||
break;
|
||||
/*
|
||||
* Formatting the message
|
||||
*/
|
||||
if (fmt == NULL) {
|
||||
message = xmlMemStrdup("No error message provided");
|
||||
} else {
|
||||
prev_size = chars;
|
||||
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 (chars > -1)
|
||||
size += chars + 1;
|
||||
else
|
||||
size += 100;
|
||||
larger = (char *) xmlRealloc(str, size);
|
||||
if (larger == NULL) {
|
||||
xmlFree(str);
|
||||
return(NULL);
|
||||
if (str1 != NULL) {
|
||||
str1Copy = (char *) xmlStrdup((const xmlChar *) str1);
|
||||
if (str1Copy == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
str = larger;
|
||||
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;
|
||||
}
|
||||
|
||||
return(str);
|
||||
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);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
@ -278,12 +379,14 @@ xmlParserPrintFileContext(xmlParserInputPtr input) {
|
||||
* routines.
|
||||
*/
|
||||
static void
|
||||
xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
|
||||
xmlGenericErrorFunc channel, void *data)
|
||||
xmlReportError(xmlParserCtxtPtr ctxt, const xmlError *err)
|
||||
{
|
||||
char *file = NULL;
|
||||
int line = 0;
|
||||
int code = -1;
|
||||
xmlGenericErrorFunc channel;
|
||||
void *data;
|
||||
const char *message;
|
||||
const char *file;
|
||||
int line;
|
||||
int code;
|
||||
int domain;
|
||||
const xmlChar *name = NULL;
|
||||
xmlNodePtr node;
|
||||
@ -291,13 +394,16 @@ xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
|
||||
xmlParserInputPtr input = NULL;
|
||||
xmlParserInputPtr cur = NULL;
|
||||
|
||||
if (err == NULL)
|
||||
if (err == NULL) {
|
||||
if (ctxt == NULL)
|
||||
return;
|
||||
err = &ctxt->lastError;
|
||||
}
|
||||
|
||||
if (channel == NULL) {
|
||||
channel = xmlGenericError;
|
||||
data = xmlGenericErrorContext;
|
||||
}
|
||||
|
||||
message = err->message;
|
||||
file = err->file;
|
||||
line = err->line;
|
||||
code = err->code;
|
||||
@ -425,15 +531,15 @@ xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
|
||||
channel(data, "error : ");
|
||||
break;
|
||||
}
|
||||
if (str != NULL) {
|
||||
if (message != NULL) {
|
||||
int len;
|
||||
len = xmlStrlen((const xmlChar *)str);
|
||||
if ((len > 0) && (str[len - 1] != '\n'))
|
||||
channel(data, "%s\n", str);
|
||||
len = xmlStrlen((const xmlChar *) message);
|
||||
if ((len > 0) && (message[len - 1] != '\n'))
|
||||
channel(data, "%s\n", message);
|
||||
else
|
||||
channel(data, "%s", str);
|
||||
channel(data, "%s", message);
|
||||
} else {
|
||||
channel(data, "%s\n", "out of memory error");
|
||||
channel(data, "%s\n", "No error message provided");
|
||||
}
|
||||
|
||||
if (ctxt != NULL) {
|
||||
@ -461,6 +567,47 @@ xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 = &xmlLastError;
|
||||
|
||||
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
|
||||
@ -490,197 +637,50 @@ xmlReportError(xmlErrorPtr err, xmlParserCtxtPtr ctxt, const char *str,
|
||||
int
|
||||
xmlVRaiseError(xmlStructuredErrorFunc schannel,
|
||||
xmlGenericErrorFunc channel, void *data, void *ctx,
|
||||
void *nod, int domain, int code, xmlErrorLevel level,
|
||||
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;
|
||||
xmlNodePtr node = (xmlNodePtr) nod;
|
||||
char *str = NULL;
|
||||
/* xmlLastError is a macro retrieving the per-thread global. */
|
||||
xmlErrorPtr lastError = &xmlLastError;
|
||||
xmlErrorPtr to = lastError;
|
||||
xmlNodePtr baseptr = NULL;
|
||||
|
||||
if (code == XML_ERR_OK)
|
||||
return(0);
|
||||
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;
|
||||
}
|
||||
/*
|
||||
* Check if structured error handler set
|
||||
*/
|
||||
if (schannel == NULL) {
|
||||
schannel = xmlStructuredError;
|
||||
/*
|
||||
* if user has defined handler, change data ptr to user's choice
|
||||
*/
|
||||
if (schannel != NULL)
|
||||
data = xmlStructuredErrorContext;
|
||||
}
|
||||
/*
|
||||
* Formatting the message
|
||||
*/
|
||||
if (msg == NULL) {
|
||||
str = (char *) xmlStrdup(BAD_CAST "No error message provided");
|
||||
} else {
|
||||
str = xmlVsnprintf(msg, ap);
|
||||
}
|
||||
if (str == NULL)
|
||||
goto err_memory;
|
||||
|
||||
/*
|
||||
* specific processing if a parser context is provided
|
||||
*/
|
||||
if (ctxt != NULL)
|
||||
to = &ctxt->lastError;
|
||||
|
||||
if ((node != NULL) && (file == NULL)) {
|
||||
int i;
|
||||
|
||||
if ((node->doc != NULL) && (node->doc->URL != NULL)) {
|
||||
baseptr = node;
|
||||
/* file = (const char *) node->doc->URL; */
|
||||
}
|
||||
for (i = 0;
|
||||
((i < 10) && (node != NULL) && (node->type != XML_ELEMENT_NODE));
|
||||
i++)
|
||||
node = node->parent;
|
||||
if ((baseptr == NULL) && (node != NULL) &&
|
||||
(node->doc != NULL) && (node->doc->URL != NULL))
|
||||
baseptr = node;
|
||||
|
||||
if ((node != NULL) && (node->type == XML_ELEMENT_NODE))
|
||||
line = node->line;
|
||||
if ((line == 0) || (line == 65535))
|
||||
line = xmlGetLineNo(node);
|
||||
}
|
||||
|
||||
/*
|
||||
* Save the information about the error
|
||||
*/
|
||||
xmlResetError(to);
|
||||
to->domain = domain;
|
||||
to->code = code;
|
||||
to->message = str;
|
||||
to->level = level;
|
||||
if (file != NULL) {
|
||||
to->file = (char *) xmlStrdup((const xmlChar *) file);
|
||||
if (to->file == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
else if (baseptr != NULL) {
|
||||
#ifdef LIBXML_XINCLUDE_ENABLED
|
||||
/*
|
||||
* We check if the error is within an XInclude section and,
|
||||
* if so, attempt to print out the href of the XInclude instead
|
||||
* of the usual "base" (doc->URL) for the node (bug 152623).
|
||||
*/
|
||||
xmlNodePtr prev = baseptr;
|
||||
xmlChar *href = NULL;
|
||||
int inclcount = 0;
|
||||
while (prev != NULL) {
|
||||
if (prev->prev == NULL)
|
||||
prev = prev->parent;
|
||||
else {
|
||||
prev = prev->prev;
|
||||
if (prev->type == XML_XINCLUDE_START) {
|
||||
if (inclcount > 0) {
|
||||
--inclcount;
|
||||
} else {
|
||||
if (xmlNodeGetAttrValue(prev, BAD_CAST "href", NULL,
|
||||
&href) < 0)
|
||||
goto err_memory;
|
||||
if (href != NULL)
|
||||
break;
|
||||
}
|
||||
} else if (prev->type == XML_XINCLUDE_END)
|
||||
inclcount++;
|
||||
}
|
||||
}
|
||||
if (href != NULL) {
|
||||
to->file = (char *) href;
|
||||
} else
|
||||
#endif
|
||||
if (baseptr->doc->URL != NULL) {
|
||||
to->file = (char *) xmlStrdup(baseptr->doc->URL);
|
||||
if (to->file == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
}
|
||||
to->line = line;
|
||||
if (str1 != NULL) {
|
||||
to->str1 = (char *) xmlStrdup((const xmlChar *) str1);
|
||||
if (to->str1 == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (str2 != NULL) {
|
||||
to->str2 = (char *) xmlStrdup((const xmlChar *) str2);
|
||||
if (to->str2 == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (str3 != NULL) {
|
||||
to->str3 = (char *) xmlStrdup((const xmlChar *) str3);
|
||||
if (to->str3 == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
to->int1 = int1;
|
||||
to->int2 = col;
|
||||
to->node = node;
|
||||
to->ctxt = ctx;
|
||||
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)
|
||||
goto err_memory;
|
||||
return(-1);
|
||||
}
|
||||
|
||||
if (schannel != NULL) {
|
||||
schannel(data, to);
|
||||
return(0);
|
||||
} else if (xmlStructuredError != NULL) {
|
||||
xmlStructuredError(xmlStructuredErrorContext, to);
|
||||
} else if ((ctxt == NULL) && (channel == NULL)) {
|
||||
xmlGenericError(xmlGenericErrorContext, "%s", to->message);
|
||||
} else if (channel != NULL) {
|
||||
channel(data, "%s", to->message);
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the callback channel if channel param is NULL
|
||||
*/
|
||||
if ((ctxt == NULL) && (channel == NULL)) {
|
||||
channel = xmlGenericError;
|
||||
data = xmlGenericErrorContext;
|
||||
}
|
||||
if (channel == NULL)
|
||||
return(0);
|
||||
|
||||
if ((channel == xmlParserError) ||
|
||||
(channel == xmlParserWarning) ||
|
||||
(channel == xmlParserValidityError) ||
|
||||
(channel == xmlParserValidityWarning))
|
||||
xmlReportError(to, ctxt, str, NULL, NULL);
|
||||
else if (((void(*)(void)) channel == (void(*)(void)) fprintf) ||
|
||||
(channel == xmlGenericErrorDefaultFunc))
|
||||
xmlReportError(to, ctxt, str, channel, data);
|
||||
else
|
||||
channel(data, "%s", str);
|
||||
|
||||
return(0);
|
||||
|
||||
err_memory:
|
||||
xmlResetError(to);
|
||||
to->domain = domain;
|
||||
to->code = XML_ERR_NO_MEMORY;
|
||||
to->level = XML_ERR_FATAL;
|
||||
|
||||
if (to != lastError) {
|
||||
xmlResetError(lastError);
|
||||
lastError->domain = domain;
|
||||
lastError->code = XML_ERR_NO_MEMORY;
|
||||
lastError->level = XML_ERR_FATAL;
|
||||
}
|
||||
|
||||
return(-1);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -712,7 +712,7 @@ err_memory:
|
||||
int
|
||||
__xmlRaiseError(xmlStructuredErrorFunc schannel,
|
||||
xmlGenericErrorFunc channel, void *data, void *ctx,
|
||||
void *nod, int domain, int code, xmlErrorLevel level,
|
||||
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, ...)
|
||||
@ -721,7 +721,7 @@ __xmlRaiseError(xmlStructuredErrorFunc schannel,
|
||||
int res;
|
||||
|
||||
va_start(ap, msg);
|
||||
res = xmlVRaiseError(schannel, channel, data, ctx, nod, domain, code,
|
||||
res = xmlVRaiseError(schannel, channel, data, ctx, node, domain, code,
|
||||
level, file, line, str1, str2, str3, int1, col, msg,
|
||||
ap);
|
||||
va_end(ap);
|
||||
@ -769,37 +769,9 @@ __xmlSimpleError(int domain, int code, xmlNodePtr node,
|
||||
* extra parameters.
|
||||
*/
|
||||
void
|
||||
xmlParserError(void *ctx, const char *msg, ...)
|
||||
xmlParserError(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
|
||||
{
|
||||
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||||
xmlParserInputPtr input = NULL;
|
||||
xmlParserInputPtr cur = NULL;
|
||||
char * str;
|
||||
|
||||
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, "error: ");
|
||||
XML_GET_VAR_STR(msg, str);
|
||||
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||||
if (str != NULL)
|
||||
xmlFree(str);
|
||||
|
||||
if (ctxt != NULL) {
|
||||
xmlParserPrintFileContext(input);
|
||||
if (cur != NULL) {
|
||||
xmlParserPrintFileInfo(cur);
|
||||
xmlGenericError(xmlGenericErrorContext, "\n");
|
||||
xmlParserPrintFileContext(cur);
|
||||
}
|
||||
}
|
||||
xmlReportError(ctx, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -812,45 +784,11 @@ xmlParserError(void *ctx, const char *msg, ...)
|
||||
* extra parameters.
|
||||
*/
|
||||
void
|
||||
xmlParserWarning(void *ctx, const char *msg, ...)
|
||||
xmlParserWarning(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
|
||||
{
|
||||
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||||
xmlParserInputPtr input = NULL;
|
||||
xmlParserInputPtr cur = NULL;
|
||||
char * str;
|
||||
|
||||
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, "warning: ");
|
||||
XML_GET_VAR_STR(msg, str);
|
||||
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||||
if (str != NULL)
|
||||
xmlFree(str);
|
||||
|
||||
if (ctxt != NULL) {
|
||||
xmlParserPrintFileContext(input);
|
||||
if (cur != NULL) {
|
||||
xmlParserPrintFileInfo(cur);
|
||||
xmlGenericError(xmlGenericErrorContext, "\n");
|
||||
xmlParserPrintFileContext(cur);
|
||||
}
|
||||
}
|
||||
xmlReportError(ctx, NULL);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Handling of validation errors *
|
||||
* *
|
||||
************************************************************************/
|
||||
|
||||
/**
|
||||
* xmlParserValidityError:
|
||||
* @ctx: an XML parser context
|
||||
@ -861,38 +799,9 @@ xmlParserWarning(void *ctx, const char *msg, ...)
|
||||
* line, position and extra parameters.
|
||||
*/
|
||||
void
|
||||
xmlParserValidityError(void *ctx, const char *msg, ...)
|
||||
xmlParserValidityError(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
|
||||
{
|
||||
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||||
xmlParserInputPtr input = NULL;
|
||||
char * str;
|
||||
int len = xmlStrlen((const xmlChar *) msg);
|
||||
static int had_info = 0;
|
||||
|
||||
if ((len > 1) && (msg[len - 2] != ':')) {
|
||||
if (ctxt != NULL) {
|
||||
input = ctxt->input;
|
||||
if ((input->filename == NULL) && (ctxt->inputNr > 1))
|
||||
input = ctxt->inputTab[ctxt->inputNr - 2];
|
||||
|
||||
if (had_info == 0) {
|
||||
xmlParserPrintFileInfo(input);
|
||||
}
|
||||
}
|
||||
xmlGenericError(xmlGenericErrorContext, "validity error: ");
|
||||
had_info = 0;
|
||||
} else {
|
||||
had_info = 1;
|
||||
}
|
||||
|
||||
XML_GET_VAR_STR(msg, str);
|
||||
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||||
if (str != NULL)
|
||||
xmlFree(str);
|
||||
|
||||
if ((ctxt != NULL) && (input != NULL)) {
|
||||
xmlParserPrintFileContext(input);
|
||||
}
|
||||
xmlReportError(ctx, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -905,30 +814,9 @@ xmlParserValidityError(void *ctx, const char *msg, ...)
|
||||
* position and extra parameters.
|
||||
*/
|
||||
void
|
||||
xmlParserValidityWarning(void *ctx, const char *msg, ...)
|
||||
xmlParserValidityWarning(void *ctx, const char *msg ATTRIBUTE_UNUSED, ...)
|
||||
{
|
||||
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
|
||||
xmlParserInputPtr input = NULL;
|
||||
char * str;
|
||||
int len = xmlStrlen((const xmlChar *) msg);
|
||||
|
||||
if ((ctxt != NULL) && (len != 0) && (msg[len - 1] != ':')) {
|
||||
input = ctxt->input;
|
||||
if ((input->filename == NULL) && (ctxt->inputNr > 1))
|
||||
input = ctxt->inputTab[ctxt->inputNr - 2];
|
||||
|
||||
xmlParserPrintFileInfo(input);
|
||||
}
|
||||
|
||||
xmlGenericError(xmlGenericErrorContext, "validity warning: ");
|
||||
XML_GET_VAR_STR(msg, str);
|
||||
xmlGenericError(xmlGenericErrorContext, "%s", str);
|
||||
if (str != NULL)
|
||||
xmlFree(str);
|
||||
|
||||
if (ctxt != NULL) {
|
||||
xmlParserPrintFileContext(input);
|
||||
}
|
||||
xmlReportError(ctx, NULL);
|
||||
}
|
||||
|
||||
|
||||
@ -1046,75 +934,19 @@ xmlCtxtResetLastError(void *ctx)
|
||||
*/
|
||||
int
|
||||
xmlCopyError(const xmlError *from, xmlErrorPtr to) {
|
||||
char *message = NULL;
|
||||
char *file = NULL;
|
||||
char *str1 = NULL;
|
||||
char *str2 = NULL;
|
||||
char *str3 = NULL;
|
||||
const char *fmt = NULL;
|
||||
|
||||
if ((from == NULL) || (to == NULL))
|
||||
return(-1);
|
||||
|
||||
if (from->message != NULL) {
|
||||
message = (char *) xmlStrdup((xmlChar *) from->message);
|
||||
if (message == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (from->file != NULL) {
|
||||
file = (char *) xmlStrdup ((xmlChar *) from->file);
|
||||
if (file == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (from->str1 != NULL) {
|
||||
str1 = (char *) xmlStrdup ((xmlChar *) from->str1);
|
||||
if (str1 == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (from->str2 != NULL) {
|
||||
str2 = (char *) xmlStrdup ((xmlChar *) from->str2);
|
||||
if (str2 == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (from->str3 != NULL) {
|
||||
str3 = (char *) xmlStrdup ((xmlChar *) from->str3);
|
||||
if (str3 == NULL)
|
||||
goto err_memory;
|
||||
}
|
||||
if (from->message != NULL)
|
||||
fmt = "%s";
|
||||
|
||||
if (to->message != NULL)
|
||||
xmlFree(to->message);
|
||||
if (to->file != NULL)
|
||||
xmlFree(to->file);
|
||||
if (to->str1 != NULL)
|
||||
xmlFree(to->str1);
|
||||
if (to->str2 != NULL)
|
||||
xmlFree(to->str2);
|
||||
if (to->str3 != NULL)
|
||||
xmlFree(to->str3);
|
||||
to->domain = from->domain;
|
||||
to->code = from->code;
|
||||
to->level = from->level;
|
||||
to->line = from->line;
|
||||
to->node = from->node;
|
||||
to->int1 = from->int1;
|
||||
to->int2 = from->int2;
|
||||
to->node = from->node;
|
||||
to->ctxt = from->ctxt;
|
||||
to->message = message;
|
||||
to->file = file;
|
||||
to->str1 = str1;
|
||||
to->str2 = str2;
|
||||
to->str3 = str3;
|
||||
|
||||
return 0;
|
||||
|
||||
err_memory:
|
||||
xmlFree(message);
|
||||
xmlFree(file);
|
||||
xmlFree(str1);
|
||||
xmlFree(str2);
|
||||
xmlFree(str3);
|
||||
|
||||
return -1;
|
||||
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));
|
||||
}
|
||||
|
||||
|
||||
@ -4,19 +4,24 @@
|
||||
#include <libxml/xmlerror.h>
|
||||
#include <libxml/xmlversion.h>
|
||||
|
||||
#define MAX_ERR_MSG_SIZE 64000
|
||||
|
||||
struct _xmlNode;
|
||||
|
||||
XML_HIDDEN void
|
||||
xmlRaiseMemoryError(xmlStructuredErrorFunc schannel, xmlGenericErrorFunc channel,
|
||||
void *data, int domain, xmlError *error);
|
||||
XML_HIDDEN int
|
||||
xmlVRaiseError(xmlStructuredErrorFunc schannel,
|
||||
xmlGenericErrorFunc channel, void *data, void *ctx,
|
||||
void *nod, int domain, int code, xmlErrorLevel level,
|
||||
xmlVRaiseError(xmlStructuredErrorFunc schannel, xmlGenericErrorFunc channel,
|
||||
void *data, void *ctx, struct _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);
|
||||
XML_HIDDEN int
|
||||
__xmlRaiseError(xmlStructuredErrorFunc schannel,
|
||||
xmlGenericErrorFunc channel, void *data, void *ctx,
|
||||
void *nod, int domain, int code, xmlErrorLevel level,
|
||||
__xmlRaiseError(xmlStructuredErrorFunc schannel, xmlGenericErrorFunc channel,
|
||||
void *data, void *ctx, struct _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, ...) LIBXML_ATTR_FORMAT(16,17);
|
||||
|
||||
@ -3,6 +3,10 @@
|
||||
|
||||
#include <libxml/xmlstring.h>
|
||||
|
||||
XML_HIDDEN int
|
||||
xmlStrVASPrintf(xmlChar **out, int maxSize, const char *msg, va_list ap);
|
||||
XML_HIDDEN int
|
||||
xmlStrASPrintf(xmlChar **out, int maxSize, const char *msg, ...);
|
||||
XML_HIDDEN xmlChar *
|
||||
xmlEscapeFormatString(xmlChar **msg);
|
||||
|
||||
|
||||
@ -99,7 +99,7 @@ libxml2.registerInputCallback(my_input_cb)
|
||||
run_test(desc="Loading entity with custom callback",
|
||||
docpath=startURL, catalog=None,
|
||||
exp_status="loaded", exp_err=[
|
||||
(-1, "Attempt to load network entity http://example.com/dtds/sample.dtd"),
|
||||
( 3, "Attempt to load network entity http://example.com/dtds/sample.dtd"),
|
||||
( 4, "Entity 'sample.entity' not defined\n")
|
||||
])
|
||||
|
||||
|
||||
5
xmlIO.c
5
xmlIO.c
@ -154,7 +154,7 @@ static const char* const IOerr[] = {
|
||||
"No such process", /* ESRCH */
|
||||
"Operation timed out", /* ETIMEDOUT */
|
||||
"Improper link", /* EXDEV */
|
||||
"Attempt to load network entity %s", /* XML_IO_NETWORK_ATTEMPT */
|
||||
"Attempt to load network entity", /* XML_IO_NETWORK_ATTEMPT */
|
||||
"encoder error", /* XML_IO_ENCODER */
|
||||
"flush error",
|
||||
"write error",
|
||||
@ -4053,7 +4053,8 @@ xmlNoNetExternalEntityLoader(const char *URL, const char *ID,
|
||||
if (resource != NULL) {
|
||||
if ((!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "ftp://", 6)) ||
|
||||
(!xmlStrncasecmp(BAD_CAST resource, BAD_CAST "http://", 7))) {
|
||||
xmlIOErr(XML_IO_NETWORK_ATTEMPT, (const char *) resource);
|
||||
xmlLoaderErr(ctxt, "Attempt to load network entity %s",
|
||||
(const char *) resource);
|
||||
if (resource != (xmlChar *) URL)
|
||||
xmlFree(resource);
|
||||
return(NULL);
|
||||
|
||||
150
xmlstring.c
150
xmlstring.c
@ -26,6 +26,14 @@
|
||||
#include "private/parser.h"
|
||||
#include "private/string.h"
|
||||
|
||||
#ifndef va_copy
|
||||
#ifdef __va_copy
|
||||
#define va_copy(dest, src) __va_copy(dest, src)
|
||||
#else
|
||||
#define va_copy(dest, src) memcpy(dest, src, sizeof(va_list))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Commodity functions to handle xmlChars *
|
||||
@ -585,6 +593,148 @@ xmlStrVPrintf(xmlChar *buf, int len, const char *msg, va_list ap) {
|
||||
return(ret);
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlStrVASPrintf:
|
||||
* @out: pointer to the resulting string
|
||||
* @maxSize: maximum size of the output buffer
|
||||
* @fmt: printf format string
|
||||
* @ap: arguments for format string
|
||||
*
|
||||
* Creates a newly allocated string according to format.
|
||||
*
|
||||
* Returns 0 on success, 1 if the result was truncated or on other
|
||||
* errors, -1 if a memory allocation failed.
|
||||
*/
|
||||
int
|
||||
xmlStrVASPrintf(xmlChar **out, int maxSize, const char *msg, va_list ap) {
|
||||
char empty[1];
|
||||
va_list copy;
|
||||
xmlChar *buf;
|
||||
int res, size;
|
||||
int truncated = 0;
|
||||
|
||||
if (out == NULL)
|
||||
return(1);
|
||||
*out = NULL;
|
||||
if (msg == NULL)
|
||||
return(1);
|
||||
if (maxSize < 32)
|
||||
maxSize = 32;
|
||||
|
||||
va_copy(copy, ap);
|
||||
res = vsnprintf(empty, 1, msg, copy);
|
||||
va_end(copy);
|
||||
|
||||
if (res > 0) {
|
||||
/* snprintf seems to work according to C99. */
|
||||
|
||||
if (res < maxSize) {
|
||||
size = res + 1;
|
||||
} else {
|
||||
size = maxSize;
|
||||
truncated = 1;
|
||||
}
|
||||
buf = xmlMalloc(size);
|
||||
if (buf == NULL)
|
||||
return(-1);
|
||||
if (vsnprintf((char *) buf, size, msg, ap) < 0) {
|
||||
xmlFree(buf);
|
||||
return(1);
|
||||
}
|
||||
} else {
|
||||
/*
|
||||
* Unfortunately, older snprintf implementations don't follow the
|
||||
* C99 spec. If the output exceeds the size of the buffer, they can
|
||||
* return -1, 0 or the number of characters written instead of the
|
||||
* needed size. Older MSCVRT also won't write a terminating null
|
||||
* byte if the buffer is too small.
|
||||
*
|
||||
* If the value returned is non-negative and strictly less than
|
||||
* the buffer size (without terminating null), the result should
|
||||
* have been written completely, so we double the buffer size
|
||||
* until this condition is true. This assumes that snprintf will
|
||||
* eventually return a non-negative value. Otherwise, we will
|
||||
* allocate more and more memory until we run out.
|
||||
*
|
||||
* Note that this code path is also executed on conforming
|
||||
* platforms if the output is the empty string.
|
||||
*/
|
||||
|
||||
buf = NULL;
|
||||
size = 32;
|
||||
while (1) {
|
||||
buf = xmlMalloc(size);
|
||||
if (buf == NULL)
|
||||
return(-1);
|
||||
|
||||
va_copy(copy, ap);
|
||||
res = vsnprintf((char *) buf, size, msg, copy);
|
||||
va_end(copy);
|
||||
if ((res >= 0) && (res < size - 1))
|
||||
break;
|
||||
|
||||
if (size >= maxSize) {
|
||||
truncated = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
xmlFree(buf);
|
||||
|
||||
if (size > maxSize / 2)
|
||||
size = maxSize;
|
||||
else
|
||||
size *= 2;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If the output was truncated, make sure that the buffer doesn't
|
||||
* end with a truncated UTF-8 sequence.
|
||||
*/
|
||||
if (truncated != 0) {
|
||||
int i = size - 1;
|
||||
|
||||
while (i > 0) {
|
||||
/* Break after ASCII */
|
||||
if (buf[i-1] < 0x80)
|
||||
break;
|
||||
i -= 1;
|
||||
/* Break before non-ASCII */
|
||||
if (buf[i] >= 0xc0)
|
||||
break;
|
||||
}
|
||||
|
||||
buf[i] = 0;
|
||||
}
|
||||
|
||||
*out = (xmlChar *) buf;
|
||||
return(truncated);
|
||||
}
|
||||
|
||||
/**
|
||||
* xmlStrASPrintf:
|
||||
* @out: pointer to the resulting string
|
||||
* @maxSize: maximum size of the output buffer
|
||||
* @fmt: printf format string
|
||||
* @ap: arguments for format string
|
||||
*
|
||||
* See xmlStrVASPrintf.
|
||||
*
|
||||
* Returns 0 on success, 1 if the result was truncated or on other
|
||||
* errors, -1 if a memory allocation failed.
|
||||
*/
|
||||
int
|
||||
xmlStrASPrintf(xmlChar **out, int maxSize, const char *msg, ...) {
|
||||
va_list ap;
|
||||
int ret;
|
||||
|
||||
va_start(ap, msg);
|
||||
ret = xmlStrVASPrintf(out, maxSize, msg, ap);
|
||||
va_end(ap);
|
||||
|
||||
return(ret);
|
||||
}
|
||||
|
||||
/************************************************************************
|
||||
* *
|
||||
* Generic UTF8 handling routines *
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user