diff --git "a/local-test-libxml2-delta-01/afc-libxml2/parser.c" "b/local-test-libxml2-delta-01/afc-libxml2/parser.c" new file mode 100644--- /dev/null +++ "b/local-test-libxml2-delta-01/afc-libxml2/parser.c" @@ -0,0 +1,14233 @@ +/* + * parser.c : an XML 1.0 parser, namespaces and validity support are mostly + * implemented on top of the SAX interfaces + * + * References: + * The XML specification: + * http://www.w3.org/TR/REC-xml + * Original 1.0 version: + * http://www.w3.org/TR/1998/REC-xml-19980210 + * XML second edition working draft + * http://www.w3.org/TR/2000/WD-xml-2e-20000814 + * + * Okay this is a big file, the parser core is around 7000 lines, then it + * is followed by the progressive parser top routines, then the various + * high level APIs to call the parser and a few miscellaneous functions. + * A number of helper functions and deprecated ones have been moved to + * parserInternals.c to reduce this file size. + * As much as possible the functions are associated with their relative + * production in the XML specification. A few productions defining the + * different ranges of character are actually implanted either in + * parserInternals.h or parserInternals.c + * The DOM tree build is realized from the default SAX callbacks in + * the module SAX2.c. + * The routines doing the validation checks are in valid.c and called either + * from the SAX callbacks or as standalone functions using a preparsed + * document. + * + * See Copyright for the status of this software. + * + * daniel@veillard.com + */ + +/* To avoid EBCDIC trouble when parsing on zOS */ +#if defined(__MVS__) +#pragma convert("ISO8859-1") +#endif + +#define IN_LIBXML +#include "libxml.h" + +#if defined(_WIN32) +#define XML_DIR_SEP '\\' +#else +#define XML_DIR_SEP '/' +#endif + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef LIBXML_CATALOG_ENABLED +#include +#endif + +#include "private/buf.h" +#include "private/dict.h" +#include "private/entities.h" +#include "private/error.h" +#include "private/html.h" +#include "private/io.h" +#include "private/parser.h" + +#define NS_INDEX_EMPTY INT_MAX +#define NS_INDEX_XML (INT_MAX - 1) +#define URI_HASH_EMPTY 0xD943A04E +#define URI_HASH_XML 0xF0451F02 + +#ifndef STDIN_FILENO + #define STDIN_FILENO 0 +#endif + +#ifndef SIZE_MAX + #define SIZE_MAX ((size_t) -1) +#endif + +struct _xmlStartTag { + const xmlChar *prefix; + const xmlChar *URI; + int line; + int nsNr; +}; + +typedef struct { + void *saxData; + unsigned prefixHashValue; + unsigned uriHashValue; + unsigned elementId; + int oldIndex; +} xmlParserNsExtra; + +typedef struct { + unsigned hashValue; + int index; +} xmlParserNsBucket; + +struct _xmlParserNsData { + xmlParserNsExtra *extra; + + unsigned hashSize; + unsigned hashElems; + xmlParserNsBucket *hash; + + unsigned elementId; + int defaultNsIndex; + int minNsIndex; +}; + +static int +xmlParseElementStart(xmlParserCtxtPtr ctxt); + +static void +xmlParseElementEnd(xmlParserCtxtPtr ctxt); + +static xmlEntityPtr +xmlLookupGeneralEntity(xmlParserCtxtPtr ctxt, const xmlChar *name, int inAttr); + +static const xmlChar * +xmlParseEntityRefInternal(xmlParserCtxtPtr ctxt); + +/************************************************************************ + * * + * Arbitrary limits set in the parser. See XML_PARSE_HUGE * + * * + ************************************************************************/ + +#define XML_PARSER_BIG_ENTITY 1000 +#define XML_PARSER_LOT_ENTITY 5000 + +/* + * Constants for protection against abusive entity expansion + * ("billion laughs"). + */ + +/* + * A certain amount of entity expansion which is always allowed. + */ +#define XML_PARSER_ALLOWED_EXPANSION 1000000 + +/* + * Fixed cost for each entity reference. This crudely models processing time + * as well to protect, for example, against exponential expansion of empty + * or very short entities. + */ +#define XML_ENT_FIXED_COST 20 + +/** + * xmlParserMaxDepth: + * + * arbitrary depth limit for the XML documents that we allow to + * process. This is not a limitation of the parser but a safety + * boundary feature. It can be disabled with the XML_PARSE_HUGE + * parser option. + */ +const unsigned int xmlParserMaxDepth = 256; + + + +#define XML_PARSER_BIG_BUFFER_SIZE 300 +#define XML_PARSER_BUFFER_SIZE 100 +#define SAX_COMPAT_MODE BAD_CAST "SAX compatibility mode document" + +/** + * XML_PARSER_CHUNK_SIZE + * + * When calling GROW that's the minimal amount of data + * the parser expected to have received. It is not a hard + * limit but an optimization when reading strings like Names + * It is not strictly needed as long as inputs available characters + * are followed by 0, which should be provided by the I/O level + */ +#define XML_PARSER_CHUNK_SIZE 100 + +/** + * xmlParserVersion: + * + * Constant string describing the internal version of the library + */ +const char *const +xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA; + +/* + * List of XML prefixed PI allowed by W3C specs + */ + +static const char* const xmlW3CPIs[] = { + "xml-stylesheet", + "xml-model", + NULL +}; + + +/* DEPR void xmlParserHandleReference(xmlParserCtxtPtr ctxt); */ +static xmlEntityPtr xmlParseStringPEReference(xmlParserCtxtPtr ctxt, + const xmlChar **str); + +static void +xmlCtxtParseEntity(xmlParserCtxtPtr ctxt, xmlEntityPtr ent); + +static int +xmlLoadEntityContent(xmlParserCtxtPtr ctxt, xmlEntityPtr entity); + +/************************************************************************ + * * + * Some factorized error routines * + * * + ************************************************************************/ + +static void +xmlErrMemory(xmlParserCtxtPtr ctxt) { + xmlCtxtErrMemory(ctxt); +} + +/** + * xmlErrAttributeDup: + * @ctxt: an XML parser context + * @prefix: the attribute prefix + * @localname: the attribute localname + * + * Handle a redefinition of attribute error + */ +static void +xmlErrAttributeDup(xmlParserCtxtPtr ctxt, const xmlChar * prefix, + const xmlChar * localname) +{ + if (prefix == NULL) + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, XML_ERR_ATTRIBUTE_REDEFINED, + XML_ERR_FATAL, localname, NULL, NULL, 0, + "Attribute %s redefined\n", localname); + else + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, XML_ERR_ATTRIBUTE_REDEFINED, + XML_ERR_FATAL, prefix, localname, NULL, 0, + "Attribute %s:%s redefined\n", prefix, localname); +} + +/** + * xmlFatalErrMsg: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * + * Handle a fatal parser error, i.e. violating Well-Formedness constraints + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, + NULL, NULL, NULL, 0, "%s", msg); +} + +/** + * xmlWarningMsg: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * @str1: extra data + * @str2: extra data + * + * Handle a warning. + */ +void LIBXML_ATTR_FORMAT(3,0) +xmlWarningMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, const xmlChar *str1, const xmlChar *str2) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_WARNING, + str1, str2, NULL, 0, msg, str1, str2); +} + +/** + * xmlValidityError: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * @str1: extra data + * + * Handle a validity error. + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlValidityError(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, const xmlChar *str1, const xmlChar *str2) +{ + ctxt->valid = 0; + + xmlCtxtErr(ctxt, NULL, XML_FROM_DTD, error, XML_ERR_ERROR, + str1, str2, NULL, 0, msg, str1, str2); +} + +/** + * xmlFatalErrMsgInt: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * @val: an integer value + * + * Handle a fatal parser error, i.e. violating Well-Formedness constraints + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlFatalErrMsgInt(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, int val) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, + NULL, NULL, NULL, val, msg, val); +} + +/** + * xmlFatalErrMsgStrIntStr: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * @str1: an string info + * @val: an integer value + * @str2: an string info + * + * Handle a fatal parser error, i.e. violating Well-Formedness constraints + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlFatalErrMsgStrIntStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, const xmlChar *str1, int val, + const xmlChar *str2) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, + str1, str2, NULL, val, msg, str1, val, str2); +} + +/** + * xmlFatalErrMsgStr: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * @val: a string value + * + * Handle a fatal parser error, i.e. violating Well-Formedness constraints + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlFatalErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, const xmlChar * val) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL, + val, NULL, NULL, 0, msg, val); +} + +/** + * xmlErrMsgStr: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the error message + * @val: a string value + * + * Handle a non fatal parser error + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlErrMsgStr(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, const xmlChar * val) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_ERROR, + val, NULL, NULL, 0, msg, val); +} + +/** + * xmlNsErr: + * @ctxt: an XML parser context + * @error: the error number + * @msg: the message + * @info1: extra information string + * @info2: extra information string + * + * Handle a fatal parser error, i.e. violating Well-Formedness constraints + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlNsErr(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, + const xmlChar * info1, const xmlChar * info2, + const xmlChar * info3) +{ + ctxt->nsWellFormed = 0; + + xmlCtxtErr(ctxt, NULL, XML_FROM_NAMESPACE, error, XML_ERR_ERROR, + info1, info2, info3, 0, msg, info1, info2, info3); +} + +/** + * xmlNsWarn + * @ctxt: an XML parser context + * @error: the error number + * @msg: the message + * @info1: extra information string + * @info2: extra information string + * + * Handle a namespace warning error + */ +static void LIBXML_ATTR_FORMAT(3,0) +xmlNsWarn(xmlParserCtxtPtr ctxt, xmlParserErrors error, + const char *msg, + const xmlChar * info1, const xmlChar * info2, + const xmlChar * info3) +{ + xmlCtxtErr(ctxt, NULL, XML_FROM_NAMESPACE, error, XML_ERR_WARNING, + info1, info2, info3, 0, msg, info1, info2, info3); +} + +static void +xmlSaturatedAdd(unsigned long *dst, unsigned long val) { + if (val > ULONG_MAX - *dst) + *dst = ULONG_MAX; + else + *dst += val; +} + +static void +xmlSaturatedAddSizeT(unsigned long *dst, unsigned long val) { + if (val > ULONG_MAX - *dst) + *dst = ULONG_MAX; + else + *dst += val; +} + +/** + * xmlParserEntityCheck: + * @ctxt: parser context + * @extra: sum of unexpanded entity sizes + * + * Check for non-linear entity expansion behaviour. + * + * In some cases like xmlExpandEntityInAttValue, this function is called + * for each, possibly nested entity and its unexpanded content length. + * + * In other cases like xmlParseReference, it's only called for each + * top-level entity with its unexpanded content length plus the sum of + * the unexpanded content lengths (plus fixed cost) of all nested + * entities. + * + * Summing the unexpanded lengths also adds the length of the reference. + * This is by design. Taking the length of the entity name into account + * discourages attacks that try to waste CPU time with abusively long + * entity names. See test/recurse/lol6.xml for example. Each call also + * adds some fixed cost XML_ENT_FIXED_COST to discourage attacks with + * short entities. + * + * Returns 1 on error, 0 on success. + */ +static int +xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long extra) +{ + unsigned long consumed; + unsigned long *expandedSize; + xmlParserInputPtr input = ctxt->input; + xmlEntityPtr entity = input->entity; + + if ((entity) && (entity->flags & XML_ENT_CHECKED)) + return(0); + + /* + * Compute total consumed bytes so far, including input streams of + * external entities. + */ + consumed = input->consumed; + xmlSaturatedAddSizeT(&consumed, input->cur - input->base); + xmlSaturatedAdd(&consumed, ctxt->sizeentities); + + if (entity) + expandedSize = &entity->expandedSize; + else + expandedSize = &ctxt->sizeentcopy; + + /* + * Add extra cost and some fixed cost. + */ + xmlSaturatedAdd(expandedSize, extra); + xmlSaturatedAdd(expandedSize, XML_ENT_FIXED_COST); + + /* + * It's important to always use saturation arithmetic when tracking + * entity sizes to make the size checks reliable. If "sizeentcopy" + * overflows, we have to abort. + */ + if ((*expandedSize > XML_PARSER_ALLOWED_EXPANSION) && + ((*expandedSize >= ULONG_MAX) || + (*expandedSize / ctxt->maxAmpl > consumed))) { + xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, + "Maximum entity amplification factor exceeded, see " + "xmlCtxtSetMaxAmplification.\n"); + xmlHaltParser(ctxt); + return(1); + } + + return(0); +} + +/************************************************************************ + * * + * Library wide options * + * * + ************************************************************************/ + +/** + * xmlHasFeature: + * @feature: the feature to be examined + * + * Examines if the library has been compiled with a given feature. + * + * Returns a non-zero value if the feature exist, otherwise zero. + * Returns zero (0) if the feature does not exist or an unknown + * unknown feature is requested, non-zero otherwise. + */ +int +xmlHasFeature(xmlFeature feature) +{ + switch (feature) { + case XML_WITH_THREAD: +#ifdef LIBXML_THREAD_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_TREE: + return(1); + case XML_WITH_OUTPUT: +#ifdef LIBXML_OUTPUT_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_PUSH: +#ifdef LIBXML_PUSH_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_READER: +#ifdef LIBXML_READER_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_PATTERN: +#ifdef LIBXML_PATTERN_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_WRITER: +#ifdef LIBXML_WRITER_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_SAX1: +#ifdef LIBXML_SAX1_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_HTTP: +#ifdef LIBXML_HTTP_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_VALID: +#ifdef LIBXML_VALID_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_HTML: +#ifdef LIBXML_HTML_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_LEGACY: +#ifdef LIBXML_LEGACY_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_C14N: +#ifdef LIBXML_C14N_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_CATALOG: +#ifdef LIBXML_CATALOG_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_XPATH: +#ifdef LIBXML_XPATH_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_XPTR: +#ifdef LIBXML_XPTR_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_XINCLUDE: +#ifdef LIBXML_XINCLUDE_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_ICONV: +#ifdef LIBXML_ICONV_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_ISO8859X: +#ifdef LIBXML_ISO8859X_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_UNICODE: +#ifdef LIBXML_UNICODE_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_REGEXP: +#ifdef LIBXML_REGEXP_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_AUTOMATA: +#ifdef LIBXML_REGEXP_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_EXPR: +#ifdef LIBXML_EXPR_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_SCHEMAS: +#ifdef LIBXML_SCHEMAS_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_SCHEMATRON: +#ifdef LIBXML_SCHEMATRON_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_MODULES: +#ifdef LIBXML_MODULES_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_DEBUG: +#ifdef LIBXML_DEBUG_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_DEBUG_MEM: + return(0); + case XML_WITH_ZLIB: +#ifdef LIBXML_ZLIB_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_LZMA: +#ifdef LIBXML_LZMA_ENABLED + return(1); +#else + return(0); +#endif + case XML_WITH_ICU: +#ifdef LIBXML_ICU_ENABLED + return(1); +#else + return(0); +#endif + default: + break; + } + return(0); +} + +/************************************************************************ + * * + * Simple string buffer * + * * + ************************************************************************/ + +typedef struct { + xmlChar *mem; + unsigned size; + unsigned cap; /* size < cap */ + unsigned max; /* size <= max */ + xmlParserErrors code; +} xmlSBuf; + +static void +xmlSBufInit(xmlSBuf *buf, unsigned max) { + buf->mem = NULL; + buf->size = 0; + buf->cap = 0; + buf->max = max; + buf->code = XML_ERR_OK; +} + +static int +xmlSBufGrow(xmlSBuf *buf, unsigned len) { + xmlChar *mem; + unsigned cap; + + if (len >= UINT_MAX / 2 - buf->size) { + if (buf->code == XML_ERR_OK) + buf->code = XML_ERR_RESOURCE_LIMIT; + return(-1); + } + + cap = (buf->size + len) * 2; + if (cap < 240) + cap = 240; + + mem = xmlRealloc(buf->mem, cap); + if (mem == NULL) { + buf->code = XML_ERR_NO_MEMORY; + return(-1); + } + + buf->mem = mem; + buf->cap = cap; + + return(0); +} + +static void +xmlSBufAddString(xmlSBuf *buf, const xmlChar *str, unsigned len) { + if (buf->max - buf->size < len) { + if (buf->code == XML_ERR_OK) + buf->code = XML_ERR_RESOURCE_LIMIT; + return; + } + + if (buf->cap - buf->size <= len) { + if (xmlSBufGrow(buf, len) < 0) + return; + } + + if (len > 0) + memcpy(buf->mem + buf->size, str, len); + buf->size += len; +} + +static void +xmlSBufAddCString(xmlSBuf *buf, const char *str, unsigned len) { + xmlSBufAddString(buf, (const xmlChar *) str, len); +} + +static void +xmlSBufAddChar(xmlSBuf *buf, int c) { + xmlChar *end; + + if (buf->max - buf->size < 4) { + if (buf->code == XML_ERR_OK) + buf->code = XML_ERR_RESOURCE_LIMIT; + return; + } + + if (buf->cap - buf->size <= 4) { + if (xmlSBufGrow(buf, 4) < 0) + return; + } + + end = buf->mem + buf->size; + + if (c < 0x80) { + *end = (xmlChar) c; + buf->size += 1; + } else { + buf->size += xmlCopyCharMultiByte(end, c); + } +} + +static void +xmlSBufAddReplChar(xmlSBuf *buf) { + xmlSBufAddCString(buf, "\xEF\xBF\xBD", 3); +} + +static void +xmlSBufReportError(xmlSBuf *buf, xmlParserCtxtPtr ctxt, const char *errMsg) { + if (buf->code == XML_ERR_NO_MEMORY) + xmlCtxtErrMemory(ctxt); + else + xmlFatalErr(ctxt, buf->code, errMsg); +} + +static xmlChar * +xmlSBufFinish(xmlSBuf *buf, int *sizeOut, xmlParserCtxtPtr ctxt, + const char *errMsg) { + if (buf->mem == NULL) { + buf->mem = xmlMalloc(1); + if (buf->mem == NULL) { + buf->code = XML_ERR_NO_MEMORY; + } else { + buf->mem[0] = 0; + } + } else { + buf->mem[buf->size] = 0; + } + + if (buf->code == XML_ERR_OK) { + if (sizeOut != NULL) + *sizeOut = buf->size; + return(buf->mem); + } + + xmlSBufReportError(buf, ctxt, errMsg); + + xmlFree(buf->mem); + + if (sizeOut != NULL) + *sizeOut = 0; + return(NULL); +} + +static void +xmlSBufCleanup(xmlSBuf *buf, xmlParserCtxtPtr ctxt, const char *errMsg) { + if (buf->code != XML_ERR_OK) + xmlSBufReportError(buf, ctxt, errMsg); + + xmlFree(buf->mem); +} + +static int +xmlUTF8MultibyteLen(xmlParserCtxtPtr ctxt, const xmlChar *str, + const char *errMsg) { + int c = str[0]; + int c1 = str[1]; + + if ((c1 & 0xC0) != 0x80) + goto encoding_error; + + if (c < 0xE0) { + /* 2-byte sequence */ + if (c < 0xC2) + goto encoding_error; + + return(2); + } else { + int c2 = str[2]; + + if ((c2 & 0xC0) != 0x80) + goto encoding_error; + + if (c < 0xF0) { + /* 3-byte sequence */ + if (c == 0xE0) { + /* overlong */ + if (c1 < 0xA0) + goto encoding_error; + } else if (c == 0xED) { + /* surrogate */ + if (c1 >= 0xA0) + goto encoding_error; + } else if (c == 0xEF) { + /* U+FFFE and U+FFFF are invalid Chars */ + if ((c1 == 0xBF) && (c2 >= 0xBE)) + xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, errMsg); + } + + return(3); + } else { + /* 4-byte sequence */ + if ((str[3] & 0xC0) != 0x80) + goto encoding_error; + if (c == 0xF0) { + /* overlong */ + if (c1 < 0x90) + goto encoding_error; + } else if (c >= 0xF4) { + /* greater than 0x10FFFF */ + if ((c > 0xF4) || (c1 >= 0x90)) + goto encoding_error; + } + + return(4); + } + } + +encoding_error: + /* Only report the first error */ + if ((ctxt->input->flags & XML_INPUT_ENCODING_ERROR) == 0) { + xmlCtxtErrIO(ctxt, XML_ERR_INVALID_ENCODING, NULL); + ctxt->input->flags |= XML_INPUT_ENCODING_ERROR; + } + + return(0); +} + +/************************************************************************ + * * + * SAX2 defaulted attributes handling * + * * + ************************************************************************/ + +/** + * xmlCtxtInitializeLate: + * @ctxt: an XML parser context + * + * Final initialization of the parser context before starting to parse. + * + * This accounts for users modifying struct members of parser context + * directly. + */ +static void +xmlCtxtInitializeLate(xmlParserCtxtPtr ctxt) { + xmlSAXHandlerPtr sax; + + /* Avoid unused variable warning if features are disabled. */ + (void) sax; + + /* + * Changing the SAX struct directly is still widespread practice + * in internal and external code. + */ + if (ctxt == NULL) return; + sax = ctxt->sax; +#ifdef LIBXML_SAX1_ENABLED + /* + * Only enable SAX2 if there SAX2 element handlers, except when there + * are no element handlers at all. + */ + if (((ctxt->options & XML_PARSE_SAX1) == 0) && + (sax) && + (sax->initialized == XML_SAX2_MAGIC) && + ((sax->startElementNs != NULL) || + (sax->endElementNs != NULL) || + ((sax->startElement == NULL) && (sax->endElement == NULL)))) + ctxt->sax2 = 1; +#else + ctxt->sax2 = 1; +#endif /* LIBXML_SAX1_ENABLED */ + + /* + * Some users replace the dictionary directly in the context struct. + * We really need an API function to do that cleanly. + */ + ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3); + ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5); + ctxt->str_xml_ns = xmlDictLookup(ctxt->dict, XML_XML_NAMESPACE, 36); + if ((ctxt->str_xml==NULL) || (ctxt->str_xmlns==NULL) || + (ctxt->str_xml_ns == NULL)) { + xmlErrMemory(ctxt); + } + + xmlDictSetLimit(ctxt->dict, + (ctxt->options & XML_PARSE_HUGE) ? + 0 : + XML_MAX_DICTIONARY_LIMIT); +} + +typedef struct { + xmlHashedString prefix; + xmlHashedString name; + xmlHashedString value; + const xmlChar *valueEnd; + int external; + int expandedSize; +} xmlDefAttr; + +typedef struct _xmlDefAttrs xmlDefAttrs; +typedef xmlDefAttrs *xmlDefAttrsPtr; +struct _xmlDefAttrs { + int nbAttrs; /* number of defaulted attributes on that element */ + int maxAttrs; /* the size of the array */ +#if __STDC_VERSION__ >= 199901L + /* Using a C99 flexible array member avoids UBSan errors. */ + xmlDefAttr attrs[] ATTRIBUTE_COUNTED_BY(maxAttrs); +#else + xmlDefAttr attrs[1]; +#endif +}; + +/** + * xmlAttrNormalizeSpace: + * @src: the source string + * @dst: the target string + * + * Normalize the space in non CDATA attribute values: + * If the attribute type is not CDATA, then the XML processor MUST further + * process the normalized attribute value by discarding any leading and + * trailing space (#x20) characters, and by replacing sequences of space + * (#x20) characters by a single space (#x20) character. + * Note that the size of dst need to be at least src, and if one doesn't need + * to preserve dst (and it doesn't come from a dictionary or read-only) then + * passing src as dst is just fine. + * + * Returns a pointer to the normalized value (dst) or NULL if no conversion + * is needed. + */ +static xmlChar * +xmlAttrNormalizeSpace(const xmlChar *src, xmlChar *dst) +{ + if ((src == NULL) || (dst == NULL)) + return(NULL); + + while (*src == 0x20) src++; + while (*src != 0) { + if (*src == 0x20) { + while (*src == 0x20) src++; + if (*src != 0) + *dst++ = 0x20; + } else { + *dst++ = *src++; + } + } + *dst = 0; + if (dst == src) + return(NULL); + return(dst); +} + +/** + * xmlAddDefAttrs: + * @ctxt: an XML parser context + * @fullname: the element fullname + * @fullattr: the attribute fullname + * @value: the attribute value + * + * Add a defaulted attribute for an element + */ +static void +xmlAddDefAttrs(xmlParserCtxtPtr ctxt, + const xmlChar *fullname, + const xmlChar *fullattr, + const xmlChar *value) { + xmlDefAttrsPtr defaults; + xmlDefAttr *attr; + int len, expandedSize; + xmlHashedString name; + xmlHashedString prefix; + xmlHashedString hvalue; + const xmlChar *localname; + + /* + * Allows to detect attribute redefinitions + */ + if (ctxt->attsSpecial != NULL) { + if (xmlHashLookup2(ctxt->attsSpecial, fullname, fullattr) != NULL) + return; + } + + if (ctxt->attsDefault == NULL) { + ctxt->attsDefault = xmlHashCreateDict(10, ctxt->dict); + if (ctxt->attsDefault == NULL) + goto mem_error; + } + + /* + * split the element name into prefix:localname , the string found + * are within the DTD and then not associated to namespace names. + */ + localname = xmlSplitQName3(fullname, &len); + if (localname == NULL) { + name = xmlDictLookupHashed(ctxt->dict, fullname, -1); + prefix.name = NULL; + } else { + name = xmlDictLookupHashed(ctxt->dict, localname, -1); + prefix = xmlDictLookupHashed(ctxt->dict, fullname, len); + if (prefix.name == NULL) + goto mem_error; + } + if (name.name == NULL) + goto mem_error; + + /* + * make sure there is some storage + */ + defaults = xmlHashLookup2(ctxt->attsDefault, name.name, prefix.name); + if ((defaults == NULL) || + (defaults->nbAttrs >= defaults->maxAttrs)) { + xmlDefAttrsPtr temp; + int newSize; + + newSize = (defaults != NULL) ? 2 * defaults->maxAttrs : 4; + temp = xmlRealloc(defaults, + sizeof(*defaults) + newSize * sizeof(xmlDefAttr)); + if (temp == NULL) + goto mem_error; + if (defaults == NULL) + temp->nbAttrs = 0; + temp->maxAttrs = newSize; + defaults = temp; + if (xmlHashUpdateEntry2(ctxt->attsDefault, name.name, prefix.name, + defaults, NULL) < 0) { + xmlFree(defaults); + goto mem_error; + } + } + + /* + * Split the attribute name into prefix:localname , the string found + * are within the DTD and hen not associated to namespace names. + */ + localname = xmlSplitQName3(fullattr, &len); + if (localname == NULL) { + name = xmlDictLookupHashed(ctxt->dict, fullattr, -1); + prefix.name = NULL; + } else { + name = xmlDictLookupHashed(ctxt->dict, localname, -1); + prefix = xmlDictLookupHashed(ctxt->dict, fullattr, len); + if (prefix.name == NULL) + goto mem_error; + } + if (name.name == NULL) + goto mem_error; + + /* intern the string and precompute the end */ + len = strlen((const char *) value); + hvalue = xmlDictLookupHashed(ctxt->dict, value, len); + if (hvalue.name == NULL) + goto mem_error; + + expandedSize = strlen((const char *) name.name); + if (prefix.name != NULL) + expandedSize += strlen((const char *) prefix.name); + expandedSize += len; + + attr = &defaults->attrs[defaults->nbAttrs++]; + attr->name = name; + attr->prefix = prefix; + attr->value = hvalue; + attr->valueEnd = hvalue.name + len; + attr->external = PARSER_EXTERNAL(ctxt); + attr->expandedSize = expandedSize; + + return; + +mem_error: + xmlErrMemory(ctxt); +} + +/** + * xmlAddSpecialAttr: + * @ctxt: an XML parser context + * @fullname: the element fullname + * @fullattr: the attribute fullname + * @type: the attribute type + * + * Register this attribute type + */ +static void +xmlAddSpecialAttr(xmlParserCtxtPtr ctxt, + const xmlChar *fullname, + const xmlChar *fullattr, + int type) +{ + if (ctxt->attsSpecial == NULL) { + ctxt->attsSpecial = xmlHashCreateDict(10, ctxt->dict); + if (ctxt->attsSpecial == NULL) + goto mem_error; + } + + if (xmlHashAdd2(ctxt->attsSpecial, fullname, fullattr, + (void *) (ptrdiff_t) type) < 0) + goto mem_error; + return; + +mem_error: + xmlErrMemory(ctxt); +} + +/** + * xmlCleanSpecialAttrCallback: + * + * Removes CDATA attributes from the special attribute table + */ +static void +xmlCleanSpecialAttrCallback(void *payload, void *data, + const xmlChar *fullname, const xmlChar *fullattr, + const xmlChar *unused ATTRIBUTE_UNUSED) { + xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) data; + + if (((ptrdiff_t) payload) == XML_ATTRIBUTE_CDATA) { + xmlHashRemoveEntry2(ctxt->attsSpecial, fullname, fullattr, NULL); + } +} + +/** + * xmlCleanSpecialAttr: + * @ctxt: an XML parser context + * + * Trim the list of attributes defined to remove all those of type + * CDATA as they are not special. This call should be done when finishing + * to parse the DTD and before starting to parse the document root. + */ +static void +xmlCleanSpecialAttr(xmlParserCtxtPtr ctxt) +{ + if (ctxt->attsSpecial == NULL) + return; + + xmlHashScanFull(ctxt->attsSpecial, xmlCleanSpecialAttrCallback, ctxt); + + if (xmlHashSize(ctxt->attsSpecial) == 0) { + xmlHashFree(ctxt->attsSpecial, NULL); + ctxt->attsSpecial = NULL; + } +} + +/** + * xmlCheckLanguageID: + * @lang: pointer to the string value + * + * DEPRECATED: Internal function, do not use. + * + * Checks that the value conforms to the LanguageID production: + * + * NOTE: this is somewhat deprecated, those productions were removed from + * the XML Second edition. + * + * [33] LanguageID ::= Langcode ('-' Subcode)* + * [34] Langcode ::= ISO639Code | IanaCode | UserCode + * [35] ISO639Code ::= ([a-z] | [A-Z]) ([a-z] | [A-Z]) + * [36] IanaCode ::= ('i' | 'I') '-' ([a-z] | [A-Z])+ + * [37] UserCode ::= ('x' | 'X') '-' ([a-z] | [A-Z])+ + * [38] Subcode ::= ([a-z] | [A-Z])+ + * + * The current REC reference the successors of RFC 1766, currently 5646 + * + * http://www.rfc-editor.org/rfc/rfc5646.txt + * langtag = language + * ["-" script] + * ["-" region] + * *("-" variant) + * *("-" extension) + * ["-" privateuse] + * language = 2*3ALPHA ; shortest ISO 639 code + * ["-" extlang] ; sometimes followed by + * ; extended language subtags + * / 4ALPHA ; or reserved for future use + * / 5*8ALPHA ; or registered language subtag + * + * extlang = 3ALPHA ; selected ISO 639 codes + * *2("-" 3ALPHA) ; permanently reserved + * + * script = 4ALPHA ; ISO 15924 code + * + * region = 2ALPHA ; ISO 3166-1 code + * / 3DIGIT ; UN M.49 code + * + * variant = 5*8alphanum ; registered variants + * / (DIGIT 3alphanum) + * + * extension = singleton 1*("-" (2*8alphanum)) + * + * ; Single alphanumerics + * ; "x" reserved for private use + * singleton = DIGIT ; 0 - 9 + * / %x41-57 ; A - W + * / %x59-5A ; Y - Z + * / %x61-77 ; a - w + * / %x79-7A ; y - z + * + * it sounds right to still allow Irregular i-xxx IANA and user codes too + * The parser below doesn't try to cope with extension or privateuse + * that could be added but that's not interoperable anyway + * + * Returns 1 if correct 0 otherwise + **/ +int +xmlCheckLanguageID(const xmlChar * lang) +{ + const xmlChar *cur = lang, *nxt; + + if (cur == NULL) + return (0); + if (((cur[0] == 'i') && (cur[1] == '-')) || + ((cur[0] == 'I') && (cur[1] == '-')) || + ((cur[0] == 'x') && (cur[1] == '-')) || + ((cur[0] == 'X') && (cur[1] == '-'))) { + /* + * Still allow IANA code and user code which were coming + * from the previous version of the XML-1.0 specification + * it's deprecated but we should not fail + */ + cur += 2; + while (((cur[0] >= 'A') && (cur[0] <= 'Z')) || + ((cur[0] >= 'a') && (cur[0] <= 'z'))) + cur++; + return(cur[0] == 0); + } + nxt = cur; + while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || + ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) + nxt++; + if (nxt - cur >= 4) { + /* + * Reserved + */ + if ((nxt - cur > 8) || (nxt[0] != 0)) + return(0); + return(1); + } + if (nxt - cur < 2) + return(0); + /* we got an ISO 639 code */ + if (nxt[0] == 0) + return(1); + if (nxt[0] != '-') + return(0); + + nxt++; + cur = nxt; + /* now we can have extlang or script or region or variant */ + if ((nxt[0] >= '0') && (nxt[0] <= '9')) + goto region_m49; + + while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || + ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) + nxt++; + if (nxt - cur == 4) + goto script; + if (nxt - cur == 2) + goto region; + if ((nxt - cur >= 5) && (nxt - cur <= 8)) + goto variant; + if (nxt - cur != 3) + return(0); + /* we parsed an extlang */ + if (nxt[0] == 0) + return(1); + if (nxt[0] != '-') + return(0); + + nxt++; + cur = nxt; + /* now we can have script or region or variant */ + if ((nxt[0] >= '0') && (nxt[0] <= '9')) + goto region_m49; + + while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || + ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) + nxt++; + if (nxt - cur == 2) + goto region; + if ((nxt - cur >= 5) && (nxt - cur <= 8)) + goto variant; + if (nxt - cur != 4) + return(0); + /* we parsed a script */ +script: + if (nxt[0] == 0) + return(1); + if (nxt[0] != '-') + return(0); + + nxt++; + cur = nxt; + /* now we can have region or variant */ + if ((nxt[0] >= '0') && (nxt[0] <= '9')) + goto region_m49; + + while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || + ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) + nxt++; + + if ((nxt - cur >= 5) && (nxt - cur <= 8)) + goto variant; + if (nxt - cur != 2) + return(0); + /* we parsed a region */ +region: + if (nxt[0] == 0) + return(1); + if (nxt[0] != '-') + return(0); + + nxt++; + cur = nxt; + /* now we can just have a variant */ + while (((nxt[0] >= 'A') && (nxt[0] <= 'Z')) || + ((nxt[0] >= 'a') && (nxt[0] <= 'z'))) + nxt++; + + if ((nxt - cur < 5) || (nxt - cur > 8)) + return(0); + + /* we parsed a variant */ +variant: + if (nxt[0] == 0) + return(1); + if (nxt[0] != '-') + return(0); + /* extensions and private use subtags not checked */ + return (1); + +region_m49: + if (((nxt[1] >= '0') && (nxt[1] <= '9')) && + ((nxt[2] >= '0') && (nxt[2] <= '9'))) { + nxt += 3; + goto region; + } + return(0); +} + +/************************************************************************ + * * + * Parser stacks related functions and macros * + * * + ************************************************************************/ + +static xmlChar * +xmlParseStringEntityRef(xmlParserCtxtPtr ctxt, const xmlChar **str); + +/** + * xmlParserNsCreate: + * + * Create a new namespace database. + * + * Returns the new obejct. + */ +xmlParserNsData * +xmlParserNsCreate(void) { + xmlParserNsData *nsdb = xmlMalloc(sizeof(*nsdb)); + + if (nsdb == NULL) + return(NULL); + memset(nsdb, 0, sizeof(*nsdb)); + nsdb->defaultNsIndex = INT_MAX; + + return(nsdb); +} + +/** + * xmlParserNsFree: + * @nsdb: namespace database + * + * Free a namespace database. + */ +void +xmlParserNsFree(xmlParserNsData *nsdb) { + if (nsdb == NULL) + return; + + xmlFree(nsdb->extra); + xmlFree(nsdb->hash); + xmlFree(nsdb); +} + +/** + * xmlParserNsReset: + * @nsdb: namespace database + * + * Reset a namespace database. + */ +static void +xmlParserNsReset(xmlParserNsData *nsdb) { + if (nsdb == NULL) + return; + + nsdb->hashElems = 0; + nsdb->elementId = 0; + nsdb->defaultNsIndex = INT_MAX; + + if (nsdb->hash) + memset(nsdb->hash, 0, nsdb->hashSize * sizeof(nsdb->hash[0])); +} + +/** + * xmlParserStartElement: + * @nsdb: namespace database + * + * Signal that a new element has started. + * + * Returns 0 on success, -1 if the element counter overflowed. + */ +static int +xmlParserNsStartElement(xmlParserNsData *nsdb) { + if (nsdb->elementId == UINT_MAX) + return(-1); + nsdb->elementId++; + + return(0); +} + +/** + * xmlParserNsLookup: + * @ctxt: parser context + * @prefix: namespace prefix + * @bucketPtr: optional bucket (return value) + * + * Lookup namespace with given prefix. If @bucketPtr is non-NULL, it will + * be set to the matching bucket, or the first empty bucket if no match + * was found. + * + * Returns the namespace index on success, INT_MAX if no namespace was + * found. + */ +static int +xmlParserNsLookup(xmlParserCtxtPtr ctxt, const xmlHashedString *prefix, + xmlParserNsBucket **bucketPtr) { + xmlParserNsBucket *bucket, *tombstone; + unsigned index, hashValue; + + if (prefix->name == NULL) + return(ctxt->nsdb->defaultNsIndex); + + if (ctxt->nsdb->hashSize == 0) + return(INT_MAX); + + hashValue = prefix->hashValue; + index = hashValue & (ctxt->nsdb->hashSize - 1); + bucket = &ctxt->nsdb->hash[index]; + tombstone = NULL; + + while (bucket->hashValue) { + if (bucket->index == INT_MAX) { + if (tombstone == NULL) + tombstone = bucket; + } else if (bucket->hashValue == hashValue) { + if (ctxt->nsTab[bucket->index * 2] == prefix->name) { + if (bucketPtr != NULL) + *bucketPtr = bucket; + return(bucket->index); + } + } + + index++; + bucket++; + if (index == ctxt->nsdb->hashSize) { + index = 0; + bucket = ctxt->nsdb->hash; + } + } + + if (bucketPtr != NULL) + *bucketPtr = tombstone ? tombstone : bucket; + return(INT_MAX); +} + +/** + * xmlParserNsLookupUri: + * @ctxt: parser context + * @prefix: namespace prefix + * + * Lookup namespace URI with given prefix. + * + * Returns the namespace URI on success, NULL if no namespace was found. + */ +static const xmlChar * +xmlParserNsLookupUri(xmlParserCtxtPtr ctxt, const xmlHashedString *prefix) { + const xmlChar *ret; + int nsIndex; + + if (prefix->name == ctxt->str_xml) + return(ctxt->str_xml_ns); + + /* + * minNsIndex is used when building an entity tree. We must + * ignore namespaces declared outside the entity. + */ + nsIndex = xmlParserNsLookup(ctxt, prefix, NULL); + if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex)) + return(NULL); + + ret = ctxt->nsTab[nsIndex * 2 + 1]; + if (ret[0] == 0) + ret = NULL; + return(ret); +} + +/** + * xmlParserNsLookupSax: + * @ctxt: parser context + * @prefix: namespace prefix + * + * Lookup extra data for the given prefix. This returns data stored + * with xmlParserNsUdpateSax. + * + * Returns the data on success, NULL if no namespace was found. + */ +void * +xmlParserNsLookupSax(xmlParserCtxtPtr ctxt, const xmlChar *prefix) { + xmlHashedString hprefix; + int nsIndex; + + if (prefix == ctxt->str_xml) + return(NULL); + + hprefix.name = prefix; + if (prefix != NULL) + hprefix.hashValue = xmlDictComputeHash(ctxt->dict, prefix); + else + hprefix.hashValue = 0; + nsIndex = xmlParserNsLookup(ctxt, &hprefix, NULL); + if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex)) + return(NULL); + + return(ctxt->nsdb->extra[nsIndex].saxData); +} + +/** + * xmlParserNsUpdateSax: + * @ctxt: parser context + * @prefix: namespace prefix + * @saxData: extra data for SAX handler + * + * Sets or updates extra data for the given prefix. This value will be + * returned by xmlParserNsLookupSax as long as the namespace with the + * given prefix is in scope. + * + * Returns the data on success, NULL if no namespace was found. + */ +int +xmlParserNsUpdateSax(xmlParserCtxtPtr ctxt, const xmlChar *prefix, + void *saxData) { + xmlHashedString hprefix; + int nsIndex; + + if (prefix == ctxt->str_xml) + return(-1); + + hprefix.name = prefix; + if (prefix != NULL) + hprefix.hashValue = xmlDictComputeHash(ctxt->dict, prefix); + else + hprefix.hashValue = 0; + nsIndex = xmlParserNsLookup(ctxt, &hprefix, NULL); + if ((nsIndex == INT_MAX) || (nsIndex < ctxt->nsdb->minNsIndex)) + return(-1); + + ctxt->nsdb->extra[nsIndex].saxData = saxData; + return(0); +} + +/** + * xmlParserNsGrow: + * @ctxt: parser context + * + * Grows the namespace tables. + * + * Returns 0 on success, -1 if a memory allocation failed. + */ +static int +xmlParserNsGrow(xmlParserCtxtPtr ctxt) { + const xmlChar **table; + xmlParserNsExtra *extra; + int newSize; + + if (ctxt->nsMax > INT_MAX / 2) + goto error; + newSize = ctxt->nsMax ? ctxt->nsMax * 2 : 16; + + table = xmlRealloc(ctxt->nsTab, 2 * newSize * sizeof(table[0])); + if (table == NULL) + goto error; + ctxt->nsTab = table; + + extra = xmlRealloc(ctxt->nsdb->extra, newSize * sizeof(extra[0])); + if (extra == NULL) + goto error; + ctxt->nsdb->extra = extra; + + ctxt->nsMax = newSize; + return(0); + +error: + xmlErrMemory(ctxt); + return(-1); +} + +/** + * xmlParserNsPush: + * @ctxt: parser context + * @prefix: prefix with hash value + * @uri: uri with hash value + * @saxData: extra data for SAX handler + * @defAttr: whether the namespace comes from a default attribute + * + * Push a new namespace on the table. + * + * Returns 1 if the namespace was pushed, 0 if the namespace was ignored, + * -1 if a memory allocation failed. + */ +static int +xmlParserNsPush(xmlParserCtxtPtr ctxt, const xmlHashedString *prefix, + const xmlHashedString *uri, void *saxData, int defAttr) { + xmlParserNsBucket *bucket = NULL; + xmlParserNsExtra *extra; + const xmlChar **ns; + unsigned hashValue, nsIndex, oldIndex; + + if ((prefix != NULL) && (prefix->name == ctxt->str_xml)) + return(0); + + if ((ctxt->nsNr >= ctxt->nsMax) && (xmlParserNsGrow(ctxt) < 0)) { + xmlErrMemory(ctxt); + return(-1); + } + + /* + * Default namespace and 'xml' namespace + */ + if ((prefix == NULL) || (prefix->name == NULL)) { + oldIndex = ctxt->nsdb->defaultNsIndex; + + if (oldIndex != INT_MAX) { + extra = &ctxt->nsdb->extra[oldIndex]; + + if (extra->elementId == ctxt->nsdb->elementId) { + if (defAttr == 0) + xmlErrAttributeDup(ctxt, NULL, BAD_CAST "xmlns"); + return(0); + } + + if ((ctxt->options & XML_PARSE_NSCLEAN) && + (uri->name == ctxt->nsTab[oldIndex * 2 + 1])) + return(0); + } + + ctxt->nsdb->defaultNsIndex = ctxt->nsNr; + goto populate_entry; + } + + /* + * Hash table lookup + */ + oldIndex = xmlParserNsLookup(ctxt, prefix, &bucket); + if (oldIndex != INT_MAX) { + extra = &ctxt->nsdb->extra[oldIndex]; + + /* + * Check for duplicate definitions on the same element. + */ + if (extra->elementId == ctxt->nsdb->elementId) { + if (defAttr == 0) + xmlErrAttributeDup(ctxt, BAD_CAST "xmlns", prefix->name); + return(0); + } + + if ((ctxt->options & XML_PARSE_NSCLEAN) && + (uri->name == ctxt->nsTab[bucket->index * 2 + 1])) + return(0); + + bucket->index = ctxt->nsNr; + goto populate_entry; + } + + /* + * Insert new bucket + */ + + hashValue = prefix->hashValue; + + /* + * Grow hash table, 50% fill factor + */ + if (ctxt->nsdb->hashElems + 1 > ctxt->nsdb->hashSize / 2) { + xmlParserNsBucket *newHash; + unsigned newSize, i, index; + + if (ctxt->nsdb->hashSize > UINT_MAX / 2) { + xmlErrMemory(ctxt); + return(-1); + } + newSize = ctxt->nsdb->hashSize ? ctxt->nsdb->hashSize * 2 : 16; + newHash = xmlMalloc(newSize * sizeof(newHash[0])); + if (newHash == NULL) { + xmlErrMemory(ctxt); + return(-1); + } + memset(newHash, 0, newSize * sizeof(newHash[0])); + + for (i = 0; i < ctxt->nsdb->hashSize; i++) { + unsigned hv = ctxt->nsdb->hash[i].hashValue; + unsigned newIndex; + + if ((hv == 0) || (ctxt->nsdb->hash[i].index == INT_MAX)) + continue; + newIndex = hv & (newSize - 1); + + while (newHash[newIndex].hashValue != 0) { + newIndex++; + if (newIndex == newSize) + newIndex = 0; + } + + newHash[newIndex] = ctxt->nsdb->hash[i]; + } + + xmlFree(ctxt->nsdb->hash); + ctxt->nsdb->hash = newHash; + ctxt->nsdb->hashSize = newSize; + + /* + * Relookup + */ + index = hashValue & (newSize - 1); + + while (newHash[index].hashValue != 0) { + index++; + if (index == newSize) + index = 0; + } + + bucket = &newHash[index]; + } + + bucket->hashValue = hashValue; + bucket->index = ctxt->nsNr; + ctxt->nsdb->hashElems++; + oldIndex = INT_MAX; + +populate_entry: + nsIndex = ctxt->nsNr; + + ns = &ctxt->nsTab[nsIndex * 2]; + ns[0] = prefix ? prefix->name : NULL; + ns[1] = uri->name; + + extra = &ctxt->nsdb->extra[nsIndex]; + extra->saxData = saxData; + extra->prefixHashValue = prefix ? prefix->hashValue : 0; + extra->uriHashValue = uri->hashValue; + extra->elementId = ctxt->nsdb->elementId; + extra->oldIndex = oldIndex; + + ctxt->nsNr++; + + return(1); +} + +/** + * xmlParserNsPop: + * @ctxt: an XML parser context + * @nr: the number to pop + * + * Pops the top @nr namespaces and restores the hash table. + * + * Returns the number of namespaces popped. + */ +static int +xmlParserNsPop(xmlParserCtxtPtr ctxt, int nr) +{ + int i; + + /* assert(nr <= ctxt->nsNr); */ + + for (i = ctxt->nsNr - 1; i >= ctxt->nsNr - nr; i--) { + const xmlChar *prefix = ctxt->nsTab[i * 2]; + xmlParserNsExtra *extra = &ctxt->nsdb->extra[i]; + + if (prefix == NULL) { + ctxt->nsdb->defaultNsIndex = extra->oldIndex; + } else { + xmlHashedString hprefix; + xmlParserNsBucket *bucket = NULL; + + hprefix.name = prefix; + hprefix.hashValue = extra->prefixHashValue; + xmlParserNsLookup(ctxt, &hprefix, &bucket); + /* assert(bucket && bucket->hashValue); */ + bucket->index = extra->oldIndex; + } + } + + ctxt->nsNr -= nr; + return(nr); +} + +static int +xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt) { + const xmlChar **atts; + unsigned *attallocs; + int maxatts = ctxt->maxatts; + + if (maxatts == 0) { + maxatts = 50; + } else { + if ((maxatts > INT_MAX / 2 - 5) || + ((size_t) maxatts > SIZE_MAX / 2 / sizeof(const xmlChar *))) + goto mem_error; + maxatts *= 2; + } + + atts = xmlMalloc(maxatts * sizeof(const xmlChar *)); + if (atts == NULL) + goto mem_error; + attallocs = xmlRealloc(ctxt->attallocs, + (maxatts / 5) * sizeof(attallocs[0])); + if (attallocs == NULL) { + xmlFree(atts); + goto mem_error; + } + if (ctxt->maxatts > 0) + memcpy(atts, ctxt->atts, ctxt->maxatts * sizeof(const xmlChar *)); + xmlFree(ctxt->atts); + + ctxt->atts = atts; + ctxt->attallocs = attallocs; + ctxt->maxatts = maxatts; + + return(maxatts); + +mem_error: + xmlErrMemory(ctxt); + return(-1); +} + +/** + * xmlCtxtPushInput: + * @ctxt: an XML parser context + * @value: the parser input + * + * Pushes a new parser input on top of the input stack + * + * Returns -1 in case of error, the index in the stack otherwise + */ +int +xmlCtxtPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr value) +{ + char *directory = NULL; + int maxDepth; + + if ((ctxt == NULL) || (value == NULL)) + return(-1); + + maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20; + if (ctxt->inputNr > maxDepth) { + xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, + "Maximum entity nesting depth exceeded"); + xmlHaltParser(ctxt); + return(-1); + } + + if (ctxt->inputNr >= ctxt->inputMax) { + size_t newSize = ctxt->inputMax * 2; + xmlParserInputPtr *tmp; + + tmp = (xmlParserInputPtr *) xmlRealloc(ctxt->inputTab, + newSize * sizeof(*tmp)); + if (tmp == NULL) { + xmlErrMemory(ctxt); + return (-1); + } + ctxt->inputTab = tmp; + ctxt->inputMax = newSize; + } + + if ((ctxt->inputNr == 0) && (value->filename != NULL)) { + directory = xmlParserGetDirectory(value->filename); + if (directory == NULL) { + xmlErrMemory(ctxt); + return(-1); + } + } + + if (ctxt->input_id >= INT_MAX) { + xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, "Input ID overflow\n"); + return(-1); + } + + ctxt->inputTab[ctxt->inputNr] = value; + ctxt->input = value; + + if (ctxt->inputNr == 0) { + xmlFree(ctxt->directory); + ctxt->directory = directory; + } + + /* + * Internally, the input ID is only used to detect parameter entity + * boundaries. But there are entity loaders in downstream code that + * detect the main document by checking for "input_id == 1". + */ + value->id = ctxt->input_id++; + + return(ctxt->inputNr++); +} + +/** + * xmlCtxtPopInput: + * @ctxt: an XML parser context + * + * Pops the top parser input from the input stack + * + * Returns the input just removed + */ +xmlParserInputPtr +xmlCtxtPopInput(xmlParserCtxtPtr ctxt) +{ + xmlParserInputPtr ret; + + if (ctxt == NULL) + return(NULL); + if (ctxt->inputNr <= 0) + return (NULL); + ctxt->inputNr--; + if (ctxt->inputNr > 0) + ctxt->input = ctxt->inputTab[ctxt->inputNr - 1]; + else + ctxt->input = NULL; + ret = ctxt->inputTab[ctxt->inputNr]; + ctxt->inputTab[ctxt->inputNr] = NULL; + return (ret); +} + +/** + * inputPush: + * @ctxt: an XML parser context + * @value: the parser input + * + * Pushes a new parser input on top of the input stack + * + * Returns -1 in case of error, the index in the stack otherwise + */ +int +inputPush(xmlParserCtxtPtr ctxt, xmlParserInputPtr value) +{ + return(xmlCtxtPushInput(ctxt, value)); +} +/** + * inputPop: + * @ctxt: an XML parser context + * + * Pops the top parser input from the input stack + * + * Returns the input just removed + */ +xmlParserInputPtr +inputPop(xmlParserCtxtPtr ctxt) +{ + return(xmlCtxtPopInput(ctxt)); +} +/** + * nodePush: + * @ctxt: an XML parser context + * @value: the element node + * + * DEPRECATED: Internal function, do not use. + * + * Pushes a new element node on top of the node stack + * + * Returns -1 in case of error, the index in the stack otherwise + */ +int +nodePush(xmlParserCtxtPtr ctxt, xmlNodePtr value) +{ + int maxDepth; + + if (ctxt == NULL) + return(0); + + maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 2048 : 256; + if (ctxt->nodeNr > maxDepth) { + xmlFatalErrMsgInt(ctxt, XML_ERR_RESOURCE_LIMIT, + "Excessive depth in document: %d use XML_PARSE_HUGE option\n", + ctxt->nodeNr); + xmlHaltParser(ctxt); + return(-1); + } + if (ctxt->nodeNr >= ctxt->nodeMax) { + xmlNodePtr *tmp; + + tmp = (xmlNodePtr *) xmlRealloc(ctxt->nodeTab, + ctxt->nodeMax * 2 * + sizeof(ctxt->nodeTab[0])); + if (tmp == NULL) { + xmlErrMemory(ctxt); + return (-1); + } + ctxt->nodeTab = tmp; + ctxt->nodeMax *= 2; + } + ctxt->nodeTab[ctxt->nodeNr] = value; + ctxt->node = value; + return (ctxt->nodeNr++); +} + +/** + * nodePop: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, do not use. + * + * Pops the top element node from the node stack + * + * Returns the node just removed + */ +xmlNodePtr +nodePop(xmlParserCtxtPtr ctxt) +{ + xmlNodePtr ret; + + if (ctxt == NULL) return(NULL); + if (ctxt->nodeNr <= 0) + return (NULL); + ctxt->nodeNr--; + if (ctxt->nodeNr > 0) + ctxt->node = ctxt->nodeTab[ctxt->nodeNr - 1]; + else + ctxt->node = NULL; + ret = ctxt->nodeTab[ctxt->nodeNr]; + ctxt->nodeTab[ctxt->nodeNr] = NULL; + return (ret); +} + +/** + * nameNsPush: + * @ctxt: an XML parser context + * @value: the element name + * @prefix: the element prefix + * @URI: the element namespace name + * @line: the current line number for error messages + * @nsNr: the number of namespaces pushed on the namespace table + * + * Pushes a new element name/prefix/URL on top of the name stack + * + * Returns -1 in case of error, the index in the stack otherwise + */ +static int +nameNsPush(xmlParserCtxtPtr ctxt, const xmlChar * value, + const xmlChar *prefix, const xmlChar *URI, int line, int nsNr) +{ + xmlStartTag *tag; + + if (ctxt->nameNr >= ctxt->nameMax) { + const xmlChar * *tmp; + xmlStartTag *tmp2; + ctxt->nameMax *= 2; + tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab, + ctxt->nameMax * + sizeof(ctxt->nameTab[0])); + if (tmp == NULL) { + ctxt->nameMax /= 2; + goto mem_error; + } + ctxt->nameTab = tmp; + tmp2 = (xmlStartTag *) xmlRealloc((void * *)ctxt->pushTab, + ctxt->nameMax * + sizeof(ctxt->pushTab[0])); + if (tmp2 == NULL) { + ctxt->nameMax /= 2; + goto mem_error; + } + ctxt->pushTab = tmp2; + } else if (ctxt->pushTab == NULL) { + ctxt->pushTab = (xmlStartTag *) xmlMalloc(ctxt->nameMax * + sizeof(ctxt->pushTab[0])); + if (ctxt->pushTab == NULL) + goto mem_error; + } + ctxt->nameTab[ctxt->nameNr] = value; + ctxt->name = value; + tag = &ctxt->pushTab[ctxt->nameNr]; + tag->prefix = prefix; + tag->URI = URI; + tag->line = line; + tag->nsNr = nsNr; + return (ctxt->nameNr++); +mem_error: + xmlErrMemory(ctxt); + return (-1); +} +#ifdef LIBXML_PUSH_ENABLED +/** + * nameNsPop: + * @ctxt: an XML parser context + * + * Pops the top element/prefix/URI name from the name stack + * + * Returns the name just removed + */ +static const xmlChar * +nameNsPop(xmlParserCtxtPtr ctxt) +{ + const xmlChar *ret; + + if (ctxt->nameNr <= 0) + return (NULL); + ctxt->nameNr--; + if (ctxt->nameNr > 0) + ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; + else + ctxt->name = NULL; + ret = ctxt->nameTab[ctxt->nameNr]; + ctxt->nameTab[ctxt->nameNr] = NULL; + return (ret); +} +#endif /* LIBXML_PUSH_ENABLED */ + +/** + * namePush: + * @ctxt: an XML parser context + * @value: the element name + * + * DEPRECATED: Internal function, do not use. + * + * Pushes a new element name on top of the name stack + * + * Returns -1 in case of error, the index in the stack otherwise + */ +int +namePush(xmlParserCtxtPtr ctxt, const xmlChar * value) +{ + if (ctxt == NULL) return (-1); + + if (ctxt->nameNr >= ctxt->nameMax) { + const xmlChar * *tmp; + tmp = (const xmlChar * *) xmlRealloc((xmlChar * *)ctxt->nameTab, + ctxt->nameMax * 2 * + sizeof(ctxt->nameTab[0])); + if (tmp == NULL) { + goto mem_error; + } + ctxt->nameTab = tmp; + ctxt->nameMax *= 2; + } + ctxt->nameTab[ctxt->nameNr] = value; + ctxt->name = value; + return (ctxt->nameNr++); +mem_error: + xmlErrMemory(ctxt); + return (-1); +} + +/** + * namePop: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, do not use. + * + * Pops the top element name from the name stack + * + * Returns the name just removed + */ +const xmlChar * +namePop(xmlParserCtxtPtr ctxt) +{ + const xmlChar *ret; + + if ((ctxt == NULL) || (ctxt->nameNr <= 0)) + return (NULL); + ctxt->nameNr--; + if (ctxt->nameNr > 0) + ctxt->name = ctxt->nameTab[ctxt->nameNr - 1]; + else + ctxt->name = NULL; + ret = ctxt->nameTab[ctxt->nameNr]; + ctxt->nameTab[ctxt->nameNr] = NULL; + return (ret); +} + +static int spacePush(xmlParserCtxtPtr ctxt, int val) { + if (ctxt->spaceNr >= ctxt->spaceMax) { + int *tmp; + + ctxt->spaceMax *= 2; + tmp = (int *) xmlRealloc(ctxt->spaceTab, + ctxt->spaceMax * sizeof(ctxt->spaceTab[0])); + if (tmp == NULL) { + xmlErrMemory(ctxt); + ctxt->spaceMax /=2; + return(-1); + } + ctxt->spaceTab = tmp; + } + ctxt->spaceTab[ctxt->spaceNr] = val; + ctxt->space = &ctxt->spaceTab[ctxt->spaceNr]; + return(ctxt->spaceNr++); +} + +static int spacePop(xmlParserCtxtPtr ctxt) { + int ret; + if (ctxt->spaceNr <= 0) return(0); + ctxt->spaceNr--; + if (ctxt->spaceNr > 0) + ctxt->space = &ctxt->spaceTab[ctxt->spaceNr - 1]; + else + ctxt->space = &ctxt->spaceTab[0]; + ret = ctxt->spaceTab[ctxt->spaceNr]; + ctxt->spaceTab[ctxt->spaceNr] = -1; + return(ret); +} + +/* + * Macros for accessing the content. Those should be used only by the parser, + * and not exported. + * + * Dirty macros, i.e. one often need to make assumption on the context to + * use them + * + * CUR_PTR return the current pointer to the xmlChar to be parsed. + * To be used with extreme caution since operations consuming + * characters may move the input buffer to a different location ! + * CUR returns the current xmlChar value, i.e. a 8 bit value if compiled + * This should be used internally by the parser + * only to compare to ASCII values otherwise it would break when + * running with UTF-8 encoding. + * RAW same as CUR but in the input buffer, bypass any token + * extraction that may have been done + * NXT(n) returns the n'th next xmlChar. Same as CUR is should be used only + * to compare on ASCII based substring. + * SKIP(n) Skip n xmlChar, and must also be used only to skip ASCII defined + * strings without newlines within the parser. + * NEXT1(l) Skip 1 xmlChar, and must also be used only to skip 1 non-newline ASCII + * defined char within the parser. + * Clean macros, not dependent of an ASCII context, expect UTF-8 encoding + * + * NEXT Skip to the next character, this does the proper decoding + * in UTF-8 mode. It also pop-up unfinished entities on the fly. + * NEXTL(l) Skip the current unicode character of l xmlChars long. + * CUR_SCHAR same but operate on a string instead of the context + * COPY_BUF copy the current unicode char to the target buffer, increment + * the index + * GROW, SHRINK handling of input buffers + */ + +#define RAW (*ctxt->input->cur) +#define CUR (*ctxt->input->cur) +#define NXT(val) ctxt->input->cur[(val)] +#define CUR_PTR ctxt->input->cur +#define BASE_PTR ctxt->input->base + +#define CMP4( s, c1, c2, c3, c4 ) \ + ( ((unsigned char *) s)[ 0 ] == c1 && ((unsigned char *) s)[ 1 ] == c2 && \ + ((unsigned char *) s)[ 2 ] == c3 && ((unsigned char *) s)[ 3 ] == c4 ) +#define CMP5( s, c1, c2, c3, c4, c5 ) \ + ( CMP4( s, c1, c2, c3, c4 ) && ((unsigned char *) s)[ 4 ] == c5 ) +#define CMP6( s, c1, c2, c3, c4, c5, c6 ) \ + ( CMP5( s, c1, c2, c3, c4, c5 ) && ((unsigned char *) s)[ 5 ] == c6 ) +#define CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) \ + ( CMP6( s, c1, c2, c3, c4, c5, c6 ) && ((unsigned char *) s)[ 6 ] == c7 ) +#define CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) \ + ( CMP7( s, c1, c2, c3, c4, c5, c6, c7 ) && ((unsigned char *) s)[ 7 ] == c8 ) +#define CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) \ + ( CMP8( s, c1, c2, c3, c4, c5, c6, c7, c8 ) && \ + ((unsigned char *) s)[ 8 ] == c9 ) +#define CMP10( s, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10 ) \ + ( CMP9( s, c1, c2, c3, c4, c5, c6, c7, c8, c9 ) && \ + ((unsigned char *) s)[ 9 ] == c10 ) + +#define SKIP(val) do { \ + ctxt->input->cur += (val),ctxt->input->col+=(val); \ + if (*ctxt->input->cur == 0) \ + xmlParserGrow(ctxt); \ + } while (0) + +#define SKIPL(val) do { \ + int skipl; \ + for(skipl=0; skiplinput->cur) == '\n') { \ + ctxt->input->line++; ctxt->input->col = 1; \ + } else ctxt->input->col++; \ + ctxt->input->cur++; \ + } \ + if (*ctxt->input->cur == 0) \ + xmlParserGrow(ctxt); \ + } while (0) + +#define SHRINK \ + if ((!PARSER_PROGRESSIVE(ctxt)) && \ + (ctxt->input->cur - ctxt->input->base > 2 * INPUT_CHUNK) && \ + (ctxt->input->end - ctxt->input->cur < 2 * INPUT_CHUNK)) \ + xmlParserShrink(ctxt); + +#define GROW \ + if ((!PARSER_PROGRESSIVE(ctxt)) && \ + (ctxt->input->end - ctxt->input->cur < INPUT_CHUNK)) \ + xmlParserGrow(ctxt); + +#define SKIP_BLANKS xmlSkipBlankChars(ctxt) + +#define SKIP_BLANKS_PE xmlSkipBlankCharsPE(ctxt) + +#define NEXT xmlNextChar(ctxt) + +#define NEXT1 { \ + ctxt->input->col++; \ + ctxt->input->cur++; \ + if (*ctxt->input->cur == 0) \ + xmlParserGrow(ctxt); \ + } + +#define NEXTL(l) do { \ + if (*(ctxt->input->cur) == '\n') { \ + ctxt->input->line++; ctxt->input->col = 1; \ + } else ctxt->input->col++; \ + ctxt->input->cur += l; \ + } while (0) + +#define CUR_SCHAR(s, l) xmlStringCurrentChar(ctxt, s, &l) + +#define COPY_BUF(b, i, v) \ + if (v < 0x80) b[i++] = v; \ + else i += xmlCopyCharMultiByte(&b[i],v) + +static int +xmlCurrentCharRecover(xmlParserCtxtPtr ctxt, int *len) { + int c = xmlCurrentChar(ctxt, len); + + if (c == XML_INVALID_CHAR) + c = 0xFFFD; /* replacement character */ + + return(c); +} + +/** + * xmlSkipBlankChars: + * @ctxt: the XML parser context + * + * DEPRECATED: Internal function, do not use. + * + * Skip whitespace in the input stream. + * + * Returns the number of space chars skipped + */ +int +xmlSkipBlankChars(xmlParserCtxtPtr ctxt) { + const xmlChar *cur; + int res = 0; + + /* + * It's Okay to use CUR/NEXT here since all the blanks are on + * the ASCII range. + */ + cur = ctxt->input->cur; + while (IS_BLANK_CH(*cur)) { + if (*cur == '\n') { + ctxt->input->line++; ctxt->input->col = 1; + } else { + ctxt->input->col++; + } + cur++; + if (res < INT_MAX) + res++; + if (*cur == 0) { + ctxt->input->cur = cur; + xmlParserGrow(ctxt); + cur = ctxt->input->cur; + } + } + ctxt->input->cur = cur; + + return(res); +} + +static void +xmlPopPE(xmlParserCtxtPtr ctxt) { + unsigned long consumed; + xmlEntityPtr ent; + + ent = ctxt->input->entity; + + ent->flags &= ~XML_ENT_EXPANDING; + + if ((ent->flags & XML_ENT_CHECKED) == 0) { + int result; + + /* + * Read the rest of the stream in case of errors. We want + * to account for the whole entity size. + */ + do { + ctxt->input->cur = ctxt->input->end; + xmlParserShrink(ctxt); + result = xmlParserGrow(ctxt); + } while (result > 0); + + consumed = ctxt->input->consumed; + xmlSaturatedAddSizeT(&consumed, + ctxt->input->end - ctxt->input->base); + + xmlSaturatedAdd(&ent->expandedSize, consumed); + + /* + * Add to sizeentities when parsing an external entity + * for the first time. + */ + if (ent->etype == XML_EXTERNAL_PARAMETER_ENTITY) { + xmlSaturatedAdd(&ctxt->sizeentities, consumed); + } + + ent->flags |= XML_ENT_CHECKED; + } + + xmlFreeInputStream(xmlCtxtPopInput(ctxt)); + + xmlParserEntityCheck(ctxt, ent->expandedSize); + + GROW; +} + +/** + * xmlSkipBlankCharsPE: + * @ctxt: the XML parser context + * + * Skip whitespace in the input stream, also handling parameter + * entities. + * + * Returns the number of space chars skipped + */ +static int +xmlSkipBlankCharsPE(xmlParserCtxtPtr ctxt) { + int res = 0; + int inParam; + int expandParam; + + inParam = PARSER_IN_PE(ctxt); + expandParam = PARSER_EXTERNAL(ctxt); + + if (!inParam && !expandParam) + return(xmlSkipBlankChars(ctxt)); + + while (PARSER_STOPPED(ctxt) == 0) { + if (IS_BLANK_CH(CUR)) { /* CHECKED tstblanks.xml */ + NEXT; + } else if (CUR == '%') { + if ((expandParam == 0) || + (IS_BLANK_CH(NXT(1))) || (NXT(1) == 0)) + break; + + /* + * Expand parameter entity. We continue to consume + * whitespace at the start of the entity and possible + * even consume the whole entity and pop it. We might + * even pop multiple PEs in this loop. + */ + xmlParsePEReference(ctxt); + + inParam = PARSER_IN_PE(ctxt); + expandParam = PARSER_EXTERNAL(ctxt); + } else if (CUR == 0) { + if (inParam == 0) + break; + + xmlPopPE(ctxt); + + inParam = PARSER_IN_PE(ctxt); + expandParam = PARSER_EXTERNAL(ctxt); + } else { + break; + } + + /* + * Also increase the counter when entering or exiting a PERef. + * The spec says: "When a parameter-entity reference is recognized + * in the DTD and included, its replacement text MUST be enlarged + * by the attachment of one leading and one following space (#x20) + * character." + */ + if (res < INT_MAX) + res++; + } + + return(res); +} + +/************************************************************************ + * * + * Commodity functions to handle entities * + * * + ************************************************************************/ + +/** + * xmlPopInput: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * Returns the current xmlChar in the parser context + */ +xmlChar +xmlPopInput(xmlParserCtxtPtr ctxt) { + xmlParserInputPtr input; + + if ((ctxt == NULL) || (ctxt->inputNr <= 1)) return(0); + input = xmlCtxtPopInput(ctxt); + xmlFreeInputStream(input); + if (*ctxt->input->cur == 0) + xmlParserGrow(ctxt); + return(CUR); +} + +/** + * xmlPushInput: + * @ctxt: an XML parser context + * @input: an XML parser input fragment (entity, XML fragment ...). + * + * DEPRECATED: Internal function, don't use. + * + * Push an input stream onto the stack. + * + * Returns -1 in case of error or the index in the input stack + */ +int +xmlPushInput(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) { + int ret; + + if ((ctxt == NULL) || (input == NULL)) + return(-1); + + ret = xmlCtxtPushInput(ctxt, input); + if (ret >= 0) + GROW; + return(ret); +} + +/** + * xmlParseCharRef: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * Parse a numeric character reference. Always consumes '&'. + * + * [66] CharRef ::= '&#' [0-9]+ ';' | + * '&#x' [0-9a-fA-F]+ ';' + * + * [ WFC: Legal Character ] + * Characters referred to using character references must match the + * production for Char. + * + * Returns the value parsed (as an int), 0 in case of error + */ +int +xmlParseCharRef(xmlParserCtxtPtr ctxt) { + int val = 0; + int count = 0; + + /* + * Using RAW/CUR/NEXT is okay since we are working on ASCII range here + */ + if ((RAW == '&') && (NXT(1) == '#') && + (NXT(2) == 'x')) { + SKIP(3); + GROW; + while ((RAW != ';') && (PARSER_STOPPED(ctxt) == 0)) { + if (count++ > 20) { + count = 0; + GROW; + } + if ((RAW >= '0') && (RAW <= '9')) + val = val * 16 + (CUR - '0'); + else if ((RAW >= 'a') && (RAW <= 'f') && (count < 20)) + val = val * 16 + (CUR - 'a') + 10; + else if ((RAW >= 'A') && (RAW <= 'F') && (count < 20)) + val = val * 16 + (CUR - 'A') + 10; + else { + xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL); + val = 0; + break; + } + if (val > 0x110000) + val = 0x110000; + + NEXT; + count++; + } + if (RAW == ';') { + /* on purpose to avoid reentrancy problems with NEXT and SKIP */ + ctxt->input->col++; + ctxt->input->cur++; + } + } else if ((RAW == '&') && (NXT(1) == '#')) { + SKIP(2); + GROW; + while (RAW != ';') { /* loop blocked by count */ + if (count++ > 20) { + count = 0; + GROW; + } + if ((RAW >= '0') && (RAW <= '9')) + val = val * 10 + (CUR - '0'); + else { + xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL); + val = 0; + break; + } + if (val > 0x110000) + val = 0x110000; + + NEXT; + count++; + } + if (RAW == ';') { + /* on purpose to avoid reentrancy problems with NEXT and SKIP */ + ctxt->input->col++; + ctxt->input->cur++; + } + } else { + if (RAW == '&') + SKIP(1); + xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL); + } + + /* + * [ WFC: Legal Character ] + * Characters referred to using character references must match the + * production for Char. + */ + if (val >= 0x110000) { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "xmlParseCharRef: character reference out of bounds\n", + val); + } else if (IS_CHAR(val)) { + return(val); + } else { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "xmlParseCharRef: invalid xmlChar value %d\n", + val); + } + return(0); +} + +/** + * xmlParseStringCharRef: + * @ctxt: an XML parser context + * @str: a pointer to an index in the string + * + * parse Reference declarations, variant parsing from a string rather + * than an an input flow. + * + * [66] CharRef ::= '&#' [0-9]+ ';' | + * '&#x' [0-9a-fA-F]+ ';' + * + * [ WFC: Legal Character ] + * Characters referred to using character references must match the + * production for Char. + * + * Returns the value parsed (as an int), 0 in case of error, str will be + * updated to the current value of the index + */ +static int +xmlParseStringCharRef(xmlParserCtxtPtr ctxt, const xmlChar **str) { + const xmlChar *ptr; + xmlChar cur; + int val = 0; + + if ((str == NULL) || (*str == NULL)) return(0); + ptr = *str; + cur = *ptr; + if ((cur == '&') && (ptr[1] == '#') && (ptr[2] == 'x')) { + ptr += 3; + cur = *ptr; + while (cur != ';') { /* Non input consuming loop */ + if ((cur >= '0') && (cur <= '9')) + val = val * 16 + (cur - '0'); + else if ((cur >= 'a') && (cur <= 'f')) + val = val * 16 + (cur - 'a') + 10; + else if ((cur >= 'A') && (cur <= 'F')) + val = val * 16 + (cur - 'A') + 10; + else { + xmlFatalErr(ctxt, XML_ERR_INVALID_HEX_CHARREF, NULL); + val = 0; + break; + } + if (val > 0x110000) + val = 0x110000; + + ptr++; + cur = *ptr; + } + if (cur == ';') + ptr++; + } else if ((cur == '&') && (ptr[1] == '#')){ + ptr += 2; + cur = *ptr; + while (cur != ';') { /* Non input consuming loops */ + if ((cur >= '0') && (cur <= '9')) + val = val * 10 + (cur - '0'); + else { + xmlFatalErr(ctxt, XML_ERR_INVALID_DEC_CHARREF, NULL); + val = 0; + break; + } + if (val > 0x110000) + val = 0x110000; + + ptr++; + cur = *ptr; + } + if (cur == ';') + ptr++; + } else { + xmlFatalErr(ctxt, XML_ERR_INVALID_CHARREF, NULL); + return(0); + } + *str = ptr; + + /* + * [ WFC: Legal Character ] + * Characters referred to using character references must match the + * production for Char. + */ + if (val >= 0x110000) { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "xmlParseStringCharRef: character reference out of bounds\n", + val); + } else if (IS_CHAR(val)) { + return(val); + } else { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "xmlParseStringCharRef: invalid xmlChar value %d\n", + val); + } + return(0); +} + +/** + * xmlParserHandlePEReference: + * @ctxt: the parser context + * + * DEPRECATED: Internal function, do not use. + * + * [69] PEReference ::= '%' Name ';' + * + * [ WFC: No Recursion ] + * A parsed entity must not contain a recursive + * reference to itself, either directly or indirectly. + * + * [ WFC: Entity Declared ] + * In a document without any DTD, a document with only an internal DTD + * subset which contains no parameter entity references, or a document + * with "standalone='yes'", ... ... The declaration of a parameter + * entity must precede any reference to it... + * + * [ VC: Entity Declared ] + * In a document with an external subset or external parameter entities + * with "standalone='no'", ... ... The declaration of a parameter entity + * must precede any reference to it... + * + * [ WFC: In DTD ] + * Parameter-entity references may only appear in the DTD. + * NOTE: misleading but this is handled. + * + * A PEReference may have been detected in the current input stream + * the handling is done accordingly to + * http://www.w3.org/TR/REC-xml#entproc + * i.e. + * - Included in literal in entity values + * - Included as Parameter Entity reference within DTDs + */ +void +xmlParserHandlePEReference(xmlParserCtxtPtr ctxt) { + xmlParsePEReference(ctxt); +} + +/** + * xmlStringLenDecodeEntities: + * @ctxt: the parser context + * @str: the input string + * @len: the string length + * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF + * @end: an end marker xmlChar, 0 if none + * @end2: an end marker xmlChar, 0 if none + * @end3: an end marker xmlChar, 0 if none + * + * DEPRECATED: Internal function, don't use. + * + * Returns A newly allocated string with the substitution done. The caller + * must deallocate it ! + */ +xmlChar * +xmlStringLenDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, + int what ATTRIBUTE_UNUSED, + xmlChar end, xmlChar end2, xmlChar end3) { + if ((ctxt == NULL) || (str == NULL) || (len < 0)) + return(NULL); + + if ((str[len] != 0) || + (end != 0) || (end2 != 0) || (end3 != 0)) + return(NULL); + + return(xmlExpandEntitiesInAttValue(ctxt, str, 0)); +} + +/** + * xmlStringDecodeEntities: + * @ctxt: the parser context + * @str: the input string + * @what: combination of XML_SUBSTITUTE_REF and XML_SUBSTITUTE_PEREF + * @end: an end marker xmlChar, 0 if none + * @end2: an end marker xmlChar, 0 if none + * @end3: an end marker xmlChar, 0 if none + * + * DEPRECATED: Internal function, don't use. + * + * Returns A newly allocated string with the substitution done. The caller + * must deallocate it ! + */ +xmlChar * +xmlStringDecodeEntities(xmlParserCtxtPtr ctxt, const xmlChar *str, + int what ATTRIBUTE_UNUSED, + xmlChar end, xmlChar end2, xmlChar end3) { + if ((ctxt == NULL) || (str == NULL)) + return(NULL); + + if ((end != 0) || (end2 != 0) || (end3 != 0)) + return(NULL); + + return(xmlExpandEntitiesInAttValue(ctxt, str, 0)); +} + +/************************************************************************ + * * + * Commodity functions, cleanup needed ? * + * * + ************************************************************************/ + +/** + * areBlanks: + * @ctxt: an XML parser context + * @str: a xmlChar * + * @len: the size of @str + * @blank_chars: we know the chars are blanks + * + * Is this a sequence of blank chars that one can ignore ? + * + * Returns 1 if ignorable 0 otherwise. + */ + +static int areBlanks(xmlParserCtxtPtr ctxt, const xmlChar *str, int len, + int blank_chars) { + int i; + xmlNodePtr lastChild; + + /* + * Don't spend time trying to differentiate them, the same callback is + * used ! + */ + if (ctxt->sax->ignorableWhitespace == ctxt->sax->characters) + return(0); + + /* + * Check for xml:space value. + */ + if ((ctxt->space == NULL) || (*(ctxt->space) == 1) || + (*(ctxt->space) == -2)) + return(0); + + /* + * Check that the string is made of blanks + */ + if (blank_chars == 0) { + for (i = 0;i < len;i++) + if (!(IS_BLANK_CH(str[i]))) return(0); + } + + /* + * Look if the element is mixed content in the DTD if available + */ + if (ctxt->node == NULL) return(0); + if (ctxt->myDoc != NULL) { + xmlElementPtr elemDecl = NULL; + xmlDocPtr doc = ctxt->myDoc; + const xmlChar *prefix = NULL; + + if (ctxt->node->ns) + prefix = ctxt->node->ns->prefix; + if (doc->intSubset != NULL) + elemDecl = xmlHashLookup2(doc->intSubset->elements, ctxt->node->name, + prefix); + if ((elemDecl == NULL) && (doc->extSubset != NULL)) + elemDecl = xmlHashLookup2(doc->extSubset->elements, ctxt->node->name, + prefix); + if (elemDecl != NULL) { + if (elemDecl->etype == XML_ELEMENT_TYPE_ELEMENT) + return(1); + if ((elemDecl->etype == XML_ELEMENT_TYPE_ANY) || + (elemDecl->etype == XML_ELEMENT_TYPE_MIXED)) + return(0); + } + } + + /* + * Otherwise, heuristic :-\ + */ + if ((RAW != '<') && (RAW != 0xD)) return(0); + if ((ctxt->node->children == NULL) && + (RAW == '<') && (NXT(1) == '/')) return(0); + + lastChild = xmlGetLastChild(ctxt->node); + if (lastChild == NULL) { + if ((ctxt->node->type != XML_ELEMENT_NODE) && + (ctxt->node->content != NULL)) return(0); + } else if (xmlNodeIsText(lastChild)) + return(0); + else if ((ctxt->node->children != NULL) && + (xmlNodeIsText(ctxt->node->children))) + return(0); + return(1); +} + +/************************************************************************ + * * + * Extra stuff for namespace support * + * Relates to http://www.w3.org/TR/WD-xml-names * + * * + ************************************************************************/ + +/** + * xmlSplitQName: + * @ctxt: an XML parser context + * @name: an XML parser context + * @prefixOut: a xmlChar ** + * + * DEPRECATED: Don't use. + * + * parse an UTF8 encoded XML qualified name string + * + * [NS 5] QName ::= (Prefix ':')? LocalPart + * + * [NS 6] Prefix ::= NCName + * + * [NS 7] LocalPart ::= NCName + * + * Returns the local part, and prefix is updated + * to get the Prefix if any. + */ + +xmlChar * +xmlSplitQName(xmlParserCtxtPtr ctxt, const xmlChar *name, xmlChar **prefixOut) { + xmlChar buf[XML_MAX_NAMELEN + 5]; + xmlChar *buffer = NULL; + int len = 0; + int max = XML_MAX_NAMELEN; + xmlChar *ret = NULL; + xmlChar *prefix; + const xmlChar *cur = name; + int c; + + if (prefixOut == NULL) return(NULL); + *prefixOut = NULL; + + if (cur == NULL) return(NULL); + + /* nasty but well=formed */ + if (cur[0] == ':') + return(xmlStrdup(name)); + + c = *cur++; + while ((c != 0) && (c != ':') && (len < max)) { /* tested bigname.xml */ + buf[len++] = c; + c = *cur++; + } + if (len >= max) { + /* + * Okay someone managed to make a huge name, so he's ready to pay + * for the processing speed. + */ + max = len * 2; + + buffer = xmlMalloc(max); + if (buffer == NULL) { + xmlErrMemory(ctxt); + return(NULL); + } + memcpy(buffer, buf, len); + while ((c != 0) && (c != ':')) { /* tested bigname.xml */ + if (len + 10 > max) { + xmlChar *tmp; + + max *= 2; + tmp = (xmlChar *) xmlRealloc(buffer, max); + if (tmp == NULL) { + xmlFree(buffer); + xmlErrMemory(ctxt); + return(NULL); + } + buffer = tmp; + } + buffer[len++] = c; + c = *cur++; + } + buffer[len] = 0; + } + + if ((c == ':') && (*cur == 0)) { + if (buffer != NULL) + xmlFree(buffer); + return(xmlStrdup(name)); + } + + if (buffer == NULL) { + ret = xmlStrndup(buf, len); + if (ret == NULL) { + xmlErrMemory(ctxt); + return(NULL); + } + } else { + ret = buffer; + buffer = NULL; + max = XML_MAX_NAMELEN; + } + + + if (c == ':') { + c = *cur; + prefix = ret; + if (c == 0) { + ret = xmlStrndup(BAD_CAST "", 0); + if (ret == NULL) { + xmlFree(prefix); + return(NULL); + } + *prefixOut = prefix; + return(ret); + } + len = 0; + + /* + * Check that the first character is proper to start + * a new name + */ + if (!(((c >= 0x61) && (c <= 0x7A)) || + ((c >= 0x41) && (c <= 0x5A)) || + (c == '_') || (c == ':'))) { + int l; + int first = CUR_SCHAR(cur, l); + + if (!IS_LETTER(first) && (first != '_')) { + xmlFatalErrMsgStr(ctxt, XML_NS_ERR_QNAME, + "Name %s is not XML Namespace compliant\n", + name); + } + } + cur++; + + while ((c != 0) && (len < max)) { /* tested bigname2.xml */ + buf[len++] = c; + c = *cur++; + } + if (len >= max) { + /* + * Okay someone managed to make a huge name, so he's ready to pay + * for the processing speed. + */ + max = len * 2; + + buffer = xmlMalloc(max); + if (buffer == NULL) { + xmlErrMemory(ctxt); + xmlFree(prefix); + return(NULL); + } + memcpy(buffer, buf, len); + while (c != 0) { /* tested bigname2.xml */ + if (len + 10 > max) { + xmlChar *tmp; + + max *= 2; + tmp = (xmlChar *) xmlRealloc(buffer, max); + if (tmp == NULL) { + xmlErrMemory(ctxt); + xmlFree(prefix); + xmlFree(buffer); + return(NULL); + } + buffer = tmp; + } + buffer[len++] = c; + c = *cur++; + } + buffer[len] = 0; + } + + if (buffer == NULL) { + ret = xmlStrndup(buf, len); + if (ret == NULL) { + xmlFree(prefix); + return(NULL); + } + } else { + ret = buffer; + } + + *prefixOut = prefix; + } + + return(ret); +} + +/************************************************************************ + * * + * The parser itself * + * Relates to http://www.w3.org/TR/REC-xml * + * * + ************************************************************************/ + +/************************************************************************ + * * + * Routines to parse Name, NCName and NmToken * + * * + ************************************************************************/ + +/* + * The two following functions are related to the change of accepted + * characters for Name and NmToken in the Revision 5 of XML-1.0 + * They correspond to the modified production [4] and the new production [4a] + * changes in that revision. Also note that the macros used for the + * productions Letter, Digit, CombiningChar and Extender are not needed + * anymore. + * We still keep compatibility to pre-revision5 parsing semantic if the + * new XML_PARSE_OLD10 option is given to the parser. + */ +static int +xmlIsNameStartChar(xmlParserCtxtPtr ctxt, int c) { + if ((ctxt->options & XML_PARSE_OLD10) == 0) { + /* + * Use the new checks of production [4] [4a] amd [5] of the + * Update 5 of XML-1.0 + */ + if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ + (((c >= 'a') && (c <= 'z')) || + ((c >= 'A') && (c <= 'Z')) || + (c == '_') || (c == ':') || + ((c >= 0xC0) && (c <= 0xD6)) || + ((c >= 0xD8) && (c <= 0xF6)) || + ((c >= 0xF8) && (c <= 0x2FF)) || + ((c >= 0x370) && (c <= 0x37D)) || + ((c >= 0x37F) && (c <= 0x1FFF)) || + ((c >= 0x200C) && (c <= 0x200D)) || + ((c >= 0x2070) && (c <= 0x218F)) || + ((c >= 0x2C00) && (c <= 0x2FEF)) || + ((c >= 0x3001) && (c <= 0xD7FF)) || + ((c >= 0xF900) && (c <= 0xFDCF)) || + ((c >= 0xFDF0) && (c <= 0xFFFD)) || + ((c >= 0x10000) && (c <= 0xEFFFF)))) + return(1); + } else { + if (IS_LETTER(c) || (c == '_') || (c == ':')) + return(1); + } + return(0); +} + +static int +xmlIsNameChar(xmlParserCtxtPtr ctxt, int c) { + if ((ctxt->options & XML_PARSE_OLD10) == 0) { + /* + * Use the new checks of production [4] [4a] amd [5] of the + * Update 5 of XML-1.0 + */ + if ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ + (((c >= 'a') && (c <= 'z')) || + ((c >= 'A') && (c <= 'Z')) || + ((c >= '0') && (c <= '9')) || /* !start */ + (c == '_') || (c == ':') || + (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ + ((c >= 0xC0) && (c <= 0xD6)) || + ((c >= 0xD8) && (c <= 0xF6)) || + ((c >= 0xF8) && (c <= 0x2FF)) || + ((c >= 0x300) && (c <= 0x36F)) || /* !start */ + ((c >= 0x370) && (c <= 0x37D)) || + ((c >= 0x37F) && (c <= 0x1FFF)) || + ((c >= 0x200C) && (c <= 0x200D)) || + ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ + ((c >= 0x2070) && (c <= 0x218F)) || + ((c >= 0x2C00) && (c <= 0x2FEF)) || + ((c >= 0x3001) && (c <= 0xD7FF)) || + ((c >= 0xF900) && (c <= 0xFDCF)) || + ((c >= 0xFDF0) && (c <= 0xFFFD)) || + ((c >= 0x10000) && (c <= 0xEFFFF)))) + return(1); + } else { + if ((IS_LETTER(c)) || (IS_DIGIT(c)) || + (c == '.') || (c == '-') || + (c == '_') || (c == ':') || + (IS_COMBINING(c)) || + (IS_EXTENDER(c))) + return(1); + } + return(0); +} + +static const xmlChar * +xmlParseNameComplex(xmlParserCtxtPtr ctxt) { + const xmlChar *ret; + int len = 0, l; + int c; + int maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + + /* + * Handler for more complex cases + */ + c = xmlCurrentChar(ctxt, &l); + if ((ctxt->options & XML_PARSE_OLD10) == 0) { + /* + * Use the new checks of production [4] [4a] amd [5] of the + * Update 5 of XML-1.0 + */ + if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ + (!(((c >= 'a') && (c <= 'z')) || + ((c >= 'A') && (c <= 'Z')) || + (c == '_') || (c == ':') || + ((c >= 0xC0) && (c <= 0xD6)) || + ((c >= 0xD8) && (c <= 0xF6)) || + ((c >= 0xF8) && (c <= 0x2FF)) || + ((c >= 0x370) && (c <= 0x37D)) || + ((c >= 0x37F) && (c <= 0x1FFF)) || + ((c >= 0x200C) && (c <= 0x200D)) || + ((c >= 0x2070) && (c <= 0x218F)) || + ((c >= 0x2C00) && (c <= 0x2FEF)) || + ((c >= 0x3001) && (c <= 0xD7FF)) || + ((c >= 0xF900) && (c <= 0xFDCF)) || + ((c >= 0xFDF0) && (c <= 0xFFFD)) || + ((c >= 0x10000) && (c <= 0xEFFFF))))) { + return(NULL); + } + len += l; + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + while ((c != ' ') && (c != '>') && (c != '/') && /* accelerators */ + (((c >= 'a') && (c <= 'z')) || + ((c >= 'A') && (c <= 'Z')) || + ((c >= '0') && (c <= '9')) || /* !start */ + (c == '_') || (c == ':') || + (c == '-') || (c == '.') || (c == 0xB7) || /* !start */ + ((c >= 0xC0) && (c <= 0xD6)) || + ((c >= 0xD8) && (c <= 0xF6)) || + ((c >= 0xF8) && (c <= 0x2FF)) || + ((c >= 0x300) && (c <= 0x36F)) || /* !start */ + ((c >= 0x370) && (c <= 0x37D)) || + ((c >= 0x37F) && (c <= 0x1FFF)) || + ((c >= 0x200C) && (c <= 0x200D)) || + ((c >= 0x203F) && (c <= 0x2040)) || /* !start */ + ((c >= 0x2070) && (c <= 0x218F)) || + ((c >= 0x2C00) && (c <= 0x2FEF)) || + ((c >= 0x3001) && (c <= 0xD7FF)) || + ((c >= 0xF900) && (c <= 0xFDCF)) || + ((c >= 0xFDF0) && (c <= 0xFFFD)) || + ((c >= 0x10000) && (c <= 0xEFFFF)) + )) { + if (len <= INT_MAX - l) + len += l; + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + } + } else { + if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ + (!IS_LETTER(c) && (c != '_') && + (c != ':'))) { + return(NULL); + } + len += l; + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + + while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ + ((IS_LETTER(c)) || (IS_DIGIT(c)) || + (c == '.') || (c == '-') || + (c == '_') || (c == ':') || + (IS_COMBINING(c)) || + (IS_EXTENDER(c)))) { + if (len <= INT_MAX - l) + len += l; + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + } + } + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name"); + return(NULL); + } + if (ctxt->input->cur - ctxt->input->base < len) { + /* + * There were a couple of bugs where PERefs lead to to a change + * of the buffer. Check the buffer size to avoid passing an invalid + * pointer to xmlDictLookup. + */ + xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR, + "unexpected change of input buffer"); + return (NULL); + } + if ((*ctxt->input->cur == '\n') && (ctxt->input->cur[-1] == '\r')) + ret = xmlDictLookup(ctxt->dict, ctxt->input->cur - (len + 1), len); + else + ret = xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len); + if (ret == NULL) + xmlErrMemory(ctxt); + return(ret); +} + +/** + * xmlParseName: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * parse an XML name. + * + * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | + * CombiningChar | Extender + * + * [5] Name ::= (Letter | '_' | ':') (NameChar)* + * + * [6] Names ::= Name (#x20 Name)* + * + * Returns the Name parsed or NULL + */ + +const xmlChar * +xmlParseName(xmlParserCtxtPtr ctxt) { + const xmlChar *in; + const xmlChar *ret; + size_t count = 0; + size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + + GROW; + + /* + * Accelerator for simple ASCII names + */ + in = ctxt->input->cur; + if (((*in >= 0x61) && (*in <= 0x7A)) || + ((*in >= 0x41) && (*in <= 0x5A)) || + (*in == '_') || (*in == ':')) { + in++; + while (((*in >= 0x61) && (*in <= 0x7A)) || + ((*in >= 0x41) && (*in <= 0x5A)) || + ((*in >= 0x30) && (*in <= 0x39)) || + (*in == '_') || (*in == '-') || + (*in == ':') || (*in == '.')) + in++; + if ((*in > 0) && (*in < 0x80)) { + count = in - ctxt->input->cur; + if (count > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Name"); + return(NULL); + } + ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count); + ctxt->input->cur = in; + ctxt->input->col += count; + if (ret == NULL) + xmlErrMemory(ctxt); + return(ret); + } + } + /* accelerator for special cases */ + return(xmlParseNameComplex(ctxt)); +} + +static xmlHashedString +xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) { + xmlHashedString ret; + int len = 0, l; + int c; + int maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + size_t startPosition = 0; + + ret.name = NULL; + ret.hashValue = 0; + + /* + * Handler for more complex cases + */ + startPosition = CUR_PTR - BASE_PTR; + c = xmlCurrentChar(ctxt, &l); + if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */ + (!xmlIsNameStartChar(ctxt, c) || (c == ':'))) { + return(ret); + } + + while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */ + (xmlIsNameChar(ctxt, c) && (c != ':'))) { + if (len <= INT_MAX - l) + len += l; + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + } + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); + return(ret); + } + ret = xmlDictLookupHashed(ctxt->dict, (BASE_PTR + startPosition), len); + if (ret.name == NULL) + xmlErrMemory(ctxt); + return(ret); +} + +/** + * xmlParseNCName: + * @ctxt: an XML parser context + * @len: length of the string parsed + * + * parse an XML name. + * + * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' | + * CombiningChar | Extender + * + * [5NS] NCName ::= (Letter | '_') (NCNameChar)* + * + * Returns the Name parsed or NULL + */ + +static xmlHashedString +xmlParseNCName(xmlParserCtxtPtr ctxt) { + const xmlChar *in, *e; + xmlHashedString ret; + size_t count = 0; + size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + + ret.name = NULL; + + /* + * Accelerator for simple ASCII names + */ + in = ctxt->input->cur; + e = ctxt->input->end; + if ((((*in >= 0x61) && (*in <= 0x7A)) || + ((*in >= 0x41) && (*in <= 0x5A)) || + (*in == '_')) && (in < e)) { + in++; + while ((((*in >= 0x61) && (*in <= 0x7A)) || + ((*in >= 0x41) && (*in <= 0x5A)) || + ((*in >= 0x30) && (*in <= 0x39)) || + (*in == '_') || (*in == '-') || + (*in == '.')) && (in < e)) + in++; + if (in >= e) + goto complex; + if ((*in > 0) && (*in < 0x80)) { + count = in - ctxt->input->cur; + if (count > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); + return(ret); + } + ret = xmlDictLookupHashed(ctxt->dict, ctxt->input->cur, count); + ctxt->input->cur = in; + ctxt->input->col += count; + if (ret.name == NULL) { + xmlErrMemory(ctxt); + } + return(ret); + } + } +complex: + return(xmlParseNCNameComplex(ctxt)); +} + +/** + * xmlParseNameAndCompare: + * @ctxt: an XML parser context + * + * parse an XML name and compares for match + * (specialized for endtag parsing) + * + * Returns NULL for an illegal name, (xmlChar*) 1 for success + * and the name for mismatch + */ + +static const xmlChar * +xmlParseNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *other) { + register const xmlChar *cmp = other; + register const xmlChar *in; + const xmlChar *ret; + + GROW; + + in = ctxt->input->cur; + while (*in != 0 && *in == *cmp) { + ++in; + ++cmp; + } + if (*cmp == 0 && (*in == '>' || IS_BLANK_CH (*in))) { + /* success */ + ctxt->input->col += in - ctxt->input->cur; + ctxt->input->cur = in; + return (const xmlChar*) 1; + } + /* failure (or end of input buffer), check with full function */ + ret = xmlParseName (ctxt); + /* strings coming from the dictionary direct compare possible */ + if (ret == other) { + return (const xmlChar*) 1; + } + return ret; +} + +/** + * xmlParseStringName: + * @ctxt: an XML parser context + * @str: a pointer to the string pointer (IN/OUT) + * + * parse an XML name. + * + * [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':' | + * CombiningChar | Extender + * + * [5] Name ::= (Letter | '_' | ':') (NameChar)* + * + * [6] Names ::= Name (#x20 Name)* + * + * Returns the Name parsed or NULL. The @str pointer + * is updated to the current location in the string. + */ + +static xmlChar * +xmlParseStringName(xmlParserCtxtPtr ctxt, const xmlChar** str) { + xmlChar buf[XML_MAX_NAMELEN + 5]; + xmlChar *ret; + const xmlChar *cur = *str; + int len = 0, l; + int c; + int maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + + c = CUR_SCHAR(cur, l); + if (!xmlIsNameStartChar(ctxt, c)) { + return(NULL); + } + + COPY_BUF(buf, len, c); + cur += l; + c = CUR_SCHAR(cur, l); + while (xmlIsNameChar(ctxt, c)) { + COPY_BUF(buf, len, c); + cur += l; + c = CUR_SCHAR(cur, l); + if (len >= XML_MAX_NAMELEN) { /* test bigentname.xml */ + /* + * Okay someone managed to make a huge name, so he's ready to pay + * for the processing speed. + */ + xmlChar *buffer; + int max = len * 2; + + buffer = xmlMalloc(max); + if (buffer == NULL) { + xmlErrMemory(ctxt); + return(NULL); + } + memcpy(buffer, buf, len); + while (xmlIsNameChar(ctxt, c)) { + if (len + 10 > max) { + xmlChar *tmp; + + max *= 2; + tmp = (xmlChar *) xmlRealloc(buffer, max); + if (tmp == NULL) { + xmlErrMemory(ctxt); + xmlFree(buffer); + return(NULL); + } + buffer = tmp; + } + COPY_BUF(buffer, len, c); + cur += l; + c = CUR_SCHAR(cur, l); + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); + xmlFree(buffer); + return(NULL); + } + } + buffer[len] = 0; + *str = cur; + return(buffer); + } + } + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NCName"); + return(NULL); + } + *str = cur; + ret = xmlStrndup(buf, len); + if (ret == NULL) + xmlErrMemory(ctxt); + return(ret); +} + +/** + * xmlParseNmtoken: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * parse an XML Nmtoken. + * + * [7] Nmtoken ::= (NameChar)+ + * + * [8] Nmtokens ::= Nmtoken (#x20 Nmtoken)* + * + * Returns the Nmtoken parsed or NULL + */ + +xmlChar * +xmlParseNmtoken(xmlParserCtxtPtr ctxt) { + xmlChar buf[XML_MAX_NAMELEN + 5]; + xmlChar *ret; + int len = 0, l; + int c; + int maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + + c = xmlCurrentChar(ctxt, &l); + + while (xmlIsNameChar(ctxt, c)) { + COPY_BUF(buf, len, c); + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + if (len >= XML_MAX_NAMELEN) { + /* + * Okay someone managed to make a huge token, so he's ready to pay + * for the processing speed. + */ + xmlChar *buffer; + int max = len * 2; + + buffer = xmlMalloc(max); + if (buffer == NULL) { + xmlErrMemory(ctxt); + return(NULL); + } + memcpy(buffer, buf, len); + while (xmlIsNameChar(ctxt, c)) { + if (len + 10 > max) { + xmlChar *tmp; + + max *= 2; + tmp = (xmlChar *) xmlRealloc(buffer, max); + if (tmp == NULL) { + xmlErrMemory(ctxt); + xmlFree(buffer); + return(NULL); + } + buffer = tmp; + } + COPY_BUF(buffer, len, c); + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken"); + xmlFree(buffer); + return(NULL); + } + NEXTL(l); + c = xmlCurrentChar(ctxt, &l); + } + buffer[len] = 0; + return(buffer); + } + } + if (len == 0) + return(NULL); + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "NmToken"); + return(NULL); + } + ret = xmlStrndup(buf, len); + if (ret == NULL) + xmlErrMemory(ctxt); + return(ret); +} + +/** + * xmlExpandPEsInEntityValue: + * @ctxt: parser context + * @buf: string buffer + * @str: entity value + * @length: size of entity value + * @depth: nesting depth + * + * Validate an entity value and expand parameter entities. + */ +static void +xmlExpandPEsInEntityValue(xmlParserCtxtPtr ctxt, xmlSBuf *buf, + const xmlChar *str, int length, int depth) { + int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20; + const xmlChar *end, *chunk; + int c, l; + + if (str == NULL) + return; + + depth += 1; + if (depth > maxDepth) { + xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, + "Maximum entity nesting depth exceeded"); + return; + } + + end = str + length; + chunk = str; + + while ((str < end) && (!PARSER_STOPPED(ctxt))) { + c = *str; + + if (c >= 0x80) { + l = xmlUTF8MultibyteLen(ctxt, str, + "invalid character in entity value\n"); + if (l == 0) { + if (chunk < str) + xmlSBufAddString(buf, chunk, str - chunk); + xmlSBufAddReplChar(buf); + str += 1; + chunk = str; + } else { + str += l; + } + } else if (c == '&') { + if (str[1] == '#') { + if (chunk < str) + xmlSBufAddString(buf, chunk, str - chunk); + + c = xmlParseStringCharRef(ctxt, &str); + if (c == 0) + return; + + xmlSBufAddChar(buf, c); + + chunk = str; + } else { + xmlChar *name; + + /* + * General entity references are checked for + * syntactic validity. + */ + str++; + name = xmlParseStringName(ctxt, &str); + + if ((name == NULL) || (*str++ != ';')) { + xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_CHAR_ERROR, + "EntityValue: '&' forbidden except for entities " + "references\n"); + xmlFree(name); + return; + } + + xmlFree(name); + } + } else if (c == '%') { + xmlEntityPtr ent; + + if (chunk < str) + xmlSBufAddString(buf, chunk, str - chunk); + + ent = xmlParseStringPEReference(ctxt, &str); + if (ent == NULL) + return; + + if (!PARSER_EXTERNAL(ctxt)) { + xmlFatalErr(ctxt, XML_ERR_ENTITY_PE_INTERNAL, NULL); + return; + } + + if (ent->content == NULL) { + /* + * Note: external parsed entities will not be loaded, + * it is not required for a non-validating parser to + * complete external PEReferences coming from the + * internal subset + */ + if (((ctxt->options & XML_PARSE_NO_XXE) == 0) && + ((ctxt->replaceEntities) || + (ctxt->validate))) { + xmlLoadEntityContent(ctxt, ent); + } else { + xmlWarningMsg(ctxt, XML_ERR_ENTITY_PROCESSING, + "not validating will not read content for " + "PE entity %s\n", ent->name, NULL); + } + } + + /* + * TODO: Skip if ent->content is still NULL. + */ + + if (xmlParserEntityCheck(ctxt, ent->length)) + return; + + if (ent->flags & XML_ENT_EXPANDING) { + xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); + xmlHaltParser(ctxt); + return; + } + + ent->flags |= XML_ENT_EXPANDING; + xmlExpandPEsInEntityValue(ctxt, buf, ent->content, ent->length, + depth); + ent->flags &= ~XML_ENT_EXPANDING; + + chunk = str; + } else { + /* Normal ASCII char */ + if (!IS_BYTE_CHAR(c)) { + xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, + "invalid character in entity value\n"); + if (chunk < str) + xmlSBufAddString(buf, chunk, str - chunk); + xmlSBufAddReplChar(buf); + str += 1; + chunk = str; + } else { + str += 1; + } + } + } + + if (chunk < str) + xmlSBufAddString(buf, chunk, str - chunk); +} + +/** + * xmlParseEntityValue: + * @ctxt: an XML parser context + * @orig: if non-NULL store a copy of the original entity value + * + * DEPRECATED: Internal function, don't use. + * + * parse a value for ENTITY declarations + * + * [9] EntityValue ::= '"' ([^%&"] | PEReference | Reference)* '"' | + * "'" ([^%&'] | PEReference | Reference)* "'" + * + * Returns the EntityValue parsed with reference substituted or NULL + */ +xmlChar * +xmlParseEntityValue(xmlParserCtxtPtr ctxt, xmlChar **orig) { + unsigned maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_HUGE_LENGTH : + XML_MAX_TEXT_LENGTH; + xmlSBuf buf; + const xmlChar *start; + int quote, length; + + xmlSBufInit(&buf, maxLength); + + GROW; + + quote = CUR; + if ((quote != '"') && (quote != '\'')) { + xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL); + return(NULL); + } + CUR_PTR++; + + length = 0; + + /* + * Copy raw content of the entity into a buffer + */ + while (1) { + int c; + + if (PARSER_STOPPED(ctxt)) + goto error; + + if (CUR_PTR >= ctxt->input->end) { + xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_NOT_FINISHED, NULL); + goto error; + } + + c = CUR; + + if (c == 0) { + xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, + "invalid character in entity value\n"); + goto error; + } + if (c == quote) + break; + NEXTL(1); + length += 1; + + /* + * TODO: Check growth threshold + */ + if (ctxt->input->end - CUR_PTR < 10) + GROW; + } + + start = CUR_PTR - length; + + if (orig != NULL) { + *orig = xmlStrndup(start, length); + if (*orig == NULL) + xmlErrMemory(ctxt); + } + + xmlExpandPEsInEntityValue(ctxt, &buf, start, length, ctxt->inputNr); + + NEXTL(1); + + return(xmlSBufFinish(&buf, NULL, ctxt, "entity length too long")); + +error: + xmlSBufCleanup(&buf, ctxt, "entity length too long"); + return(NULL); +} + +/** + * xmlCheckEntityInAttValue: + * @ctxt: parser context + * @pent: entity + * @depth: nesting depth + * + * Check an entity reference in an attribute value for validity + * without expanding it. + */ +static void +xmlCheckEntityInAttValue(xmlParserCtxtPtr ctxt, xmlEntityPtr pent, int depth) { + int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20; + const xmlChar *str; + unsigned long expandedSize = pent->length; + int c, flags; + + depth += 1; + if (depth > maxDepth) { + xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, + "Maximum entity nesting depth exceeded"); + return; + } + + if (pent->flags & XML_ENT_EXPANDING) { + xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); + xmlHaltParser(ctxt); + return; + } + + /* + * If we're parsing a default attribute value in DTD content, + * the entity might reference other entities which weren't + * defined yet, so the check isn't reliable. + */ + if (ctxt->inSubset == 0) + flags = XML_ENT_CHECKED | XML_ENT_VALIDATED; + else + flags = XML_ENT_VALIDATED; + + str = pent->content; + if (str == NULL) + goto done; + + /* + * Note that entity values are already validated. We only check + * for illegal less-than signs and compute the expanded size + * of the entity. No special handling for multi-byte characters + * is needed. + */ + while (!PARSER_STOPPED(ctxt)) { + c = *str; + + if (c != '&') { + if (c == 0) + break; + + if (c == '<') + xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, + "'<' in entity '%s' is not allowed in attributes " + "values\n", pent->name); + + str += 1; + } else if (str[1] == '#') { + int val; + + val = xmlParseStringCharRef(ctxt, &str); + if (val == 0) { + pent->content[0] = 0; + break; + } + } else { + xmlChar *name; + xmlEntityPtr ent; + + name = xmlParseStringEntityRef(ctxt, &str); + if (name == NULL) { + pent->content[0] = 0; + break; + } + + ent = xmlLookupGeneralEntity(ctxt, name, /* inAttr */ 1); + xmlFree(name); + + if ((ent != NULL) && + (ent->etype != XML_INTERNAL_PREDEFINED_ENTITY)) { + if ((ent->flags & flags) != flags) { + pent->flags |= XML_ENT_EXPANDING; + xmlCheckEntityInAttValue(ctxt, ent, depth); + pent->flags &= ~XML_ENT_EXPANDING; + } + + xmlSaturatedAdd(&expandedSize, ent->expandedSize); + xmlSaturatedAdd(&expandedSize, XML_ENT_FIXED_COST); + } + } + } + +done: + if (ctxt->inSubset == 0) + pent->expandedSize = expandedSize; + + pent->flags |= flags; +} + +/** + * xmlExpandEntityInAttValue: + * @ctxt: parser context + * @buf: string buffer + * @str: entity or attribute value + * @pent: entity for entity value, NULL for attribute values + * @normalize: whether to collapse whitespace + * @inSpace: whitespace state + * @depth: nesting depth + * @check: whether to check for amplification + * + * Expand general entity references in an entity or attribute value. + * Perform attribute value normalization. + */ +static void +xmlExpandEntityInAttValue(xmlParserCtxtPtr ctxt, xmlSBuf *buf, + const xmlChar *str, xmlEntityPtr pent, int normalize, + int *inSpace, int depth, int check) { + int maxDepth = (ctxt->options & XML_PARSE_HUGE) ? 40 : 20; + int c, chunkSize; + + if (str == NULL) + return; + + depth += 1; + if (depth > maxDepth) { + xmlFatalErrMsg(ctxt, XML_ERR_RESOURCE_LIMIT, + "Maximum entity nesting depth exceeded"); + return; + } + + if (pent != NULL) { + if (pent->flags & XML_ENT_EXPANDING) { + xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); + xmlHaltParser(ctxt); + return; + } + + if (check) { + if (xmlParserEntityCheck(ctxt, pent->length)) + return; + } + } + + chunkSize = 0; + + /* + * Note that entity values are already validated. No special + * handling for multi-byte characters is needed. + */ + while (!PARSER_STOPPED(ctxt)) { + c = *str; + + if (c != '&') { + if (c == 0) + break; + + /* + * If this function is called without an entity, it is used to + * expand entities in an attribute content where less-than was + * already unscaped and is allowed. + */ + if ((pent != NULL) && (c == '<')) { + xmlFatalErrMsgStr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, + "'<' in entity '%s' is not allowed in attributes " + "values\n", pent->name); + break; + } + + if (c <= 0x20) { + if ((normalize) && (*inSpace)) { + /* Skip char */ + if (chunkSize > 0) { + xmlSBufAddString(buf, str - chunkSize, chunkSize); + chunkSize = 0; + } + } else if (c < 0x20) { + if (chunkSize > 0) { + xmlSBufAddString(buf, str - chunkSize, chunkSize); + chunkSize = 0; + } + + xmlSBufAddCString(buf, " ", 1); + } else { + chunkSize += 1; + } + + *inSpace = 1; + } else { + chunkSize += 1; + *inSpace = 0; + } + + str += 1; + } else if (str[1] == '#') { + int val; + + if (chunkSize > 0) { + xmlSBufAddString(buf, str - chunkSize, chunkSize); + chunkSize = 0; + } + + val = xmlParseStringCharRef(ctxt, &str); + if (val == 0) { + if (pent != NULL) + pent->content[0] = 0; + break; + } + + if (val == ' ') { + if ((!normalize) || (!*inSpace)) + xmlSBufAddCString(buf, " ", 1); + *inSpace = 1; + } else { + xmlSBufAddChar(buf, val); + *inSpace = 0; + } + } else { + xmlChar *name; + xmlEntityPtr ent; + + if (chunkSize > 0) { + xmlSBufAddString(buf, str - chunkSize, chunkSize); + chunkSize = 0; + } + + name = xmlParseStringEntityRef(ctxt, &str); + if (name == NULL) { + if (pent != NULL) + pent->content[0] = 0; + break; + } + + ent = xmlLookupGeneralEntity(ctxt, name, /* inAttr */ 1); + xmlFree(name); + + if ((ent != NULL) && + (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) { + if (ent->content == NULL) { + xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, + "predefined entity has no content\n"); + break; + } + + xmlSBufAddString(buf, ent->content, ent->length); + + *inSpace = 0; + } else if ((ent != NULL) && (ent->content != NULL)) { + if (pent != NULL) + pent->flags |= XML_ENT_EXPANDING; + xmlExpandEntityInAttValue(ctxt, buf, ent->content, ent, + normalize, inSpace, depth, check); + if (pent != NULL) + pent->flags &= ~XML_ENT_EXPANDING; + } + } + } + + if (chunkSize > 0) + xmlSBufAddString(buf, str - chunkSize, chunkSize); +} + +/** + * xmlExpandEntitiesInAttValue: + * @ctxt: parser context + * @str: entity or attribute value + * @normalize: whether to collapse whitespace + * + * Expand general entity references in an entity or attribute value. + * Perform attribute value normalization. + * + * Returns the expanded attribtue value. + */ +xmlChar * +xmlExpandEntitiesInAttValue(xmlParserCtxtPtr ctxt, const xmlChar *str, + int normalize) { + unsigned maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_HUGE_LENGTH : + XML_MAX_TEXT_LENGTH; + xmlSBuf buf; + int inSpace = 1; + + xmlSBufInit(&buf, maxLength); + + xmlExpandEntityInAttValue(ctxt, &buf, str, NULL, normalize, &inSpace, + ctxt->inputNr, /* check */ 0); + + if ((normalize) && (inSpace) && (buf.size > 0)) + buf.size--; + + return(xmlSBufFinish(&buf, NULL, ctxt, "AttValue length too long")); +} + +/** + * xmlParseAttValueInternal: + * @ctxt: an XML parser context + * @len: attribute len result + * @alloc: whether the attribute was reallocated as a new string + * @normalize: if 1 then further non-CDATA normalization must be done + * + * parse a value for an attribute. + * NOTE: if no normalization is needed, the routine will return pointers + * directly from the data buffer. + * + * 3.3.3 Attribute-Value Normalization: + * Before the value of an attribute is passed to the application or + * checked for validity, the XML processor must normalize it as follows: + * - a character reference is processed by appending the referenced + * character to the attribute value + * - an entity reference is processed by recursively processing the + * replacement text of the entity + * - a whitespace character (#x20, #xD, #xA, #x9) is processed by + * appending #x20 to the normalized value, except that only a single + * #x20 is appended for a "#xD#xA" sequence that is part of an external + * parsed entity or the literal entity value of an internal parsed entity + * - other characters are processed by appending them to the normalized value + * If the declared value is not CDATA, then the XML processor must further + * process the normalized attribute value by discarding any leading and + * trailing space (#x20) characters, and by replacing sequences of space + * (#x20) characters by a single space (#x20) character. + * All attributes for which no declaration has been read should be treated + * by a non-validating parser as if declared CDATA. + * + * Returns the AttValue parsed or NULL. The value has to be freed by the + * caller if it was copied, this can be detected by val[*len] == 0. + */ +static xmlChar * +xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *attlen, int *alloc, + int normalize, int isNamespace) { + unsigned maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_HUGE_LENGTH : + XML_MAX_TEXT_LENGTH; + xmlSBuf buf; + xmlChar *ret; + int c, l, quote, flags, chunkSize; + int inSpace = 1; + int replaceEntities; + + /* Always expand namespace URIs */ + replaceEntities = (ctxt->replaceEntities) || (isNamespace); + + xmlSBufInit(&buf, maxLength); + + GROW; + + quote = CUR; + if ((quote != '"') && (quote != '\'')) { + xmlFatalErr(ctxt, XML_ERR_ATTRIBUTE_NOT_STARTED, NULL); + return(NULL); + } + NEXTL(1); + + if (ctxt->inSubset == 0) + flags = XML_ENT_CHECKED | XML_ENT_VALIDATED; + else + flags = XML_ENT_VALIDATED; + + inSpace = 1; + chunkSize = 0; + + while (1) { + if (PARSER_STOPPED(ctxt)) + goto error; + + if (CUR_PTR >= ctxt->input->end) { + xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED, + "AttValue: ' expected\n"); + goto error; + } + + /* + * TODO: Check growth threshold + */ + if (ctxt->input->end - CUR_PTR < 10) + GROW; + + c = CUR; + + if (c >= 0x80) { + l = xmlUTF8MultibyteLen(ctxt, CUR_PTR, + "invalid character in attribute value\n"); + if (l == 0) { + if (chunkSize > 0) { + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + chunkSize = 0; + } + xmlSBufAddReplChar(&buf); + NEXTL(1); + } else { + chunkSize += l; + NEXTL(l); + } + + inSpace = 0; + } else if (c != '&') { + if (c > 0x20) { + if (c == quote) + break; + + if (c == '<') + xmlFatalErr(ctxt, XML_ERR_LT_IN_ATTRIBUTE, NULL); + + chunkSize += 1; + inSpace = 0; + } else if (!IS_BYTE_CHAR(c)) { + xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, + "invalid character in attribute value\n"); + if (chunkSize > 0) { + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + chunkSize = 0; + } + xmlSBufAddReplChar(&buf); + inSpace = 0; + } else { + /* Whitespace */ + if ((normalize) && (inSpace)) { + /* Skip char */ + if (chunkSize > 0) { + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + chunkSize = 0; + } + } else if (c < 0x20) { + /* Convert to space */ + if (chunkSize > 0) { + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + chunkSize = 0; + } + + xmlSBufAddCString(&buf, " ", 1); + } else { + chunkSize += 1; + } + + inSpace = 1; + + if ((c == 0xD) && (NXT(1) == 0xA)) + CUR_PTR++; + } + + NEXTL(1); + } else if (NXT(1) == '#') { + int val; + + if (chunkSize > 0) { + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + chunkSize = 0; + } + + val = xmlParseCharRef(ctxt); + if (val == 0) + goto error; + + if ((val == '&') && (!replaceEntities)) { + /* + * The reparsing will be done in xmlNodeParseContent() + * called from SAX2.c + */ + xmlSBufAddCString(&buf, "&", 5); + inSpace = 0; + } else if (val == ' ') { + if ((!normalize) || (!inSpace)) + xmlSBufAddCString(&buf, " ", 1); + inSpace = 1; + } else { + xmlSBufAddChar(&buf, val); + inSpace = 0; + } + } else { + const xmlChar *name; + xmlEntityPtr ent; + + if (chunkSize > 0) { + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + chunkSize = 0; + } + + name = xmlParseEntityRefInternal(ctxt); + if (name == NULL) { + /* + * Probably a literal '&' which wasn't escaped. + * TODO: Handle gracefully in recovery mode. + */ + continue; + } + + ent = xmlLookupGeneralEntity(ctxt, name, /* isAttr */ 1); + if (ent == NULL) + continue; + + if (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY) { + if ((ent->content[0] == '&') && (!replaceEntities)) + xmlSBufAddCString(&buf, "&", 5); + else + xmlSBufAddString(&buf, ent->content, ent->length); + inSpace = 0; + } else if (replaceEntities) { + xmlExpandEntityInAttValue(ctxt, &buf, ent->content, ent, + normalize, &inSpace, ctxt->inputNr, + /* check */ 1); + } else { + if ((ent->flags & flags) != flags) + xmlCheckEntityInAttValue(ctxt, ent, ctxt->inputNr); + + if (xmlParserEntityCheck(ctxt, ent->expandedSize)) { + ent->content[0] = 0; + goto error; + } + + /* + * Just output the reference + */ + xmlSBufAddCString(&buf, "&", 1); + xmlSBufAddString(&buf, ent->name, xmlStrlen(ent->name)); + xmlSBufAddCString(&buf, ";", 1); + + inSpace = 0; + } + } + } + + if ((buf.mem == NULL) && (alloc != NULL)) { + ret = (xmlChar *) CUR_PTR - chunkSize; + + if (attlen != NULL) + *attlen = chunkSize; + if ((normalize) && (inSpace) && (chunkSize > 0)) + *attlen -= 1; + *alloc = 0; + + /* Report potential error */ + xmlSBufCleanup(&buf, ctxt, "AttValue length too long"); + } else { + if (chunkSize > 0) + xmlSBufAddString(&buf, CUR_PTR - chunkSize, chunkSize); + + if ((normalize) && (inSpace) && (buf.size > 0)) + buf.size--; + + ret = xmlSBufFinish(&buf, attlen, ctxt, "AttValue length too long"); + + if (ret != NULL) { + if (attlen != NULL) + *attlen = buf.size; + if (alloc != NULL) + *alloc = 1; + } + } + + NEXTL(1); + + return(ret); + +error: + xmlSBufCleanup(&buf, ctxt, "AttValue length too long"); + return(NULL); +} + +/** + * xmlParseAttValue: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * parse a value for an attribute + * Note: the parser won't do substitution of entities here, this + * will be handled later in xmlStringGetNodeList + * + * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' | + * "'" ([^<&'] | Reference)* "'" + * + * 3.3.3 Attribute-Value Normalization: + * Before the value of an attribute is passed to the application or + * checked for validity, the XML processor must normalize it as follows: + * - a character reference is processed by appending the referenced + * character to the attribute value + * - an entity reference is processed by recursively processing the + * replacement text of the entity + * - a whitespace character (#x20, #xD, #xA, #x9) is processed by + * appending #x20 to the normalized value, except that only a single + * #x20 is appended for a "#xD#xA" sequence that is part of an external + * parsed entity or the literal entity value of an internal parsed entity + * - other characters are processed by appending them to the normalized value + * If the declared value is not CDATA, then the XML processor must further + * process the normalized attribute value by discarding any leading and + * trailing space (#x20) characters, and by replacing sequences of space + * (#x20) characters by a single space (#x20) character. + * All attributes for which no declaration has been read should be treated + * by a non-validating parser as if declared CDATA. + * + * Returns the AttValue parsed or NULL. The value has to be freed by the caller. + */ + + +xmlChar * +xmlParseAttValue(xmlParserCtxtPtr ctxt) { + if ((ctxt == NULL) || (ctxt->input == NULL)) return(NULL); + return(xmlParseAttValueInternal(ctxt, NULL, NULL, 0, 0)); +} + +/** + * xmlParseSystemLiteral: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * parse an XML Literal + * + * [11] SystemLiteral ::= ('"' [^"]* '"') | ("'" [^']* "'") + * + * Returns the SystemLiteral parsed or NULL + */ + +xmlChar * +xmlParseSystemLiteral(xmlParserCtxtPtr ctxt) { + xmlChar *buf = NULL; + int len = 0; + int size = XML_PARSER_BUFFER_SIZE; + int cur, l; + int maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + xmlChar stop; + + if (RAW == '"') { + NEXT; + stop = '"'; + } else if (RAW == '\'') { + NEXT; + stop = '\''; + } else { + xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL); + return(NULL); + } + + buf = xmlMalloc(size); + if (buf == NULL) { + xmlErrMemory(ctxt); + return(NULL); + } + cur = xmlCurrentCharRecover(ctxt, &l); + while ((IS_CHAR(cur)) && (cur != stop)) { /* checked */ + if (len + 5 >= size) { + xmlChar *tmp; + + size *= 2; + tmp = (xmlChar *) xmlRealloc(buf, size); + if (tmp == NULL) { + xmlFree(buf); + xmlErrMemory(ctxt); + return(NULL); + } + buf = tmp; + } + COPY_BUF(buf, len, cur); + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "SystemLiteral"); + xmlFree(buf); + return(NULL); + } + NEXTL(l); + cur = xmlCurrentCharRecover(ctxt, &l); + } + buf[len] = 0; + if (!IS_CHAR(cur)) { + xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL); + } else { + NEXT; + } + return(buf); +} + +/** + * xmlParsePubidLiteral: + * @ctxt: an XML parser context + * + * DEPRECATED: Internal function, don't use. + * + * parse an XML public literal + * + * [12] PubidLiteral ::= '"' PubidChar* '"' | "'" (PubidChar - "'")* "'" + * + * Returns the PubidLiteral parsed or NULL. + */ + +xmlChar * +xmlParsePubidLiteral(xmlParserCtxtPtr ctxt) { + xmlChar *buf = NULL; + int len = 0; + int size = XML_PARSER_BUFFER_SIZE; + int maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_TEXT_LENGTH : + XML_MAX_NAME_LENGTH; + xmlChar cur; + xmlChar stop; + + if (RAW == '"') { + NEXT; + stop = '"'; + } else if (RAW == '\'') { + NEXT; + stop = '\''; + } else { + xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_STARTED, NULL); + return(NULL); + } + buf = xmlMalloc(size); + if (buf == NULL) { + xmlErrMemory(ctxt); + return(NULL); + } + cur = CUR; + while ((IS_PUBIDCHAR_CH(cur)) && (cur != stop) && + (PARSER_STOPPED(ctxt) == 0)) { /* checked */ + if (len + 1 >= size) { + xmlChar *tmp; + + size *= 2; + tmp = (xmlChar *) xmlRealloc(buf, size); + if (tmp == NULL) { + xmlErrMemory(ctxt); + xmlFree(buf); + return(NULL); + } + buf = tmp; + } + buf[len++] = cur; + if (len > maxLength) { + xmlFatalErr(ctxt, XML_ERR_NAME_TOO_LONG, "Public ID"); + xmlFree(buf); + return(NULL); + } + NEXT; + cur = CUR; + } + buf[len] = 0; + if (cur != stop) { + xmlFatalErr(ctxt, XML_ERR_LITERAL_NOT_FINISHED, NULL); + } else { + NEXTL(1); + } + return(buf); +} + +static void xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int partial); + +/* + * used for the test in the inner loop of the char data testing + */ +static const unsigned char test_char_data[256] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x9, CR/LF separated */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x00, 0x27, /* & */ + 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x3A, 0x3B, 0x00, 0x3D, 0x3E, 0x3F, /* < */ + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, + 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x00, 0x5E, 0x5F, /* ] */ + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* non-ascii */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + +/** + * xmlParseCharDataInternal: + * @ctxt: an XML parser context + * @partial: buffer may contain partial UTF-8 sequences + * + * Parse character data. Always makes progress if the first char isn't + * '<' or '&'. + * + * The right angle bracket (>) may be represented using the string ">", + * and must, for compatibility, be escaped using ">" or a character + * reference when it appears in the string "]]>" in content, when that + * string is not marking the end of a CDATA section. + * + * [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*) + */ +static void +xmlParseCharDataInternal(xmlParserCtxtPtr ctxt, int partial) { + const xmlChar *in; + int nbchar = 0; + int line = ctxt->input->line; + int col = ctxt->input->col; + int ccol; + + GROW; + /* + * Accelerated common case where input don't need to be + * modified before passing it to the handler. + */ + in = ctxt->input->cur; + do { +get_more_space: + while (*in == 0x20) { in++; ctxt->input->col++; } + if (*in == 0xA) { + do { + ctxt->input->line++; ctxt->input->col = 1; + in++; + } while (*in == 0xA); + goto get_more_space; + } + if (*in == '<') { + nbchar = in - ctxt->input->cur; + if (nbchar > 0) { + const xmlChar *tmp = ctxt->input->cur; + ctxt->input->cur = in; + + if ((ctxt->sax != NULL) && + (ctxt->disableSAX == 0) && + (ctxt->sax->ignorableWhitespace != + ctxt->sax->characters)) { + if (areBlanks(ctxt, tmp, nbchar, 1)) { + if (ctxt->sax->ignorableWhitespace != NULL) + ctxt->sax->ignorableWhitespace(ctxt->userData, + tmp, nbchar); + } else { + if (ctxt->sax->characters != NULL) + ctxt->sax->characters(ctxt->userData, + tmp, nbchar); + if (*ctxt->space == -1) + *ctxt->space = -2; + } + } else if ((ctxt->sax != NULL) && + (ctxt->disableSAX == 0) && + (ctxt->sax->characters != NULL)) { + ctxt->sax->characters(ctxt->userData, + tmp, nbchar); + } + } + return; + } + +get_more: + ccol = ctxt->input->col; + while (test_char_data[*in]) { + in++; + ccol++; + } + ctxt->input->col = ccol; + if (*in == 0xA) { + do { + ctxt->input->line++; ctxt->input->col = 1; + in++; + } while (*in == 0xA); + goto get_more; + } + if (*in == ']') { + if ((in[1] == ']') && (in[2] == '>')) { + xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL); + ctxt->input->cur = in + 1; + return; + } + in++; + ctxt->input->col++; + goto get_more; + } + nbchar = in - ctxt->input->cur; + if (nbchar > 0) { + if ((ctxt->sax != NULL) && + (ctxt->disableSAX == 0) && + (ctxt->sax->ignorableWhitespace != + ctxt->sax->characters) && + (IS_BLANK_CH(*ctxt->input->cur))) { + const xmlChar *tmp = ctxt->input->cur; + ctxt->input->cur = in; + + if (areBlanks(ctxt, tmp, nbchar, 0)) { + if (ctxt->sax->ignorableWhitespace != NULL) + ctxt->sax->ignorableWhitespace(ctxt->userData, + tmp, nbchar); + } else { + if (ctxt->sax->characters != NULL) + ctxt->sax->characters(ctxt->userData, + tmp, nbchar); + if (*ctxt->space == -1) + *ctxt->space = -2; + } + line = ctxt->input->line; + col = ctxt->input->col; + } else if ((ctxt->sax != NULL) && + (ctxt->disableSAX == 0)) { + if (ctxt->sax->characters != NULL) + ctxt->sax->characters(ctxt->userData, + ctxt->input->cur, nbchar); + line = ctxt->input->line; + col = ctxt->input->col; + } + } + ctxt->input->cur = in; + if (*in == 0xD) { + in++; + if (*in == 0xA) { + ctxt->input->cur = in; + in++; + ctxt->input->line++; ctxt->input->col = 1; + continue; /* while */ + } + in--; + } + if (*in == '<') { + return; + } + if (*in == '&') { + return; + } + SHRINK; + GROW; + in = ctxt->input->cur; + } while (((*in >= 0x20) && (*in <= 0x7F)) || + (*in == 0x09) || (*in == 0x0a)); + ctxt->input->line = line; + ctxt->input->col = col; + xmlParseCharDataComplex(ctxt, partial); +} + +/** + * xmlParseCharDataComplex: + * @ctxt: an XML parser context + * @cdata: int indicating whether we are within a CDATA section + * + * Always makes progress if the first char isn't '<' or '&'. + * + * parse a CharData section.this is the fallback function + * of xmlParseCharData() when the parsing requires handling + * of non-ASCII characters. + */ +static void +xmlParseCharDataComplex(xmlParserCtxtPtr ctxt, int partial) { + xmlChar buf[XML_PARSER_BIG_BUFFER_SIZE + 5]; + int nbchar = 0; + int cur, l; + + cur = xmlCurrentCharRecover(ctxt, &l); + while ((cur != '<') && /* checked */ + (cur != '&') && + (IS_CHAR(cur))) { + if ((cur == ']') && (NXT(1) == ']') && (NXT(2) == '>')) { + xmlFatalErr(ctxt, XML_ERR_MISPLACED_CDATA_END, NULL); + } + COPY_BUF(buf, nbchar, cur); + /* move current position before possible calling of ctxt->sax->characters */ + NEXTL(l); + if (nbchar >= XML_PARSER_BIG_BUFFER_SIZE) { + buf[nbchar] = 0; + + /* + * OK the segment is to be consumed as chars. + */ + if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { + if (areBlanks(ctxt, buf, nbchar, 0)) { + if (ctxt->sax->ignorableWhitespace != NULL) + ctxt->sax->ignorableWhitespace(ctxt->userData, + buf, nbchar); + } else { + if (ctxt->sax->characters != NULL) + ctxt->sax->characters(ctxt->userData, buf, nbchar); + if ((ctxt->sax->characters != + ctxt->sax->ignorableWhitespace) && + (*ctxt->space == -1)) + *ctxt->space = -2; + } + } + nbchar = 0; + SHRINK; + } + cur = xmlCurrentCharRecover(ctxt, &l); + } + if (nbchar != 0) { + buf[nbchar] = 0; + /* + * OK the segment is to be consumed as chars. + */ + if ((ctxt->sax != NULL) && (!ctxt->disableSAX)) { + if (areBlanks(ctxt, buf, nbchar, 0)) { + if (ctxt->sax->ignorableWhitespace != NULL) + ctxt->sax->ignorableWhitespace(ctxt->userData, buf, nbchar); + } else { + if (ctxt->sax->characters != NULL) + ctxt->sax->characters(ctxt->userData, buf, nbchar); + if ((ctxt->sax->characters != ctxt->sax->ignorableWhitespace) && + (*ctxt->space == -1)) + *ctxt->space = -2; + } + } + } + /* + * cur == 0 can mean + * + * - End of buffer. + * - An actual 0 character. + * - An incomplete UTF-8 sequence. This is allowed if partial is set. + */ + if (ctxt->input->cur < ctxt->input->end) { + if ((cur == 0) && (CUR != 0)) { + if (partial == 0) { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "Incomplete UTF-8 sequence starting with %02X\n", CUR); + NEXTL(1); + } + } else if ((cur != '<') && (cur != '&')) { + /* Generate the error and skip the offending character */ + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "PCDATA invalid Char value %d\n", cur); + NEXTL(l); + } + } +} + +/** + * xmlParseCharData: + * @ctxt: an XML parser context + * @cdata: unused + * + * DEPRECATED: Internal function, don't use. + */ +void +xmlParseCharData(xmlParserCtxtPtr ctxt, ATTRIBUTE_UNUSED int cdata) { + xmlParseCharDataInternal(ctxt, 0); +} + +/** + * xmlParseExternalID: + * @ctxt: an XML parser context + * @publicID: a xmlChar** receiving PubidLiteral + * @strict: indicate whether we should restrict parsing to only + * production [75], see NOTE below + * + * DEPRECATED: Internal function, don't use. + * + * Parse an External ID or a Public ID + * + * NOTE: Productions [75] and [83] interact badly since [75] can generate + * 'PUBLIC' S PubidLiteral S SystemLiteral + * + * [75] ExternalID ::= 'SYSTEM' S SystemLiteral + * | 'PUBLIC' S PubidLiteral S SystemLiteral + * + * [83] PublicID ::= 'PUBLIC' S PubidLiteral + * + * Returns the function returns SystemLiteral and in the second + * case publicID receives PubidLiteral, is strict is off + * it is possible to return NULL and have publicID set. + */ + +xmlChar * +xmlParseExternalID(xmlParserCtxtPtr ctxt, xmlChar **publicID, int strict) { + xmlChar *URI = NULL; + + *publicID = NULL; + if (CMP6(CUR_PTR, 'S', 'Y', 'S', 'T', 'E', 'M')) { + SKIP(6); + if (SKIP_BLANKS == 0) { + xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, + "Space required after 'SYSTEM'\n"); + } + URI = xmlParseSystemLiteral(ctxt); + if (URI == NULL) { + xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL); + } + } else if (CMP6(CUR_PTR, 'P', 'U', 'B', 'L', 'I', 'C')) { + SKIP(6); + if (SKIP_BLANKS == 0) { + xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, + "Space required after 'PUBLIC'\n"); + } + *publicID = xmlParsePubidLiteral(ctxt); + if (*publicID == NULL) { + xmlFatalErr(ctxt, XML_ERR_PUBID_REQUIRED, NULL); + } + if (strict) { + /* + * We don't handle [83] so "S SystemLiteral" is required. + */ + if (SKIP_BLANKS == 0) { + xmlFatalErrMsg(ctxt, XML_ERR_SPACE_REQUIRED, + "Space required after the Public Identifier\n"); + } + } else { + /* + * We handle [83] so we return immediately, if + * "S SystemLiteral" is not detected. We skip blanks if no + * system literal was found, but this is harmless since we must + * be at the end of a NotationDecl. + */ + if (SKIP_BLANKS == 0) return(NULL); + if ((CUR != '\'') && (CUR != '"')) return(NULL); + } + URI = xmlParseSystemLiteral(ctxt); + if (URI == NULL) { + xmlFatalErr(ctxt, XML_ERR_URI_REQUIRED, NULL); + } + } + return(URI); +} + +/** + * xmlParseCommentComplex: + * @ctxt: an XML parser context + * @buf: the already parsed part of the buffer + * @len: number of bytes in the buffer + * @size: allocated size of the buffer + * + * Skip an XML (SGML) comment + * The spec says that "For compatibility, the string "--" (double-hyphen) + * must not occur within comments. " + * This is the slow routine in case the accelerator for ascii didn't work + * + * [15] Comment ::= '' + */ +static void +xmlParseCommentComplex(xmlParserCtxtPtr ctxt, xmlChar *buf, + size_t len, size_t size) { + int q, ql; + int r, rl; + int cur, l; + size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_HUGE_LENGTH : + XML_MAX_TEXT_LENGTH; + + if (buf == NULL) { + len = 0; + size = XML_PARSER_BUFFER_SIZE; + buf = xmlMalloc(size); + if (buf == NULL) { + xmlErrMemory(ctxt); + return; + } + } + q = xmlCurrentCharRecover(ctxt, &ql); + if (q == 0) + goto not_terminated; + if (!IS_CHAR(q)) { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "xmlParseComment: invalid xmlChar value %d\n", + q); + xmlFree (buf); + return; + } + NEXTL(ql); + r = xmlCurrentCharRecover(ctxt, &rl); + if (r == 0) + goto not_terminated; + if (!IS_CHAR(r)) { + xmlFatalErrMsgInt(ctxt, XML_ERR_INVALID_CHAR, + "xmlParseComment: invalid xmlChar value %d\n", + r); + xmlFree (buf); + return; + } + NEXTL(rl); + cur = xmlCurrentCharRecover(ctxt, &l); + if (cur == 0) + goto not_terminated; + while (IS_CHAR(cur) && /* checked */ + ((cur != '>') || + (r != '-') || (q != '-'))) { + if ((r == '-') && (q == '-')) { + xmlFatalErr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, NULL); + } + if (len + 5 >= size) { + xmlChar *new_buf; + size_t new_size; + + new_size = size * 2; + new_buf = (xmlChar *) xmlRealloc(buf, new_size); + if (new_buf == NULL) { + xmlFree (buf); + xmlErrMemory(ctxt); + return; + } + buf = new_buf; + size = new_size; + } + COPY_BUF(buf, len, q); + if (len > maxLength) { + xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, + "Comment too big found", NULL); + xmlFree (buf); + return; + } + + q = r; + ql = rl; + r = cur; + rl = l; + + NEXTL(l); + cur = xmlCurrentCharRecover(ctxt, &l); + + } + buf[len] = 0; + if (cur == 0) { + xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, + "Comment not terminated \n' + */ +void +xmlParseComment(xmlParserCtxtPtr ctxt) { + xmlChar *buf = NULL; + size_t size = XML_PARSER_BUFFER_SIZE; + size_t len = 0; + size_t maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_HUGE_LENGTH : + XML_MAX_TEXT_LENGTH; + const xmlChar *in; + size_t nbchar = 0; + int ccol; + + /* + * Check that there is a comment right here. + */ + if ((RAW != '<') || (NXT(1) != '!')) + return; + SKIP(2); + if ((RAW != '-') || (NXT(1) != '-')) + return; + SKIP(2); + GROW; + + /* + * Accelerated common case where input don't need to be + * modified before passing it to the handler. + */ + in = ctxt->input->cur; + do { + if (*in == 0xA) { + do { + ctxt->input->line++; ctxt->input->col = 1; + in++; + } while (*in == 0xA); + } +get_more: + ccol = ctxt->input->col; + while (((*in > '-') && (*in <= 0x7F)) || + ((*in >= 0x20) && (*in < '-')) || + (*in == 0x09)) { + in++; + ccol++; + } + ctxt->input->col = ccol; + if (*in == 0xA) { + do { + ctxt->input->line++; ctxt->input->col = 1; + in++; + } while (*in == 0xA); + goto get_more; + } + nbchar = in - ctxt->input->cur; + /* + * save current set of data + */ + if (nbchar > 0) { + if (buf == NULL) { + if ((*in == '-') && (in[1] == '-')) + size = nbchar + 1; + else + size = XML_PARSER_BUFFER_SIZE + nbchar; + buf = xmlMalloc(size); + if (buf == NULL) { + xmlErrMemory(ctxt); + return; + } + len = 0; + } else if (len + nbchar + 1 >= size) { + xmlChar *new_buf; + size += len + nbchar + XML_PARSER_BUFFER_SIZE; + new_buf = (xmlChar *) xmlRealloc(buf, size); + if (new_buf == NULL) { + xmlFree (buf); + xmlErrMemory(ctxt); + return; + } + buf = new_buf; + } + memcpy(&buf[len], ctxt->input->cur, nbchar); + len += nbchar; + buf[len] = 0; + } + if (len > maxLength) { + xmlFatalErrMsgStr(ctxt, XML_ERR_COMMENT_NOT_FINISHED, + "Comment too big found", NULL); + xmlFree (buf); + return; + } + ctxt->input->cur = in; + if (*in == 0xA) { + in++; + ctxt->input->line++; ctxt->input->col = 1; + } + if (*in == 0xD) { + in++; + if (*in == 0xA) { + ctxt->input->cur = in; + in++; + ctxt->input->line++; ctxt->input->col = 1; + goto get_more; + } + in--; + } + SHRINK; + GROW; + in = ctxt->input->cur; + if (*in == '-') { + if (in[1] == '-') { + if (in[2] == '>') { + SKIP(3); + if ((ctxt->sax != NULL) && (ctxt->sax->comment != NULL) && + (!ctxt->disableSAX)) { + if (buf != NULL) + ctxt->sax->comment(ctxt->userData, buf); + else + ctxt->sax->comment(ctxt->userData, BAD_CAST ""); + } + if (buf != NULL) + xmlFree(buf); + return; + } + if (buf != NULL) { + xmlFatalErrMsgStr(ctxt, XML_ERR_HYPHEN_IN_COMMENT, + "Double hyphen within comment: " + " as comment */ + start = cur; + continue; + } + } + else if ((*cur == '"') || (*cur == '\'') || (*cur == ']')) { + state = *cur; + } + + cur++; + } + + /* + * Rescan the three last characters to detect "" + * split across chunks. + */ + if ((state == 0) || (state == '-')) { + if (cur - start < 3) + cur = start; + else + cur -= 3; + } + index = cur - ctxt->input->cur; + if (index > LONG_MAX) { + ctxt->checkIndex = 0; + ctxt->endCheckState = 0; + return(1); + } + ctxt->checkIndex = index; + ctxt->endCheckState = state; + return(0); +} + +/** + * xmlParseTryOrFinish: + * @ctxt: an XML parser context + * @terminate: last chunk indicator + * + * Try to progress on parsing + * + * Returns zero if no parsing was possible + */ +static int +xmlParseTryOrFinish(xmlParserCtxtPtr ctxt, int terminate) { + int ret = 0; + size_t avail; + xmlChar cur, next; + + if (ctxt->input == NULL) + return(0); + + if ((ctxt->input != NULL) && + (ctxt->input->cur - ctxt->input->base > 4096)) { + xmlParserShrink(ctxt); + } + + while (ctxt->disableSAX == 0) { + avail = ctxt->input->end - ctxt->input->cur; + if (avail < 1) + goto done; + switch (ctxt->instate) { + case XML_PARSER_EOF: + /* + * Document parsing is done ! + */ + goto done; + case XML_PARSER_START: + /* + * Very first chars read from the document flow. + */ + if ((!terminate) && (avail < 4)) + goto done; + + /* + * We need more bytes to detect EBCDIC code pages. + * See xmlDetectEBCDIC. + */ + if ((CMP4(CUR_PTR, 0x4C, 0x6F, 0xA7, 0x94)) && + (!terminate) && (avail < 200)) + goto done; + + xmlDetectEncoding(ctxt); + ctxt->instate = XML_PARSER_XML_DECL; + break; + + case XML_PARSER_XML_DECL: + if ((!terminate) && (avail < 2)) + goto done; + cur = ctxt->input->cur[0]; + next = ctxt->input->cur[1]; + if ((cur == '<') && (next == '?')) { + /* PI or XML decl */ + if ((!terminate) && + (!xmlParseLookupString(ctxt, 2, "?>", 2))) + goto done; + if ((ctxt->input->cur[2] == 'x') && + (ctxt->input->cur[3] == 'm') && + (ctxt->input->cur[4] == 'l') && + (IS_BLANK_CH(ctxt->input->cur[5]))) { + ret += 5; + xmlParseXMLDecl(ctxt); + } else { + ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); + if (ctxt->version == NULL) { + xmlErrMemory(ctxt); + break; + } + } + } else { + ctxt->version = xmlCharStrdup(XML_DEFAULT_VERSION); + if (ctxt->version == NULL) { + xmlErrMemory(ctxt); + break; + } + } + if ((ctxt->sax) && (ctxt->sax->setDocumentLocator)) { + ctxt->sax->setDocumentLocator(ctxt->userData, + (xmlSAXLocator *) &xmlDefaultSAXLocator); + } + if ((ctxt->sax) && (ctxt->sax->startDocument) && + (!ctxt->disableSAX)) + ctxt->sax->startDocument(ctxt->userData); + ctxt->instate = XML_PARSER_MISC; + break; + case XML_PARSER_START_TAG: { + const xmlChar *name; + const xmlChar *prefix = NULL; + const xmlChar *URI = NULL; + int line = ctxt->input->line; + int nbNs = 0; + + if ((!terminate) && (avail < 2)) + goto done; + cur = ctxt->input->cur[0]; + if (cur != '<') { + xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY, + "Start tag expected, '<' not found"); + ctxt->instate = XML_PARSER_EOF; + xmlFinishDocument(ctxt); + goto done; + } + if ((!terminate) && (!xmlParseLookupGt(ctxt))) + goto done; + if (ctxt->spaceNr == 0) + spacePush(ctxt, -1); + else if (*ctxt->space == -2) + spacePush(ctxt, -1); + else + spacePush(ctxt, *ctxt->space); +#ifdef LIBXML_SAX1_ENABLED + if (ctxt->sax2) +#endif /* LIBXML_SAX1_ENABLED */ + name = xmlParseStartTag2(ctxt, &prefix, &URI, &nbNs); +#ifdef LIBXML_SAX1_ENABLED + else + name = xmlParseStartTag(ctxt); +#endif /* LIBXML_SAX1_ENABLED */ + if (name == NULL) { + spacePop(ctxt); + ctxt->instate = XML_PARSER_EOF; + xmlFinishDocument(ctxt); + goto done; + } +#ifdef LIBXML_VALID_ENABLED + /* + * [ VC: Root Element Type ] + * The Name in the document type declaration must match + * the element type of the root element. + */ + if (ctxt->validate && ctxt->wellFormed && ctxt->myDoc && + ctxt->node && (ctxt->node == ctxt->myDoc->children)) + ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc); +#endif /* LIBXML_VALID_ENABLED */ + + /* + * Check for an Empty Element. + */ + if ((RAW == '/') && (NXT(1) == '>')) { + SKIP(2); + + if (ctxt->sax2) { + if ((ctxt->sax != NULL) && + (ctxt->sax->endElementNs != NULL) && + (!ctxt->disableSAX)) + ctxt->sax->endElementNs(ctxt->userData, name, + prefix, URI); + if (nbNs > 0) + xmlParserNsPop(ctxt, nbNs); +#ifdef LIBXML_SAX1_ENABLED + } else { + if ((ctxt->sax != NULL) && + (ctxt->sax->endElement != NULL) && + (!ctxt->disableSAX)) + ctxt->sax->endElement(ctxt->userData, name); +#endif /* LIBXML_SAX1_ENABLED */ + } + spacePop(ctxt); + } else if (RAW == '>') { + NEXT; + nameNsPush(ctxt, name, prefix, URI, line, nbNs); + } else { + xmlFatalErrMsgStr(ctxt, XML_ERR_GT_REQUIRED, + "Couldn't find end of Start Tag %s\n", + name); + nodePop(ctxt); + spacePop(ctxt); + if (nbNs > 0) + xmlParserNsPop(ctxt, nbNs); + } + + if (ctxt->nameNr == 0) + ctxt->instate = XML_PARSER_EPILOG; + else + ctxt->instate = XML_PARSER_CONTENT; + break; + } + case XML_PARSER_CONTENT: { + cur = ctxt->input->cur[0]; + + if (cur == '<') { + if ((!terminate) && (avail < 2)) + goto done; + next = ctxt->input->cur[1]; + + if (next == '/') { + ctxt->instate = XML_PARSER_END_TAG; + break; + } else if (next == '?') { + if ((!terminate) && + (!xmlParseLookupString(ctxt, 2, "?>", 2))) + goto done; + xmlParsePI(ctxt); + ctxt->instate = XML_PARSER_CONTENT; + break; + } else if (next == '!') { + if ((!terminate) && (avail < 3)) + goto done; + next = ctxt->input->cur[2]; + + if (next == '-') { + if ((!terminate) && (avail < 4)) + goto done; + if (ctxt->input->cur[3] == '-') { + if ((!terminate) && + (!xmlParseLookupString(ctxt, 4, "-->", 3))) + goto done; + xmlParseComment(ctxt); + ctxt->instate = XML_PARSER_CONTENT; + break; + } + } else if (next == '[') { + if ((!terminate) && (avail < 9)) + goto done; + if ((ctxt->input->cur[2] == '[') && + (ctxt->input->cur[3] == 'C') && + (ctxt->input->cur[4] == 'D') && + (ctxt->input->cur[5] == 'A') && + (ctxt->input->cur[6] == 'T') && + (ctxt->input->cur[7] == 'A') && + (ctxt->input->cur[8] == '[')) { + if ((!terminate) && + (!xmlParseLookupString(ctxt, 9, "]]>", 3))) + goto done; + ctxt->instate = XML_PARSER_CDATA_SECTION; + xmlParseCDSect(ctxt); + ctxt->instate = XML_PARSER_CONTENT; + break; + } + } + } + } else if (cur == '&') { + if ((!terminate) && (!xmlParseLookupChar(ctxt, ';'))) + goto done; + xmlParseReference(ctxt); + break; + } else { + /* TODO Avoid the extra copy, handle directly !!! */ + /* + * Goal of the following test is: + * - minimize calls to the SAX 'character' callback + * when they are mergeable + * - handle an problem for isBlank when we only parse + * a sequence of blank chars and the next one is + * not available to check against '<' presence. + * - tries to homogenize the differences in SAX + * callbacks between the push and pull versions + * of the parser. + */ + if (avail < XML_PARSER_BIG_BUFFER_SIZE) { + if ((!terminate) && (!xmlParseLookupCharData(ctxt))) + goto done; + } + ctxt->checkIndex = 0; + xmlParseCharDataInternal(ctxt, !terminate); + break; + } + + ctxt->instate = XML_PARSER_START_TAG; + break; + } + case XML_PARSER_END_TAG: + if ((!terminate) && (!xmlParseLookupChar(ctxt, '>'))) + goto done; + if (ctxt->sax2) { + xmlParseEndTag2(ctxt, &ctxt->pushTab[ctxt->nameNr - 1]); + nameNsPop(ctxt); + } +#ifdef LIBXML_SAX1_ENABLED + else + xmlParseEndTag1(ctxt, 0); +#endif /* LIBXML_SAX1_ENABLED */ + if (ctxt->nameNr == 0) { + ctxt->instate = XML_PARSER_EPILOG; + } else { + ctxt->instate = XML_PARSER_CONTENT; + } + break; + case XML_PARSER_MISC: + case XML_PARSER_PROLOG: + case XML_PARSER_EPILOG: + SKIP_BLANKS; + avail = ctxt->input->end - ctxt->input->cur; + if (avail < 1) + goto done; + if (ctxt->input->cur[0] == '<') { + if ((!terminate) && (avail < 2)) + goto done; + next = ctxt->input->cur[1]; + if (next == '?') { + if ((!terminate) && + (!xmlParseLookupString(ctxt, 2, "?>", 2))) + goto done; + xmlParsePI(ctxt); + break; + } else if (next == '!') { + if ((!terminate) && (avail < 3)) + goto done; + + if (ctxt->input->cur[2] == '-') { + if ((!terminate) && (avail < 4)) + goto done; + if (ctxt->input->cur[3] == '-') { + if ((!terminate) && + (!xmlParseLookupString(ctxt, 4, "-->", 3))) + goto done; + xmlParseComment(ctxt); + break; + } + } else if (ctxt->instate == XML_PARSER_MISC) { + if ((!terminate) && (avail < 9)) + goto done; + if ((ctxt->input->cur[2] == 'D') && + (ctxt->input->cur[3] == 'O') && + (ctxt->input->cur[4] == 'C') && + (ctxt->input->cur[5] == 'T') && + (ctxt->input->cur[6] == 'Y') && + (ctxt->input->cur[7] == 'P') && + (ctxt->input->cur[8] == 'E')) { + if ((!terminate) && (!xmlParseLookupGt(ctxt))) + goto done; + ctxt->inSubset = 1; + xmlParseDocTypeDecl(ctxt); + if (RAW == '[') { + ctxt->instate = XML_PARSER_DTD; + } else { + /* + * Create and update the external subset. + */ + ctxt->inSubset = 2; + if ((ctxt->sax != NULL) && + (!ctxt->disableSAX) && + (ctxt->sax->externalSubset != NULL)) + ctxt->sax->externalSubset( + ctxt->userData, + ctxt->intSubName, + ctxt->extSubSystem, + ctxt->extSubURI); + ctxt->inSubset = 0; + xmlCleanSpecialAttr(ctxt); + ctxt->instate = XML_PARSER_PROLOG; + } + break; + } + } + } + } + + if (ctxt->instate == XML_PARSER_EPILOG) { + if (ctxt->errNo == XML_ERR_OK) + xmlFatalErr(ctxt, XML_ERR_DOCUMENT_END, NULL); + ctxt->instate = XML_PARSER_EOF; + xmlFinishDocument(ctxt); + } else { + ctxt->instate = XML_PARSER_START_TAG; + } + break; + case XML_PARSER_DTD: { + if ((!terminate) && (!xmlParseLookupInternalSubset(ctxt))) + goto done; + xmlParseInternalSubset(ctxt); + ctxt->inSubset = 2; + if ((ctxt->sax != NULL) && (!ctxt->disableSAX) && + (ctxt->sax->externalSubset != NULL)) + ctxt->sax->externalSubset(ctxt->userData, ctxt->intSubName, + ctxt->extSubSystem, ctxt->extSubURI); + ctxt->inSubset = 0; + xmlCleanSpecialAttr(ctxt); + ctxt->instate = XML_PARSER_PROLOG; + break; + } + default: + xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, + "PP: internal error\n"); + ctxt->instate = XML_PARSER_EOF; + break; + } + } +done: + return(ret); +} + +/** + * xmlParseChunk: + * @ctxt: an XML parser context + * @chunk: chunk of memory + * @size: size of chunk in bytes + * @terminate: last chunk indicator + * + * Parse a chunk of memory in push parser mode. + * + * Assumes that the parser context was initialized with + * xmlCreatePushParserCtxt. + * + * The last chunk, which will often be empty, must be marked with + * the @terminate flag. With the default SAX callbacks, the resulting + * document will be available in ctxt->myDoc. This pointer will not + * be freed by the library. + * + * If the document isn't well-formed, ctxt->myDoc is set to NULL. + * The push parser doesn't support recovery mode. + * + * Returns an xmlParserErrors code (0 on success). + */ +int +xmlParseChunk(xmlParserCtxtPtr ctxt, const char *chunk, int size, + int terminate) { + size_t curBase; + size_t maxLength; + size_t pos; + int end_in_lf = 0; + int res; + + if ((ctxt == NULL) || (size < 0)) + return(XML_ERR_ARGUMENT); + if ((chunk == NULL) && (size > 0)) + return(XML_ERR_ARGUMENT); + if ((ctxt->input == NULL) || (ctxt->input->buf == NULL)) + return(XML_ERR_ARGUMENT); + if (ctxt->disableSAX != 0) + return(ctxt->errNo); + + ctxt->input->flags |= XML_INPUT_PROGRESSIVE; + if (ctxt->instate == XML_PARSER_START) + xmlCtxtInitializeLate(ctxt); + if ((size > 0) && (chunk != NULL) && (!terminate) && + (chunk[size - 1] == '\r')) { + end_in_lf = 1; + size--; + } + + /* + * Also push an empty chunk to make sure that the raw buffer + * will be flushed if there is an encoder. + */ + pos = ctxt->input->cur - ctxt->input->base; + res = xmlParserInputBufferPush(ctxt->input->buf, size, chunk); + xmlBufUpdateInput(ctxt->input->buf->buffer, ctxt->input, pos); + if (res < 0) { + xmlCtxtErrIO(ctxt, ctxt->input->buf->error, NULL); + xmlHaltParser(ctxt); + return(ctxt->errNo); + } + + xmlParseTryOrFinish(ctxt, terminate); + + curBase = ctxt->input->cur - ctxt->input->base; + maxLength = (ctxt->options & XML_PARSE_HUGE) ? + XML_MAX_HUGE_LENGTH : + XML_MAX_LOOKUP_LIMIT; + if (curBase > maxLength) { + xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT, + "Buffer size limit exceeded, try XML_PARSE_HUGE\n"); + xmlHaltParser(ctxt); + } + + if ((ctxt->errNo != XML_ERR_OK) && (ctxt->disableSAX != 0)) + return(ctxt->errNo); + + if (end_in_lf == 1) { + pos = ctxt->input->cur - ctxt->input->base; + res = xmlParserInputBufferPush(ctxt->input->buf, 1, "\r"); + xmlBufUpdateInput(ctxt->input->buf->buffer, ctxt->input, pos); + if (res < 0) { + xmlCtxtErrIO(ctxt, ctxt->input->buf->error, NULL); + xmlHaltParser(ctxt); + return(ctxt->errNo); + } + } + if (terminate) { + /* + * Check for termination + */ + if ((ctxt->instate != XML_PARSER_EOF) && + (ctxt->instate != XML_PARSER_EPILOG)) { + if (ctxt->nameNr > 0) { + const xmlChar *name = ctxt->nameTab[ctxt->nameNr - 1]; + int line = ctxt->pushTab[ctxt->nameNr - 1].line; + xmlFatalErrMsgStrIntStr(ctxt, XML_ERR_TAG_NOT_FINISHED, + "Premature end of data in tag %s line %d\n", + name, line, NULL); + } else if (ctxt->instate == XML_PARSER_START) { + xmlFatalErr(ctxt, XML_ERR_DOCUMENT_EMPTY, NULL); + } else { + xmlFatalErrMsg(ctxt, XML_ERR_DOCUMENT_EMPTY, + "Start tag expected, '<' not found\n"); + } + } else if ((ctxt->input->buf->encoder != NULL) && + (ctxt->input->buf->error == 0) && + (!xmlBufIsEmpty(ctxt->input->buf->raw))) { + xmlFatalErrMsg(ctxt, XML_ERR_INVALID_CHAR, + "Truncated multi-byte sequence at EOF\n"); + } + if (ctxt->instate != XML_PARSER_EOF) { + ctxt->instate = XML_PARSER_EOF; + xmlFinishDocument(ctxt); + } + } + if (ctxt->wellFormed == 0) + return((xmlParserErrors) ctxt->errNo); + else + return(0); +} + +/************************************************************************ + * * + * I/O front end functions to the parser * + * * + ************************************************************************/ + +/** + * xmlCreatePushParserCtxt: + * @sax: a SAX handler (optional) + * @user_data: user data for SAX callbacks (optional) + * @chunk: initial chunk (optional, deprecated) + * @size: size of initial chunk in bytes + * @filename: file name or URI (optional) + * + * Create a parser context for using the XML parser in push mode. + * See xmlParseChunk. + * + * Passing an initial chunk is useless and deprecated. + * + * @filename is used as base URI to fetch external entities and for + * error reports. + * + * Returns the new parser context or NULL if a memory allocation + * failed. + */ + +xmlParserCtxtPtr +xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, void *user_data, + const char *chunk, int size, const char *filename) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + + ctxt = xmlNewSAXParserCtxt(sax, user_data); + if (ctxt == NULL) + return(NULL); + + ctxt->options &= ~XML_PARSE_NODICT; + ctxt->dictNames = 1; + + input = xmlNewPushInput(filename, chunk, size); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + return(NULL); + } + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + return(ctxt); +} +#endif /* LIBXML_PUSH_ENABLED */ + +/** + * xmlStopParser: + * @ctxt: an XML parser context + * + * Blocks further parser processing + */ +void +xmlStopParser(xmlParserCtxtPtr ctxt) { + if (ctxt == NULL) + return; + xmlHaltParser(ctxt); + if (ctxt->errNo != XML_ERR_NO_MEMORY) + ctxt->errNo = XML_ERR_USER_STOP; +} + +/** + * xmlCreateIOParserCtxt: + * @sax: a SAX handler (optional) + * @user_data: user data for SAX callbacks (optional) + * @ioread: an I/O read function + * @ioclose: an I/O close function (optional) + * @ioctx: an I/O handler + * @enc: the charset encoding if known (deprecated) + * + * Create a parser context for using the XML parser with an existing + * I/O stream + * + * Returns the new parser context or NULL + */ +xmlParserCtxtPtr +xmlCreateIOParserCtxt(xmlSAXHandlerPtr sax, void *user_data, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, xmlCharEncoding enc) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + const char *encoding; + + ctxt = xmlNewSAXParserCtxt(sax, user_data); + if (ctxt == NULL) + return(NULL); + + encoding = xmlGetCharEncodingName(enc); + input = xmlCtxtNewInputFromIO(ctxt, NULL, ioread, ioclose, ioctx, + encoding, 0); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + return (NULL); + } + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + return(ctxt); +} + +#ifdef LIBXML_VALID_ENABLED +/************************************************************************ + * * + * Front ends when parsing a DTD * + * * + ************************************************************************/ + +/** + * xmlCtxtParseDtd: + * @ctxt: a parser context + * @input: a parser input + * @publicId: public ID of the DTD (optional) + * @systemId: system ID of the DTD (optional) + * + * Parse a DTD. + * + * Option XML_PARSE_DTDLOAD should be enabled in the parser context + * to make external entities work. + * + * Availabe since 2.14.0. + * + * Returns the resulting xmlDtdPtr or NULL in case of error. + * @input will be freed by the function in any case. + */ +xmlDtdPtr +xmlCtxtParseDtd(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, + const xmlChar *publicId, const xmlChar *systemId) { + xmlDtdPtr ret = NULL; + + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + return(NULL); + } + + if (publicId == NULL) + publicId = BAD_CAST "none"; + if (systemId == NULL) + systemId = BAD_CAST "none"; + + ctxt->myDoc = xmlNewDoc(BAD_CAST "1.0"); + if (ctxt->myDoc == NULL) { + xmlErrMemory(ctxt); + goto error; + } + ctxt->myDoc->properties = XML_DOC_INTERNAL; + ctxt->myDoc->extSubset = xmlNewDtd(ctxt->myDoc, BAD_CAST "none", + publicId, systemId); + if (ctxt->myDoc->extSubset == NULL) { + xmlErrMemory(ctxt); + xmlFreeDoc(ctxt->myDoc); + goto error; + } + + xmlParseExternalSubset(ctxt, publicId, systemId); + + if (ctxt->wellFormed) { + ret = ctxt->myDoc->extSubset; + ctxt->myDoc->extSubset = NULL; + if (ret != NULL) { + xmlNodePtr tmp; + + ret->doc = NULL; + tmp = ret->children; + while (tmp != NULL) { + tmp->doc = NULL; + tmp = tmp->next; + } + } + } else { + ret = NULL; + } + xmlFreeDoc(ctxt->myDoc); + ctxt->myDoc = NULL; + +error: + xmlFreeInputStream(xmlCtxtPopInput(ctxt)); + + return(ret); +} + +/** + * xmlIOParseDTD: + * @sax: the SAX handler block or NULL + * @input: an Input Buffer + * @enc: the charset encoding if known + * + * DEPRECATED: Use xmlCtxtParseDtd. + * + * Load and parse a DTD + * + * Returns the resulting xmlDtdPtr or NULL in case of error. + * @input will be freed by the function in any case. + */ + +xmlDtdPtr +xmlIOParseDTD(xmlSAXHandlerPtr sax, xmlParserInputBufferPtr input, + xmlCharEncoding enc) { + xmlDtdPtr ret = NULL; + xmlParserCtxtPtr ctxt; + xmlParserInputPtr pinput = NULL; + + if (input == NULL) + return(NULL); + + ctxt = xmlNewSAXParserCtxt(sax, NULL); + if (ctxt == NULL) { + xmlFreeParserInputBuffer(input); + return(NULL); + } + xmlCtxtSetOptions(ctxt, XML_PARSE_DTDLOAD); + + /* + * generate a parser input from the I/O handler + */ + + pinput = xmlNewIOInputStream(ctxt, input, XML_CHAR_ENCODING_NONE); + if (pinput == NULL) { + xmlFreeParserInputBuffer(input); + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + if (enc != XML_CHAR_ENCODING_NONE) { + xmlSwitchEncoding(ctxt, enc); + } + + ret = xmlCtxtParseDtd(ctxt, pinput, NULL, NULL); + + xmlFreeParserCtxt(ctxt); + return(ret); +} + +/** + * xmlSAXParseDTD: + * @sax: the SAX handler block + * @ExternalID: a NAME* containing the External ID of the DTD + * @SystemID: a NAME* containing the URL to the DTD + * + * DEPRECATED: Use xmlCtxtParseDtd. + * + * Load and parse an external subset. + * + * Returns the resulting xmlDtdPtr or NULL in case of error. + */ + +xmlDtdPtr +xmlSAXParseDTD(xmlSAXHandlerPtr sax, const xmlChar *ExternalID, + const xmlChar *SystemID) { + xmlDtdPtr ret = NULL; + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input = NULL; + xmlChar* systemIdCanonic; + + if ((ExternalID == NULL) && (SystemID == NULL)) return(NULL); + + ctxt = xmlNewSAXParserCtxt(sax, NULL); + if (ctxt == NULL) { + return(NULL); + } + xmlCtxtSetOptions(ctxt, XML_PARSE_DTDLOAD); + + /* + * Canonicalise the system ID + */ + systemIdCanonic = xmlCanonicPath(SystemID); + if ((SystemID != NULL) && (systemIdCanonic == NULL)) { + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + /* + * Ask the Entity resolver to load the damn thing + */ + + if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL)) + input = ctxt->sax->resolveEntity(ctxt->userData, ExternalID, + systemIdCanonic); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + if (systemIdCanonic != NULL) + xmlFree(systemIdCanonic); + return(NULL); + } + + if (input->filename == NULL) + input->filename = (char *) systemIdCanonic; + else + xmlFree(systemIdCanonic); + + ret = xmlCtxtParseDtd(ctxt, input, ExternalID, SystemID); + + xmlFreeParserCtxt(ctxt); + return(ret); +} + + +/** + * xmlParseDTD: + * @ExternalID: a NAME* containing the External ID of the DTD + * @SystemID: a NAME* containing the URL to the DTD + * + * Load and parse an external subset. + * + * Returns the resulting xmlDtdPtr or NULL in case of error. + */ + +xmlDtdPtr +xmlParseDTD(const xmlChar *ExternalID, const xmlChar *SystemID) { + return(xmlSAXParseDTD(NULL, ExternalID, SystemID)); +} +#endif /* LIBXML_VALID_ENABLED */ + +/************************************************************************ + * * + * Front ends when parsing an Entity * + * * + ************************************************************************/ + +static xmlNodePtr +xmlCtxtParseContentInternal(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, + int hasTextDecl, int buildTree) { + xmlNodePtr root = NULL; + xmlNodePtr list = NULL; + xmlChar *rootName = BAD_CAST "#root"; + int result; + + if (buildTree) { + root = xmlNewDocNode(ctxt->myDoc, NULL, rootName, NULL); + if (root == NULL) { + xmlErrMemory(ctxt); + goto error; + } + } + + if (xmlCtxtPushInput(ctxt, input) < 0) + goto error; + + nameNsPush(ctxt, rootName, NULL, NULL, 0, 0); + spacePush(ctxt, -1); + + if (buildTree) + nodePush(ctxt, root); + + if (hasTextDecl) { + xmlDetectEncoding(ctxt); + + /* + * Parse a possible text declaration first + */ + if ((CMP5(CUR_PTR, '<', '?', 'x', 'm', 'l')) && + (IS_BLANK_CH(NXT(5)))) { + xmlParseTextDecl(ctxt); + /* + * An XML-1.0 document can't reference an entity not XML-1.0 + */ + if ((xmlStrEqual(ctxt->version, BAD_CAST "1.0")) && + (!xmlStrEqual(ctxt->input->version, BAD_CAST "1.0"))) { + xmlFatalErrMsg(ctxt, XML_ERR_VERSION_MISMATCH, + "Version mismatch between document and " + "entity\n"); + } + } + } + + xmlParseContentInternal(ctxt); + + if (ctxt->input->cur < ctxt->input->end) + xmlFatalErr(ctxt, XML_ERR_NOT_WELL_BALANCED, NULL); + + if ((ctxt->wellFormed) || + ((ctxt->recovery) && (!xmlCtxtIsCatastrophicError(ctxt)))) { + if (root != NULL) { + xmlNodePtr cur; + + /* + * Unlink newly created node list. + */ + list = root->children; + root->children = NULL; + root->last = NULL; + for (cur = list; cur != NULL; cur = cur->next) + cur->parent = NULL; + } + } + + /* + * Read the rest of the stream in case of errors. We want + * to account for the whole entity size. + */ + do { + ctxt->input->cur = ctxt->input->end; + xmlParserShrink(ctxt); + result = xmlParserGrow(ctxt); + } while (result > 0); + + if (buildTree) + nodePop(ctxt); + + namePop(ctxt); + spacePop(ctxt); + + xmlCtxtPopInput(ctxt); + +error: + xmlFreeNode(root); + + return(list); +} + +static void +xmlCtxtParseEntity(xmlParserCtxtPtr ctxt, xmlEntityPtr ent) { + xmlParserInputPtr input; + xmlNodePtr list; + unsigned long consumed; + int isExternal; + int buildTree; + int oldMinNsIndex; + int oldNodelen, oldNodemem; + + isExternal = (ent->etype == XML_EXTERNAL_GENERAL_PARSED_ENTITY); + buildTree = (ctxt->node != NULL); + + /* + * Recursion check + */ + if (ent->flags & XML_ENT_EXPANDING) { + xmlFatalErr(ctxt, XML_ERR_ENTITY_LOOP, NULL); + xmlHaltParser(ctxt); + goto error; + } + + /* + * Load entity + */ + input = xmlNewEntityInputStream(ctxt, ent); + if (input == NULL) + goto error; + + /* + * When building a tree, we need to limit the scope of namespace + * declarations, so that entities don't reference xmlNs structs + * from the parent of a reference. + */ + oldMinNsIndex = ctxt->nsdb->minNsIndex; + if (buildTree) + ctxt->nsdb->minNsIndex = ctxt->nsNr; + + oldNodelen = ctxt->nodelen; + oldNodemem = ctxt->nodemem; + ctxt->nodelen = 0; + ctxt->nodemem = 0; + + /* + * Parse content + * + * This initiates a recursive call chain: + * + * - xmlCtxtParseContentInternal + * - xmlParseContentInternal + * - xmlParseReference + * - xmlCtxtParseEntity + * + * The nesting depth is limited by the maximum number of inputs, + * see xmlCtxtPushInput. + * + * It's possible to make this non-recursive (minNsIndex must be + * stored in the input struct) at the expense of code readability. + */ + + ent->flags |= XML_ENT_EXPANDING; + + list = xmlCtxtParseContentInternal(ctxt, input, isExternal, buildTree); + + ent->flags &= ~XML_ENT_EXPANDING; + + ctxt->nsdb->minNsIndex = oldMinNsIndex; + ctxt->nodelen = oldNodelen; + ctxt->nodemem = oldNodemem; + + /* + * Entity size accounting + */ + consumed = input->consumed; + xmlSaturatedAddSizeT(&consumed, input->end - input->base); + + if ((ent->flags & XML_ENT_CHECKED) == 0) + xmlSaturatedAdd(&ent->expandedSize, consumed); + + if ((ent->flags & XML_ENT_PARSED) == 0) { + if (isExternal) + xmlSaturatedAdd(&ctxt->sizeentities, consumed); + + ent->children = list; + + while (list != NULL) { + list->parent = (xmlNodePtr) ent; + + /* + * Downstream code like the nginx xslt module can set + * ctxt->myDoc->extSubset to a separate DTD, so the entity + * might have a different or a NULL document. + */ + if (list->doc != ent->doc) + xmlSetTreeDoc(list, ent->doc); + + if (list->next == NULL) + ent->last = list; + list = list->next; + } + } else { + xmlFreeNodeList(list); + } + + xmlFreeInputStream(input); + +error: + ent->flags |= XML_ENT_PARSED | XML_ENT_CHECKED; +} + +/** + * xmlParseCtxtExternalEntity: + * @ctxt: the existing parsing context + * @URL: the URL for the entity to load + * @ID: the System ID for the entity to load + * @listOut: the return value for the set of parsed nodes + * + * Parse an external general entity within an existing parsing context + * An external general parsed entity is well-formed if it matches the + * production labeled extParsedEnt. + * + * [78] extParsedEnt ::= TextDecl? content + * + * Returns 0 if the entity is well formed, -1 in case of args problem and + * the parser error code otherwise + */ + +int +xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctxt, const xmlChar *URL, + const xmlChar *ID, xmlNodePtr *listOut) { + xmlParserInputPtr input; + xmlNodePtr list; + + if (listOut != NULL) + *listOut = NULL; + + if (ctxt == NULL) + return(XML_ERR_ARGUMENT); + + input = xmlLoadResource(ctxt, (char *) URL, (char *) ID, + XML_RESOURCE_GENERAL_ENTITY); + if (input == NULL) + return(ctxt->errNo); + + xmlCtxtInitializeLate(ctxt); + + list = xmlCtxtParseContentInternal(ctxt, input, /* hasTextDecl */ 1, 1); + if (listOut != NULL) + *listOut = list; + else + xmlFreeNodeList(list); + + xmlFreeInputStream(input); + return(ctxt->errNo); +} + +#ifdef LIBXML_SAX1_ENABLED +/** + * xmlParseExternalEntity: + * @doc: the document the chunk pertains to + * @sax: the SAX handler block (possibly NULL) + * @user_data: The user data returned on SAX callbacks (possibly NULL) + * @depth: Used for loop detection, use 0 + * @URL: the URL for the entity to load + * @ID: the System ID for the entity to load + * @list: the return value for the set of parsed nodes + * + * DEPRECATED: Use xmlParseCtxtExternalEntity. + * + * Parse an external general entity + * An external general parsed entity is well-formed if it matches the + * production labeled extParsedEnt. + * + * [78] extParsedEnt ::= TextDecl? content + * + * Returns 0 if the entity is well formed, -1 in case of args problem and + * the parser error code otherwise + */ + +int +xmlParseExternalEntity(xmlDocPtr doc, xmlSAXHandlerPtr sax, void *user_data, + int depth, const xmlChar *URL, const xmlChar *ID, xmlNodePtr *list) { + xmlParserCtxtPtr ctxt; + int ret; + + if (list != NULL) + *list = NULL; + + if (doc == NULL) + return(XML_ERR_ARGUMENT); + + ctxt = xmlNewSAXParserCtxt(sax, user_data); + if (ctxt == NULL) + return(XML_ERR_NO_MEMORY); + + ctxt->depth = depth; + ctxt->myDoc = doc; + ret = xmlParseCtxtExternalEntity(ctxt, URL, ID, list); + + xmlFreeParserCtxt(ctxt); + return(ret); +} + +/** + * xmlParseBalancedChunkMemory: + * @doc: the document the chunk pertains to (must not be NULL) + * @sax: the SAX handler block (possibly NULL) + * @user_data: The user data returned on SAX callbacks (possibly NULL) + * @depth: Used for loop detection, use 0 + * @string: the input string in UTF8 or ISO-Latin (zero terminated) + * @lst: the return value for the set of parsed nodes + * + * Parse a well-balanced chunk of an XML document + * called by the parser + * The allowed sequence for the Well Balanced Chunk is the one defined by + * the content production in the XML grammar: + * + * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* + * + * Returns 0 if the chunk is well balanced, -1 in case of args problem and + * the parser error code otherwise + */ + +int +xmlParseBalancedChunkMemory(xmlDocPtr doc, xmlSAXHandlerPtr sax, + void *user_data, int depth, const xmlChar *string, xmlNodePtr *lst) { + return xmlParseBalancedChunkMemoryRecover( doc, sax, user_data, + depth, string, lst, 0 ); +} +#endif /* LIBXML_SAX1_ENABLED */ + +/** + * xmlCtxtParseContent: + * @ctxt: parser context + * @input: parser input + * @node: target node or document + * @hasTextDecl: whether to parse text declaration + * + * Parse a well-balanced chunk of XML matching the 'content' production. + * + * Namespaces in scope of @node and entities of @node's document are + * recognized. When validating, the DTD of @node's document is used. + * + * Always consumes @input even in error case. + * + * Available since 2.14.0. + * + * Returns a node list or NULL in case of error. + */ +xmlNodePtr +xmlCtxtParseContent(xmlParserCtxtPtr ctxt, xmlParserInputPtr input, + xmlNodePtr node, int hasTextDecl) { + xmlDocPtr doc; + xmlNodePtr cur, list = NULL; + int nsnr = 0; + xmlDictPtr oldDict; + int oldOptions, oldDictNames, oldLoadSubset; + + if ((ctxt == NULL) || (input == NULL) || (node == NULL)) { + xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL); + goto exit; + } + + doc = node->doc; + if (doc == NULL) { + xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL); + goto exit; + } + + switch (node->type) { + case XML_ELEMENT_NODE: + case XML_DOCUMENT_NODE: + case XML_HTML_DOCUMENT_NODE: + break; + + case XML_ATTRIBUTE_NODE: + case XML_TEXT_NODE: + case XML_CDATA_SECTION_NODE: + case XML_ENTITY_REF_NODE: + case XML_PI_NODE: + case XML_COMMENT_NODE: + for (cur = node->parent; cur != NULL; cur = node->parent) { + if ((cur->type == XML_ELEMENT_NODE) || + (cur->type == XML_DOCUMENT_NODE) || + (cur->type == XML_HTML_DOCUMENT_NODE)) { + node = cur; + break; + } + } + break; + + default: + xmlFatalErr(ctxt, XML_ERR_ARGUMENT, NULL); + goto exit; + } + +#ifdef LIBXML_HTML_ENABLED + if (ctxt->html) + htmlCtxtReset(ctxt); + else +#endif + xmlCtxtReset(ctxt); + + oldDict = ctxt->dict; + oldOptions = ctxt->options; + oldDictNames = ctxt->dictNames; + oldLoadSubset = ctxt->loadsubset; + + /* + * Use input doc's dict if present, else assure XML_PARSE_NODICT is set. + */ + if (doc->dict != NULL) { + ctxt->dict = doc->dict; + } else { + ctxt->options |= XML_PARSE_NODICT; + ctxt->dictNames = 0; + } + + /* + * Disable IDs + */ + ctxt->loadsubset |= XML_SKIP_IDS; + + ctxt->myDoc = doc; + +#ifdef LIBXML_HTML_ENABLED + if (ctxt->html) { + /* + * When parsing in context, it makes no sense to add implied + * elements like html/body/etc... + */ + ctxt->options |= HTML_PARSE_NOIMPLIED; + + list = htmlCtxtParseContentInternal(ctxt, input); + } else +#endif + { + xmlCtxtInitializeLate(ctxt); + + /* + * This hack lowers the error level of undeclared entities + * from XML_ERR_FATAL (well-formedness error) to XML_ERR_ERROR + * or XML_ERR_WARNING. + */ + ctxt->hasExternalSubset = 1; + + /* + * initialize the SAX2 namespaces stack + */ + cur = node; + while ((cur != NULL) && (cur->type == XML_ELEMENT_NODE)) { + xmlNsPtr ns = cur->nsDef; + xmlHashedString hprefix, huri; + + while (ns != NULL) { + hprefix = xmlDictLookupHashed(ctxt->dict, ns->prefix, -1); + huri = xmlDictLookupHashed(ctxt->dict, ns->href, -1); + if (xmlParserNsPush(ctxt, &hprefix, &huri, ns, 1) > 0) + nsnr++; + ns = ns->next; + } + cur = cur->parent; + } + + list = xmlCtxtParseContentInternal(ctxt, input, hasTextDecl, 1); + + if (nsnr > 0) + xmlParserNsPop(ctxt, nsnr); + } + + ctxt->dict = oldDict; + ctxt->options = oldOptions; + ctxt->dictNames = oldDictNames; + ctxt->loadsubset = oldLoadSubset; + ctxt->myDoc = NULL; + ctxt->node = NULL; + +exit: + xmlFreeInputStream(input); + return(list); +} + +/** + * xmlParseInNodeContext: + * @node: the context node + * @data: the input string + * @datalen: the input string length in bytes + * @options: a combination of xmlParserOption + * @listOut: the return value for the set of parsed nodes + * + * Parse a well-balanced chunk of an XML document + * within the context (DTD, namespaces, etc ...) of the given node. + * + * The allowed sequence for the data is a Well Balanced Chunk defined by + * the content production in the XML grammar: + * + * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* + * + * This function assumes the encoding of @node's document which is + * typically not what you want. A better alternative is + * xmlCtxtParseContent. + * + * Returns XML_ERR_OK if the chunk is well balanced, and the parser + * error code otherwise + */ +xmlParserErrors +xmlParseInNodeContext(xmlNodePtr node, const char *data, int datalen, + int options, xmlNodePtr *listOut) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlDocPtr doc; + xmlNodePtr list; + xmlParserErrors ret; + + if (listOut == NULL) + return(XML_ERR_INTERNAL_ERROR); + *listOut = NULL; + + if ((node == NULL) || (data == NULL) || (datalen < 0)) + return(XML_ERR_INTERNAL_ERROR); + + doc = node->doc; + if (doc == NULL) + return(XML_ERR_INTERNAL_ERROR); + +#ifdef LIBXML_HTML_ENABLED + if (doc->type == XML_HTML_DOCUMENT_NODE) { + ctxt = htmlNewParserCtxt(); + } + else +#endif + ctxt = xmlNewParserCtxt(); + + if (ctxt == NULL) + return(XML_ERR_NO_MEMORY); + + input = xmlCtxtNewInputFromMemory(ctxt, NULL, data, datalen, + (const char *) doc->encoding, + XML_INPUT_BUF_STATIC); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + return(XML_ERR_NO_MEMORY); + } + + xmlCtxtUseOptions(ctxt, options); + + list = xmlCtxtParseContent(ctxt, input, node, /* hasTextDecl */ 0); + + if (list == NULL) { + ret = ctxt->errNo; + if (ret == XML_ERR_ARGUMENT) + ret = XML_ERR_INTERNAL_ERROR; + } else { + ret = XML_ERR_OK; + *listOut = list; + } + + xmlFreeParserCtxt(ctxt); + + return(ret); +} + +#ifdef LIBXML_SAX1_ENABLED +/** + * xmlParseBalancedChunkMemoryRecover: + * @doc: the document the chunk pertains to (must not be NULL) + * @sax: the SAX handler block (possibly NULL) + * @user_data: The user data returned on SAX callbacks (possibly NULL) + * @depth: Used for loop detection, use 0 + * @string: the input string in UTF8 or ISO-Latin (zero terminated) + * @listOut: the return value for the set of parsed nodes + * @recover: return nodes even if the data is broken (use 0) + * + * Parse a well-balanced chunk of an XML document + * + * The allowed sequence for the Well Balanced Chunk is the one defined by + * the content production in the XML grammar: + * + * [43] content ::= (element | CharData | Reference | CDSect | PI | Comment)* + * + * Returns 0 if the chunk is well balanced, or thehe parser error code + * otherwise. + * + * In case recover is set to 1, the nodelist will not be empty even if + * the parsed chunk is not well balanced, assuming the parsing succeeded to + * some extent. + */ +int +xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, xmlSAXHandlerPtr sax, + void *user_data, int depth, const xmlChar *string, xmlNodePtr *listOut, + int recover) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlNodePtr list; + int ret; + + if (listOut != NULL) + *listOut = NULL; + + if (string == NULL) + return(XML_ERR_ARGUMENT); + + ctxt = xmlNewSAXParserCtxt(sax, user_data); + if (ctxt == NULL) + return(XML_ERR_NO_MEMORY); + + xmlCtxtInitializeLate(ctxt); + + ctxt->depth = depth; + ctxt->myDoc = doc; + if (recover) { + ctxt->options |= XML_PARSE_RECOVER; + ctxt->recovery = 1; + } + + input = xmlNewStringInputStream(ctxt, string); + if (input == NULL) { + ret = ctxt->errNo; + goto error; + } + + list = xmlCtxtParseContentInternal(ctxt, input, /* hasTextDecl */ 0, 1); + if (listOut != NULL) + *listOut = list; + else + xmlFreeNodeList(list); + + if (!ctxt->wellFormed) + ret = ctxt->errNo; + else + ret = XML_ERR_OK; + +error: + xmlFreeInputStream(input); + xmlFreeParserCtxt(ctxt); + return(ret); +} + +/** + * xmlSAXParseEntity: + * @sax: the SAX handler block + * @filename: the filename + * + * DEPRECATED: Don't use. + * + * parse an XML external entity out of context and build a tree. + * It use the given SAX function block to handle the parsing callback. + * If sax is NULL, fallback to the default DOM tree building routines. + * + * [78] extParsedEnt ::= TextDecl? content + * + * This correspond to a "Well Balanced" chunk + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlSAXParseEntity(xmlSAXHandlerPtr sax, const char *filename) { + xmlDocPtr ret; + xmlParserCtxtPtr ctxt; + + ctxt = xmlCreateFileParserCtxt(filename); + if (ctxt == NULL) { + return(NULL); + } + if (sax != NULL) { + if (sax->initialized == XML_SAX2_MAGIC) { + *ctxt->sax = *sax; + } else { + memset(ctxt->sax, 0, sizeof(*ctxt->sax)); + memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); + } + ctxt->userData = NULL; + } + + xmlParseExtParsedEnt(ctxt); + + if (ctxt->wellFormed) { + ret = ctxt->myDoc; + } else { + ret = NULL; + xmlFreeDoc(ctxt->myDoc); + } + + xmlFreeParserCtxt(ctxt); + + return(ret); +} + +/** + * xmlParseEntity: + * @filename: the filename + * + * parse an XML external entity out of context and build a tree. + * + * [78] extParsedEnt ::= TextDecl? content + * + * This correspond to a "Well Balanced" chunk + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlParseEntity(const char *filename) { + return(xmlSAXParseEntity(NULL, filename)); +} +#endif /* LIBXML_SAX1_ENABLED */ + +/** + * xmlCreateEntityParserCtxt: + * @URL: the entity URL + * @ID: the entity PUBLIC ID + * @base: a possible base for the target URI + * + * DEPRECATED: Don't use. + * + * Create a parser context for an external entity + * Automatic support for ZLIB/Compress compressed document is provided + * by default if found at compile-time. + * + * Returns the new parser context or NULL + */ +xmlParserCtxtPtr +xmlCreateEntityParserCtxt(const xmlChar *URL, const xmlChar *ID, + const xmlChar *base) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlChar *uri = NULL; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + if (base != NULL) { + if (xmlBuildURISafe(URL, base, &uri) < 0) + goto error; + if (uri != NULL) + URL = uri; + } + + input = xmlLoadResource(ctxt, (char *) URL, (char *) ID, + XML_RESOURCE_UNKNOWN); + if (input == NULL) + goto error; + + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + goto error; + } + + xmlFree(uri); + return(ctxt); + +error: + xmlFree(uri); + xmlFreeParserCtxt(ctxt); + return(NULL); +} + +/************************************************************************ + * * + * Front ends when parsing from a file * + * * + ************************************************************************/ + +/** + * xmlCreateURLParserCtxt: + * @filename: the filename or URL + * @options: a combination of xmlParserOption + * + * DEPRECATED: Use xmlNewParserCtxt and xmlCtxtReadFile. + * + * Create a parser context for a file or URL content. + * Automatic support for ZLIB/Compress compressed document is provided + * by default if found at compile-time and for file accesses + * + * Returns the new parser context or NULL + */ +xmlParserCtxtPtr +xmlCreateURLParserCtxt(const char *filename, int options) +{ + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + xmlCtxtUseOptions(ctxt, options); + ctxt->linenumbers = 1; + + input = xmlLoadResource(ctxt, filename, NULL, XML_RESOURCE_MAIN_DOCUMENT); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + return(NULL); + } + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + return(ctxt); +} + +/** + * xmlCreateFileParserCtxt: + * @filename: the filename + * + * DEPRECATED: Use xmlNewParserCtxt and xmlCtxtReadFile. + * + * Create a parser context for a file content. + * Automatic support for ZLIB/Compress compressed document is provided + * by default if found at compile-time. + * + * Returns the new parser context or NULL + */ +xmlParserCtxtPtr +xmlCreateFileParserCtxt(const char *filename) +{ + return(xmlCreateURLParserCtxt(filename, 0)); +} + +#ifdef LIBXML_SAX1_ENABLED +/** + * xmlSAXParseFileWithData: + * @sax: the SAX handler block + * @filename: the filename + * @recovery: work in recovery mode, i.e. tries to read no Well Formed + * documents + * @data: the userdata + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadFile. + * + * parse an XML file and build a tree. Automatic support for ZLIB/Compress + * compressed document is provided by default if found at compile-time. + * It use the given SAX function block to handle the parsing callback. + * If sax is NULL, fallback to the default DOM tree building routines. + * + * User data (void *) is stored within the parser context in the + * context's _private member, so it is available nearly everywhere in libxml + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlSAXParseFileWithData(xmlSAXHandlerPtr sax, const char *filename, + int recovery, void *data) { + xmlDocPtr ret; + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + + ctxt = xmlNewSAXParserCtxt(sax, NULL); + if (ctxt == NULL) + return(NULL); + + if (data != NULL) + ctxt->_private = data; + + if (recovery) { + ctxt->options |= XML_PARSE_RECOVER; + ctxt->recovery = 1; + } + + if ((filename != NULL) && (filename[0] == '-') && (filename[1] == 0)) + input = xmlCtxtNewInputFromFd(ctxt, filename, STDIN_FILENO, NULL, 0); + else + input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, NULL, 0); + + ret = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(ret); +} + +/** + * xmlSAXParseFile: + * @sax: the SAX handler block + * @filename: the filename + * @recovery: work in recovery mode, i.e. tries to read no Well Formed + * documents + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadFile. + * + * parse an XML file and build a tree. Automatic support for ZLIB/Compress + * compressed document is provided by default if found at compile-time. + * It use the given SAX function block to handle the parsing callback. + * If sax is NULL, fallback to the default DOM tree building routines. + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlSAXParseFile(xmlSAXHandlerPtr sax, const char *filename, + int recovery) { + return(xmlSAXParseFileWithData(sax,filename,recovery,NULL)); +} + +/** + * xmlRecoverDoc: + * @cur: a pointer to an array of xmlChar + * + * DEPRECATED: Use xmlReadDoc with XML_PARSE_RECOVER. + * + * parse an XML in-memory document and build a tree. + * In the case the document is not Well Formed, a attempt to build a + * tree is tried anyway + * + * Returns the resulting document tree or NULL in case of failure + */ + +xmlDocPtr +xmlRecoverDoc(const xmlChar *cur) { + return(xmlSAXParseDoc(NULL, cur, 1)); +} + +/** + * xmlParseFile: + * @filename: the filename + * + * DEPRECATED: Use xmlReadFile. + * + * parse an XML file and build a tree. Automatic support for ZLIB/Compress + * compressed document is provided by default if found at compile-time. + * + * Returns the resulting document tree if the file was wellformed, + * NULL otherwise. + */ + +xmlDocPtr +xmlParseFile(const char *filename) { + return(xmlSAXParseFile(NULL, filename, 0)); +} + +/** + * xmlRecoverFile: + * @filename: the filename + * + * DEPRECATED: Use xmlReadFile with XML_PARSE_RECOVER. + * + * parse an XML file and build a tree. Automatic support for ZLIB/Compress + * compressed document is provided by default if found at compile-time. + * In the case the document is not Well Formed, it attempts to build + * a tree anyway + * + * Returns the resulting document tree or NULL in case of failure + */ + +xmlDocPtr +xmlRecoverFile(const char *filename) { + return(xmlSAXParseFile(NULL, filename, 1)); +} + + +/** + * xmlSetupParserForBuffer: + * @ctxt: an XML parser context + * @buffer: a xmlChar * buffer + * @filename: a file name + * + * DEPRECATED: Don't use. + * + * Setup the parser context to parse a new buffer; Clears any prior + * contents from the parser context. The buffer parameter must not be + * NULL, but the filename parameter can be + */ +void +xmlSetupParserForBuffer(xmlParserCtxtPtr ctxt, const xmlChar* buffer, + const char* filename) +{ + xmlParserInputPtr input; + + if ((ctxt == NULL) || (buffer == NULL)) + return; + + xmlClearParserCtxt(ctxt); + + input = xmlCtxtNewInputFromString(ctxt, filename, (const char *) buffer, + NULL, 0); + if (input == NULL) + return; + if (xmlCtxtPushInput(ctxt, input) < 0) + xmlFreeInputStream(input); +} + +/** + * xmlSAXUserParseFile: + * @sax: a SAX handler + * @user_data: The user data returned on SAX callbacks + * @filename: a file name + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadFile. + * + * parse an XML file and call the given SAX handler routines. + * Automatic support for ZLIB/Compress compressed document is provided + * + * Returns 0 in case of success or a error number otherwise + */ +int +xmlSAXUserParseFile(xmlSAXHandlerPtr sax, void *user_data, + const char *filename) { + int ret = 0; + xmlParserCtxtPtr ctxt; + + ctxt = xmlCreateFileParserCtxt(filename); + if (ctxt == NULL) return -1; + if (sax != NULL) { + if (sax->initialized == XML_SAX2_MAGIC) { + *ctxt->sax = *sax; + } else { + memset(ctxt->sax, 0, sizeof(*ctxt->sax)); + memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); + } + ctxt->userData = user_data; + } + + xmlParseDocument(ctxt); + + if (ctxt->wellFormed) + ret = 0; + else { + if (ctxt->errNo != 0) + ret = ctxt->errNo; + else + ret = -1; + } + if (ctxt->myDoc != NULL) { + xmlFreeDoc(ctxt->myDoc); + ctxt->myDoc = NULL; + } + xmlFreeParserCtxt(ctxt); + + return ret; +} +#endif /* LIBXML_SAX1_ENABLED */ + +/************************************************************************ + * * + * Front ends when parsing from memory * + * * + ************************************************************************/ + +/** + * xmlCreateMemoryParserCtxt: + * @buffer: a pointer to a char array + * @size: the size of the array + * + * Create a parser context for an XML in-memory document. The input buffer + * must not contain a terminating null byte. + * + * Returns the new parser context or NULL + */ +xmlParserCtxtPtr +xmlCreateMemoryParserCtxt(const char *buffer, int size) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + + if (size < 0) + return(NULL); + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + input = xmlCtxtNewInputFromMemory(ctxt, NULL, buffer, size, NULL, 0); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + return(NULL); + } + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + return(ctxt); +} + +#ifdef LIBXML_SAX1_ENABLED +/** + * xmlSAXParseMemoryWithData: + * @sax: the SAX handler block + * @buffer: an pointer to a char array + * @size: the size of the array + * @recovery: work in recovery mode, i.e. tries to read no Well Formed + * documents + * @data: the userdata + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadMemory. + * + * parse an XML in-memory block and use the given SAX function block + * to handle the parsing callback. If sax is NULL, fallback to the default + * DOM tree building routines. + * + * User data (void *) is stored within the parser context in the + * context's _private member, so it is available nearly everywhere in libxml + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlSAXParseMemoryWithData(xmlSAXHandlerPtr sax, const char *buffer, + int size, int recovery, void *data) { + xmlDocPtr ret; + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + + if (size < 0) + return(NULL); + + ctxt = xmlNewSAXParserCtxt(sax, NULL); + if (ctxt == NULL) + return(NULL); + + if (data != NULL) + ctxt->_private=data; + + if (recovery) { + ctxt->options |= XML_PARSE_RECOVER; + ctxt->recovery = 1; + } + + input = xmlCtxtNewInputFromMemory(ctxt, NULL, buffer, size, NULL, + XML_INPUT_BUF_STATIC); + + ret = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(ret); +} + +/** + * xmlSAXParseMemory: + * @sax: the SAX handler block + * @buffer: an pointer to a char array + * @size: the size of the array + * @recovery: work in recovery mode, i.e. tries to read not Well Formed + * documents + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadMemory. + * + * parse an XML in-memory block and use the given SAX function block + * to handle the parsing callback. If sax is NULL, fallback to the default + * DOM tree building routines. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlSAXParseMemory(xmlSAXHandlerPtr sax, const char *buffer, + int size, int recovery) { + return xmlSAXParseMemoryWithData(sax, buffer, size, recovery, NULL); +} + +/** + * xmlParseMemory: + * @buffer: an pointer to a char array + * @size: the size of the array + * + * DEPRECATED: Use xmlReadMemory. + * + * parse an XML in-memory block and build a tree. + * + * Returns the resulting document tree + */ + +xmlDocPtr xmlParseMemory(const char *buffer, int size) { + return(xmlSAXParseMemory(NULL, buffer, size, 0)); +} + +/** + * xmlRecoverMemory: + * @buffer: an pointer to a char array + * @size: the size of the array + * + * DEPRECATED: Use xmlReadMemory with XML_PARSE_RECOVER. + * + * parse an XML in-memory block and build a tree. + * In the case the document is not Well Formed, an attempt to + * build a tree is tried anyway + * + * Returns the resulting document tree or NULL in case of error + */ + +xmlDocPtr xmlRecoverMemory(const char *buffer, int size) { + return(xmlSAXParseMemory(NULL, buffer, size, 1)); +} + +/** + * xmlSAXUserParseMemory: + * @sax: a SAX handler + * @user_data: The user data returned on SAX callbacks + * @buffer: an in-memory XML document input + * @size: the length of the XML document in bytes + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadMemory. + * + * parse an XML in-memory buffer and call the given SAX handler routines. + * + * Returns 0 in case of success or a error number otherwise + */ +int xmlSAXUserParseMemory(xmlSAXHandlerPtr sax, void *user_data, + const char *buffer, int size) { + int ret = 0; + xmlParserCtxtPtr ctxt; + + ctxt = xmlCreateMemoryParserCtxt(buffer, size); + if (ctxt == NULL) return -1; + if (sax != NULL) { + if (sax->initialized == XML_SAX2_MAGIC) { + *ctxt->sax = *sax; + } else { + memset(ctxt->sax, 0, sizeof(*ctxt->sax)); + memcpy(ctxt->sax, sax, sizeof(xmlSAXHandlerV1)); + } + ctxt->userData = user_data; + } + + xmlParseDocument(ctxt); + + if (ctxt->wellFormed) + ret = 0; + else { + if (ctxt->errNo != 0) + ret = ctxt->errNo; + else + ret = -1; + } + if (ctxt->myDoc != NULL) { + xmlFreeDoc(ctxt->myDoc); + ctxt->myDoc = NULL; + } + xmlFreeParserCtxt(ctxt); + + return ret; +} +#endif /* LIBXML_SAX1_ENABLED */ + +/** + * xmlCreateDocParserCtxt: + * @str: a pointer to an array of xmlChar + * + * Creates a parser context for an XML in-memory document. + * + * Returns the new parser context or NULL + */ +xmlParserCtxtPtr +xmlCreateDocParserCtxt(const xmlChar *str) { + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + input = xmlCtxtNewInputFromString(ctxt, NULL, (const char *) str, NULL, 0); + if (input == NULL) { + xmlFreeParserCtxt(ctxt); + return(NULL); + } + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + xmlFreeParserCtxt(ctxt); + return(NULL); + } + + return(ctxt); +} + +#ifdef LIBXML_SAX1_ENABLED +/** + * xmlSAXParseDoc: + * @sax: the SAX handler block + * @cur: a pointer to an array of xmlChar + * @recovery: work in recovery mode, i.e. tries to read no Well Formed + * documents + * + * DEPRECATED: Use xmlNewSAXParserCtxt and xmlCtxtReadDoc. + * + * parse an XML in-memory document and build a tree. + * It use the given SAX function block to handle the parsing callback. + * If sax is NULL, fallback to the default DOM tree building routines. + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlSAXParseDoc(xmlSAXHandlerPtr sax, const xmlChar *cur, int recovery) { + xmlDocPtr ret; + xmlParserCtxtPtr ctxt; + xmlSAXHandlerPtr oldsax = NULL; + + if (cur == NULL) return(NULL); + + + ctxt = xmlCreateDocParserCtxt(cur); + if (ctxt == NULL) return(NULL); + if (sax != NULL) { + oldsax = ctxt->sax; + ctxt->sax = sax; + ctxt->userData = NULL; + } + + xmlParseDocument(ctxt); + if ((ctxt->wellFormed) || recovery) ret = ctxt->myDoc; + else { + ret = NULL; + xmlFreeDoc(ctxt->myDoc); + ctxt->myDoc = NULL; + } + if (sax != NULL) + ctxt->sax = oldsax; + xmlFreeParserCtxt(ctxt); + + return(ret); +} + +/** + * xmlParseDoc: + * @cur: a pointer to an array of xmlChar + * + * DEPRECATED: Use xmlReadDoc. + * + * parse an XML in-memory document and build a tree. + * + * Returns the resulting document tree + */ + +xmlDocPtr +xmlParseDoc(const xmlChar *cur) { + return(xmlSAXParseDoc(NULL, cur, 0)); +} +#endif /* LIBXML_SAX1_ENABLED */ + +/************************************************************************ + * * + * New set (2.6.0) of simpler and more flexible APIs * + * * + ************************************************************************/ + +/** + * DICT_FREE: + * @str: a string + * + * Free a string if it is not owned by the "dict" dictionary in the + * current scope + */ +#define DICT_FREE(str) \ + if ((str) && ((!dict) || \ + (xmlDictOwns(dict, (const xmlChar *)(str)) == 0))) \ + xmlFree((char *)(str)); + +/** + * xmlCtxtReset: + * @ctxt: an XML parser context + * + * Reset a parser context + */ +void +xmlCtxtReset(xmlParserCtxtPtr ctxt) +{ + xmlParserInputPtr input; + xmlDictPtr dict; + + if (ctxt == NULL) + return; + + dict = ctxt->dict; + + while ((input = xmlCtxtPopInput(ctxt)) != NULL) { /* Non consuming */ + xmlFreeInputStream(input); + } + ctxt->inputNr = 0; + ctxt->input = NULL; + + ctxt->spaceNr = 0; + if (ctxt->spaceTab != NULL) { + ctxt->spaceTab[0] = -1; + ctxt->space = &ctxt->spaceTab[0]; + } else { + ctxt->space = NULL; + } + + + ctxt->nodeNr = 0; + ctxt->node = NULL; + + ctxt->nameNr = 0; + ctxt->name = NULL; + + ctxt->nsNr = 0; + xmlParserNsReset(ctxt->nsdb); + + DICT_FREE(ctxt->version); + ctxt->version = NULL; + DICT_FREE(ctxt->encoding); + ctxt->encoding = NULL; + DICT_FREE(ctxt->extSubURI); + ctxt->extSubURI = NULL; + DICT_FREE(ctxt->extSubSystem); + ctxt->extSubSystem = NULL; + + if (ctxt->directory != NULL) { + xmlFree(ctxt->directory); + ctxt->directory = NULL; + } + + if (ctxt->myDoc != NULL) + xmlFreeDoc(ctxt->myDoc); + ctxt->myDoc = NULL; + + ctxt->standalone = -1; + ctxt->hasExternalSubset = 0; + ctxt->hasPErefs = 0; + ctxt->html = 0; + ctxt->instate = XML_PARSER_START; + + ctxt->wellFormed = 1; + ctxt->nsWellFormed = 1; + ctxt->disableSAX = 0; + ctxt->valid = 1; + ctxt->record_info = 0; + ctxt->checkIndex = 0; + ctxt->endCheckState = 0; + ctxt->inSubset = 0; + ctxt->errNo = XML_ERR_OK; + ctxt->depth = 0; + ctxt->catalogs = NULL; + ctxt->sizeentities = 0; + ctxt->sizeentcopy = 0; + xmlInitNodeInfoSeq(&ctxt->node_seq); + + if (ctxt->attsDefault != NULL) { + xmlHashFree(ctxt->attsDefault, xmlHashDefaultDeallocator); + ctxt->attsDefault = NULL; + } + if (ctxt->attsSpecial != NULL) { + xmlHashFree(ctxt->attsSpecial, NULL); + ctxt->attsSpecial = NULL; + } + +#ifdef LIBXML_CATALOG_ENABLED + if (ctxt->catalogs != NULL) + xmlCatalogFreeLocal(ctxt->catalogs); +#endif + ctxt->nbErrors = 0; + ctxt->nbWarnings = 0; + if (ctxt->lastError.code != XML_ERR_OK) + xmlResetError(&ctxt->lastError); +} + +/** + * xmlCtxtResetPush: + * @ctxt: an XML parser context + * @chunk: a pointer to an array of chars + * @size: number of chars in the array + * @filename: an optional file name or URI + * @encoding: the document encoding, or NULL + * + * Reset a push parser context + * + * Returns 0 in case of success and 1 in case of error + */ +int +xmlCtxtResetPush(xmlParserCtxtPtr ctxt, const char *chunk, + int size, const char *filename, const char *encoding) +{ + xmlParserInputPtr input; + + if (ctxt == NULL) + return(1); + + xmlCtxtReset(ctxt); + + input = xmlNewPushInput(filename, chunk, size); + if (input == NULL) + return(1); + + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + return(1); + } + + if (encoding != NULL) + xmlSwitchEncodingName(ctxt, encoding); + + return(0); +} + +static int +xmlCtxtSetOptionsInternal(xmlParserCtxtPtr ctxt, int options, int keepMask) +{ + int allMask; + + if (ctxt == NULL) + return(-1); + + /* + * XInclude options aren't handled by the parser. + * + * XML_PARSE_XINCLUDE + * XML_PARSE_NOXINCNODE + * XML_PARSE_NOBASEFIX + */ + allMask = XML_PARSE_RECOVER | + XML_PARSE_NOENT | + XML_PARSE_DTDLOAD | + XML_PARSE_DTDATTR | + XML_PARSE_DTDVALID | + XML_PARSE_NOERROR | + XML_PARSE_NOWARNING | + XML_PARSE_PEDANTIC | + XML_PARSE_NOBLANKS | +#ifdef LIBXML_SAX1_ENABLED + XML_PARSE_SAX1 | +#endif + XML_PARSE_NONET | + XML_PARSE_NODICT | + XML_PARSE_NSCLEAN | + XML_PARSE_NOCDATA | + XML_PARSE_COMPACT | + XML_PARSE_OLD10 | + XML_PARSE_HUGE | + XML_PARSE_OLDSAX | + XML_PARSE_IGNORE_ENC | + XML_PARSE_BIG_LINES | + XML_PARSE_NO_XXE | + XML_PARSE_NO_UNZIP | + XML_PARSE_NO_SYS_CATALOG | + XML_PARSE_NO_CATALOG_PI; + + ctxt->options = (ctxt->options & keepMask) | (options & allMask); + + /* + * For some options, struct members are historically the source + * of truth. The values are initalized from global variables and + * old code could also modify them directly. Several older API + * functions that don't take an options argument rely on these + * deprecated mechanisms. + * + * Once public access to struct members and the globals are + * disabled, we can use the options bitmask as source of + * truth, making all these struct members obsolete. + * + * The XML_DETECT_IDS flags is misnamed. It simply enables + * loading of the external subset. + */ + ctxt->recovery = (options & XML_PARSE_RECOVER) ? 1 : 0; + ctxt->replaceEntities = (options & XML_PARSE_NOENT) ? 1 : 0; + ctxt->loadsubset = (options & XML_PARSE_DTDLOAD) ? XML_DETECT_IDS : 0; + ctxt->loadsubset |= (options & XML_PARSE_DTDATTR) ? XML_COMPLETE_ATTRS : 0; + ctxt->validate = (options & XML_PARSE_DTDVALID) ? 1 : 0; + ctxt->pedantic = (options & XML_PARSE_PEDANTIC) ? 1 : 0; + ctxt->keepBlanks = (options & XML_PARSE_NOBLANKS) ? 0 : 1; + ctxt->dictNames = (options & XML_PARSE_NODICT) ? 0 : 1; + + /* + * Changing SAX callbacks is a bad idea. This should be fixed. + */ + if (options & XML_PARSE_NOBLANKS) { + ctxt->sax->ignorableWhitespace = xmlSAX2IgnorableWhitespace; + } + if (options & XML_PARSE_NOCDATA) { + ctxt->sax->cdataBlock = NULL; + } + if (options & XML_PARSE_HUGE) { + if (ctxt->dict != NULL) + xmlDictSetLimit(ctxt->dict, 0); + } + + ctxt->linenumbers = 1; + + return(options & ~allMask); +} + +/** + * xmlCtxtSetOptions: + * @ctxt: an XML parser context + * @options: a bitmask of xmlParserOption values + * + * Applies the options to the parser context. Unset options are + * cleared. + * + * Available since 2.13.0. With older versions, you can use + * xmlCtxtUseOptions. + * + * XML_PARSE_RECOVER + * + * Enable "recovery" mode which allows non-wellformed documents. + * How this mode behaves exactly is unspecified and may change + * without further notice. Use of this feature is DISCOURAGED. + * + * XML_PARSE_NOENT + * + * Despite the confusing name, this option enables substitution + * of entities. The resulting tree won't contain any entity + * reference nodes. + * + * This option also enables loading of external entities (both + * general and parameter entities) which is dangerous. If you + * process untrusted data, it's recommended to set the + * XML_PARSE_NO_XXE option to disable loading of external + * entities. + * + * XML_PARSE_DTDLOAD + * + * Enables loading of an external DTD and the loading and + * substitution of external parameter entities. Has no effect + * if XML_PARSE_NO_XXE is set. + * + * XML_PARSE_DTDATTR + * + * Adds default attributes from the DTD to the result document. + * + * Implies XML_PARSE_DTDLOAD, but loading of external content + * can be disabled with XML_PARSE_NO_XXE. + * + * XML_PARSE_DTDVALID + * + * This option enables DTD validation which requires to load + * external DTDs and external entities (both general and + * parameter entities) unless XML_PARSE_NO_XXE was set. + * + * XML_PARSE_NO_XXE + * + * Disables loading of external DTDs or entities. + * + * Available since 2.13.0. + * + * XML_PARSE_NOERROR + * + * Disable error and warning reports to the error handlers. + * Errors are still accessible with xmlCtxtGetLastError. + * + * XML_PARSE_NOWARNING + * + * Disable warning reports. + * + * XML_PARSE_PEDANTIC + * + * Enable some pedantic warnings. + * + * XML_PARSE_NOBLANKS + * + * Remove some text nodes containing only whitespace from the + * result document. Which nodes are removed depends on DTD + * element declarations or a conservative heuristic. The + * reindenting feature of the serialization code relies on this + * option to be set when parsing. Use of this option is + * DISCOURAGED. + * + * XML_PARSE_SAX1 + * + * Always invoke the deprecated SAX1 startElement and endElement + * handlers. This option is DEPRECATED. + * + * XML_PARSE_NONET + * + * Disable network access with the builtin HTTP client. + * + * XML_PARSE_NODICT + * + * Create a document without interned strings, making all + * strings separate memory allocations. + * + * XML_PARSE_NSCLEAN + * + * Remove redundant namespace declarations from the result + * document. + * + * XML_PARSE_NOCDATA + * + * Output normal text nodes instead of CDATA nodes. + * + * XML_PARSE_COMPACT + * + * Store small strings directly in the node struct to save + * memory. + * + * XML_PARSE_OLD10 + * + * Use old Name productions from before XML 1.0 Fifth Edition. + * This options is DEPRECATED. + * + * XML_PARSE_HUGE + * + * Relax some internal limits. + * + * Maximum size of text nodes, tags, comments, processing instructions, + * CDATA sections, entity values + * + * normal: 10M + * huge: 1B + * + * Maximum size of names, system literals, pubid literals + * + * normal: 50K + * huge: 10M + * + * Maximum nesting depth of elements + * + * normal: 256 + * huge: 2048 + * + * Maximum nesting depth of entities + * + * normal: 20 + * huge: 40 + * + * XML_PARSE_OLDSAX + * + * Enable an unspecified legacy mode for SAX parsers. This + * option is DEPRECATED. + * + * XML_PARSE_IGNORE_ENC + * + * Ignore the encoding in the XML declaration. This option is + * mostly unneeded these days. The only effect is to enforce + * UTF-8 decoding of ASCII-like data. + * + * XML_PARSE_BIG_LINES + * + * Enable reporting of line numbers larger than 65535. + * + * XML_PARSE_NO_UNZIP + * + * Disables input decompression. Setting this option is recommended + * to avoid zip bombs. + * + * Available since 2.14.0. + * + * XML_PARSE_NO_SYS_CATALOG + * + * Disables the global system XML catalog. + * + * Available since 2.14.0. + * + * XML_PARSE_NO_CATALOG_PI + * + * Ignore XML catalog processing instructions. + * + * Available since 2.14.0. + * + * Returns 0 in case of success, the set of unknown or unimplemented options + * in case of error. + */ +int +xmlCtxtSetOptions(xmlParserCtxtPtr ctxt, int options) +{ +#ifdef LIBXML_HTML_ENABLED + if ((ctxt != NULL) && (ctxt->html)) + return(htmlCtxtSetOptions(ctxt, options)); +#endif + + return(xmlCtxtSetOptionsInternal(ctxt, options, 0)); +} + +/** + * xmlCtxtGetOptions: + * @ctxt: an XML parser context + * + * Get the current options of the parser context. + * + * Available since 2.14.0. + * + * Returns the current options set in the parser context, or -1 if ctxt is NULL. + */ +int +xmlCtxtGetOptions(xmlParserCtxtPtr ctxt) +{ + if (ctxt == NULL) + return(-1); + + return(ctxt->options); +} + +/** + * xmlCtxtUseOptions: + * @ctxt: an XML parser context + * @options: a combination of xmlParserOption + * + * DEPRECATED: Use xmlCtxtSetOptions. + * + * Applies the options to the parser context. The following options + * are never cleared and can only be enabled: + * + * XML_PARSE_NOERROR + * XML_PARSE_NOWARNING + * XML_PARSE_NONET + * XML_PARSE_NSCLEAN + * XML_PARSE_NOCDATA + * XML_PARSE_COMPACT + * XML_PARSE_OLD10 + * XML_PARSE_HUGE + * XML_PARSE_OLDSAX + * XML_PARSE_IGNORE_ENC + * XML_PARSE_BIG_LINES + * + * Returns 0 in case of success, the set of unknown or unimplemented options + * in case of error. + */ +int +xmlCtxtUseOptions(xmlParserCtxtPtr ctxt, int options) +{ + int keepMask; + +#ifdef LIBXML_HTML_ENABLED + if ((ctxt != NULL) && (ctxt->html)) + return(htmlCtxtUseOptions(ctxt, options)); +#endif + + /* + * For historic reasons, some options can only be enabled. + */ + keepMask = XML_PARSE_NOERROR | + XML_PARSE_NOWARNING | + XML_PARSE_NONET | + XML_PARSE_NSCLEAN | + XML_PARSE_NOCDATA | + XML_PARSE_COMPACT | + XML_PARSE_OLD10 | + XML_PARSE_HUGE | + XML_PARSE_OLDSAX | + XML_PARSE_IGNORE_ENC | + XML_PARSE_BIG_LINES; + + return(xmlCtxtSetOptionsInternal(ctxt, options, keepMask)); +} + +/** + * xmlCtxtSetMaxAmplification: + * @ctxt: an XML parser context + * @maxAmpl: maximum amplification factor + * + * To protect against exponential entity expansion ("billion laughs"), the + * size of serialized output is (roughly) limited to the input size + * multiplied by this factor. The default value is 5. + * + * When working with documents making heavy use of entity expansion, it can + * be necessary to increase the value. For security reasons, this should only + * be considered when processing trusted input. + */ +void +xmlCtxtSetMaxAmplification(xmlParserCtxtPtr ctxt, unsigned maxAmpl) +{ + ctxt->maxAmpl = maxAmpl; +} + +/** + * xmlCtxtParseDocument: + * @ctxt: an XML parser context + * @input: parser input + * + * Parse an XML document and return the resulting document tree. + * Takes ownership of the input object. + * + * Available since 2.13.0. + * + * Returns the resulting document tree or NULL + */ +xmlDocPtr +xmlCtxtParseDocument(xmlParserCtxtPtr ctxt, xmlParserInputPtr input) +{ + xmlDocPtr ret = NULL; + + if ((ctxt == NULL) || (input == NULL)) + return(NULL); + + /* assert(ctxt->inputNr == 0); */ + while (ctxt->inputNr > 0) + xmlFreeInputStream(xmlCtxtPopInput(ctxt)); + + if (xmlCtxtPushInput(ctxt, input) < 0) { + xmlFreeInputStream(input); + return(NULL); + } + + xmlParseDocument(ctxt); + + if ((ctxt->wellFormed) || + ((ctxt->recovery) && (!xmlCtxtIsCatastrophicError(ctxt)))) { + ret = ctxt->myDoc; + } else { + if (ctxt->errNo == XML_ERR_OK) + xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR, "unknown error\n"); + + ret = NULL; + xmlFreeDoc(ctxt->myDoc); + } + ctxt->myDoc = NULL; + + /* assert(ctxt->inputNr == 1); */ + while (ctxt->inputNr > 0) + xmlFreeInputStream(xmlCtxtPopInput(ctxt)); + + return(ret); +} + +/** + * xmlReadDoc: + * @cur: a pointer to a zero terminated string + * @URL: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Convenience function to parse an XML document from a + * zero-terminated string. + * + * See xmlCtxtReadDoc for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlReadDoc(const xmlChar *cur, const char *URL, const char *encoding, + int options) +{ + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlDocPtr doc; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromString(ctxt, URL, (const char *) cur, encoding, + XML_INPUT_BUF_STATIC); + + doc = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(doc); +} + +/** + * xmlReadFile: + * @filename: a file or URL + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Convenience function to parse an XML file from the filesystem, + * the network or a global user-define resource loader. + * + * See xmlCtxtReadFile for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlReadFile(const char *filename, const char *encoding, int options) +{ + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlDocPtr doc; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + xmlCtxtUseOptions(ctxt, options); + + /* + * Backward compatibility for users of command line utilities like + * xmlstarlet expecting "-" to mean stdin. This is dangerous and + * should be removed at some point. + */ + if ((filename != NULL) && (filename[0] == '-') && (filename[1] == 0)) + input = xmlCtxtNewInputFromFd(ctxt, filename, STDIN_FILENO, + encoding, 0); + else + input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0); + + doc = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(doc); +} + +/** + * xmlReadMemory: + * @buffer: a pointer to a char array + * @size: the size of the array + * @url: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML in-memory document and build a tree. The input buffer must + * not contain a terminating null byte. + * + * See xmlCtxtReadMemory for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlReadMemory(const char *buffer, int size, const char *url, + const char *encoding, int options) +{ + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlDocPtr doc; + + if (size < 0) + return(NULL); + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromMemory(ctxt, url, buffer, size, encoding, + XML_INPUT_BUF_STATIC); + + doc = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(doc); +} + +/** + * xmlReadFd: + * @fd: an open file descriptor + * @URL: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML from a file descriptor and build a tree. + * + * See xmlCtxtReadFd for details. + * + * NOTE that the file descriptor will not be closed when the + * context is freed or reset. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlReadFd(int fd, const char *URL, const char *encoding, int options) +{ + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlDocPtr doc; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromFd(ctxt, URL, fd, encoding, 0); + + doc = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(doc); +} + +/** + * xmlReadIO: + * @ioread: an I/O read function + * @ioclose: an I/O close function (optional) + * @ioctx: an I/O handler + * @URL: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML document from I/O functions and context and build a tree. + * + * See xmlCtxtReadIO for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlReadIO(xmlInputReadCallback ioread, xmlInputCloseCallback ioclose, + void *ioctx, const char *URL, const char *encoding, int options) +{ + xmlParserCtxtPtr ctxt; + xmlParserInputPtr input; + xmlDocPtr doc; + + ctxt = xmlNewParserCtxt(); + if (ctxt == NULL) + return(NULL); + + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromIO(ctxt, URL, ioread, ioclose, ioctx, + encoding, 0); + + doc = xmlCtxtParseDocument(ctxt, input); + + xmlFreeParserCtxt(ctxt); + return(doc); +} + +/** + * xmlCtxtReadDoc: + * @ctxt: an XML parser context + * @str: a pointer to a zero terminated string + * @URL: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML in-memory document and build a tree. + * + * @URL is used as base to resolve external entities and for error + * reporting. + * + * See xmlCtxtUseOptions for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlCtxtReadDoc(xmlParserCtxtPtr ctxt, const xmlChar *str, + const char *URL, const char *encoding, int options) +{ + xmlParserInputPtr input; + + if (ctxt == NULL) + return(NULL); + + xmlCtxtReset(ctxt); + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromString(ctxt, URL, (const char *) str, encoding, + XML_INPUT_BUF_STATIC); + + return(xmlCtxtParseDocument(ctxt, input)); +} + +/** + * xmlCtxtReadFile: + * @ctxt: an XML parser context + * @filename: a file or URL + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML file from the filesystem, the network or a user-defined + * resource loader. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlCtxtReadFile(xmlParserCtxtPtr ctxt, const char *filename, + const char *encoding, int options) +{ + xmlParserInputPtr input; + + if (ctxt == NULL) + return(NULL); + + xmlCtxtReset(ctxt); + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromUrl(ctxt, filename, NULL, encoding, 0); + + return(xmlCtxtParseDocument(ctxt, input)); +} + +/** + * xmlCtxtReadMemory: + * @ctxt: an XML parser context + * @buffer: a pointer to a char array + * @size: the size of the array + * @URL: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML in-memory document and build a tree. The input buffer must + * not contain a terminating null byte. + * + * @URL is used as base to resolve external entities and for error + * reporting. + * + * See xmlCtxtUseOptions for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlCtxtReadMemory(xmlParserCtxtPtr ctxt, const char *buffer, int size, + const char *URL, const char *encoding, int options) +{ + xmlParserInputPtr input; + + if ((ctxt == NULL) || (size < 0)) + return(NULL); + + xmlCtxtReset(ctxt); + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromMemory(ctxt, URL, buffer, size, encoding, + XML_INPUT_BUF_STATIC); + + return(xmlCtxtParseDocument(ctxt, input)); +} + +/** + * xmlCtxtReadFd: + * @ctxt: an XML parser context + * @fd: an open file descriptor + * @URL: base URL (optional) + * @encoding: the document encoding (optional) + * @options: a combination of xmlParserOption + * + * Parse an XML document from a file descriptor and build a tree. + * + * NOTE that the file descriptor will not be closed when the + * context is freed or reset. + * + * @URL is used as base to resolve external entities and for error + * reporting. + * + * See xmlCtxtUseOptions for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlCtxtReadFd(xmlParserCtxtPtr ctxt, int fd, + const char *URL, const char *encoding, int options) +{ + xmlParserInputPtr input; + + if (ctxt == NULL) + return(NULL); + + xmlCtxtReset(ctxt); + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromFd(ctxt, URL, fd, encoding, 0); + + return(xmlCtxtParseDocument(ctxt, input)); +} + +/** + * xmlCtxtReadIO: + * @ctxt: an XML parser context + * @ioread: an I/O read function + * @ioclose: an I/O close function + * @ioctx: an I/O handler + * @URL: the base URL to use for the document + * @encoding: the document encoding, or NULL + * @options: a combination of xmlParserOption + * + * parse an XML document from I/O functions and source and build a tree. + * This reuses the existing @ctxt parser context + * + * @URL is used as base to resolve external entities and for error + * reporting. + * + * See xmlCtxtUseOptions for details. + * + * Returns the resulting document tree + */ +xmlDocPtr +xmlCtxtReadIO(xmlParserCtxtPtr ctxt, xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, void *ioctx, + const char *URL, + const char *encoding, int options) +{ + xmlParserInputPtr input; + + if (ctxt == NULL) + return(NULL); + + xmlCtxtReset(ctxt); + xmlCtxtUseOptions(ctxt, options); + + input = xmlCtxtNewInputFromIO(ctxt, URL, ioread, ioclose, ioctx, + encoding, 0); + + return(xmlCtxtParseDocument(ctxt, input)); +} +