Hugging Face's logo

AryaWu
/
libxml

Model card Files
xet
Community
libxml / encoding.c
AryaWu's picture
AryaWu
Upload folder using huggingface_hub
6baed57 verified
raw
history blame contribute delete
87 kB
 /*
* encoding.c : implements the encoding conversion functions needed for XML
*
* Related specs:
* rfc2044 (UTF-8 and UTF-16) F. Yergeau Alis Technologies
* rfc2781 UTF-16, an encoding of ISO 10646, P. Hoffman, F. Yergeau
* [ISO-10646] UTF-8 and UTF-16 in Annexes
* [ISO-8859-1] ISO Latin-1 characters codes.
* [UNICODE] The Unicode Consortium, "The Unicode Standard --
* Worldwide Character Encoding -- Version 1.0", Addison-
* Wesley, Volume 1, 1991, Volume 2, 1992. UTF-8 is
* described in Unicode Technical Report \#4.
* [US-ASCII] Coded Character Set--7-bit American Standard Code for
* Information Interchange, ANSI X3.4-1986.
*
* See Copyright for the status of this software.
*
* Author: Daniel Veillard
*
* Original code for IsoLatin1 and UTF-16 by Martin J. Duerst
*/
#define IN_LIBXML
#include "libxml.h"
#include <string.h>
#include <limits.h>
#include <ctype.h>
#include <stdlib.h>
#ifdef LIBXML_ICONV_ENABLED
#include <iconv.h>
#include <errno.h>
#endif
#include <libxml/encoding.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#ifdef LIBXML_HTML_ENABLED
#include <libxml/HTMLparser.h>
#endif
#include <libxml/xmlerror.h>
#include "private/buf.h"
#include "private/enc.h"
#include "private/error.h"
#include "private/memory.h"
#ifdef LIBXML_ICU_ENABLED
#include <unicode/ucnv.h>
#endif
#define XML_HANDLER_STATIC (1 << 0)
#define XML_HANDLER_LEGACY (1 << 1)
typedef struct _xmlCharEncodingAlias xmlCharEncodingAlias;
typedef xmlCharEncodingAlias *xmlCharEncodingAliasPtr;
struct _xmlCharEncodingAlias {
const char *name;
const char *alias;
};
static xmlCharEncodingAliasPtr xmlCharEncodingAliases = NULL;
static int xmlCharEncodingAliasesNb = 0;
static int xmlCharEncodingAliasesMax = 0;
static int xmlLittleEndian = 1;
typedef struct {
const char *name;
xmlCharEncoding enc;
} xmlEncTableEntry;
static const xmlEncTableEntry xmlEncTable[] = {
{ "ansi_x3.4-1968", XML_CHAR_ENCODING_ASCII },
{ "arabic", XML_CHAR_ENCODING_8859_6 },
{ "ascii", XML_CHAR_ENCODING_ASCII },
{ "asmo-708", XML_CHAR_ENCODING_8859_6 },
{ "cp1252", XML_CHAR_ENCODING_WINDOWS_1252 },
{ "cp819", XML_CHAR_ENCODING_8859_1 },
{ "cseucpkdfmtjapanese", XML_CHAR_ENCODING_EUC_JP },
{ "csiso2022jp", XML_CHAR_ENCODING_2022_JP },
{ "csiso88596e", XML_CHAR_ENCODING_8859_6 },
{ "csiso88596i", XML_CHAR_ENCODING_8859_6 },
{ "csiso88598e", XML_CHAR_ENCODING_8859_8 },
{ "csiso88598i", XML_CHAR_ENCODING_8859_8 },
{ "csisolatin1", XML_CHAR_ENCODING_8859_1 },
{ "csisolatin2", XML_CHAR_ENCODING_8859_2 },
{ "csisolatin3", XML_CHAR_ENCODING_8859_3 },
{ "csisolatin4", XML_CHAR_ENCODING_8859_4 },
{ "csisolatin5", XML_CHAR_ENCODING_8859_9 },
{ "csisolatin6", XML_CHAR_ENCODING_8859_10 },
{ "csisolatin9", XML_CHAR_ENCODING_8859_15 },
{ "csisolatinarabic", XML_CHAR_ENCODING_8859_6 },
{ "csisolatincyrillic", XML_CHAR_ENCODING_8859_5 },
{ "csisolatingreek", XML_CHAR_ENCODING_8859_7 },
{ "csisolatinhebrew", XML_CHAR_ENCODING_8859_8 },
{ "csshiftjis", XML_CHAR_ENCODING_SHIFT_JIS },
{ "csunicode", XML_CHAR_ENCODING_UTF16 },
{ "cyrillic", XML_CHAR_ENCODING_8859_5 },
{ "ecma-114", XML_CHAR_ENCODING_8859_6 },
{ "ecma-118", XML_CHAR_ENCODING_8859_7 },
{ "elot_928", XML_CHAR_ENCODING_8859_7 },
{ "euc-jp", XML_CHAR_ENCODING_EUC_JP },
{ "greek", XML_CHAR_ENCODING_8859_7 },
{ "greek8", XML_CHAR_ENCODING_8859_7 },
{ "html", XML_CHAR_ENCODING_HTML },
{ "ibm819", XML_CHAR_ENCODING_8859_1 },
{ "iso latin 1", XML_CHAR_ENCODING_8859_1 },
{ "iso latin 2", XML_CHAR_ENCODING_8859_2 },
{ "iso-10646-ucs-2", XML_CHAR_ENCODING_UCS2 },
{ "iso-10646-ucs-4", XML_CHAR_ENCODING_UCS4LE },
{ "iso-2022-jp", XML_CHAR_ENCODING_2022_JP },
{ "iso-8859-1", XML_CHAR_ENCODING_8859_1 },
{ "iso-8859-10", XML_CHAR_ENCODING_8859_10 },
{ "iso-8859-11", XML_CHAR_ENCODING_8859_11 },
{ "iso-8859-13", XML_CHAR_ENCODING_8859_13 },
{ "iso-8859-14", XML_CHAR_ENCODING_8859_14 },
{ "iso-8859-15", XML_CHAR_ENCODING_8859_15 },
{ "iso-8859-16", XML_CHAR_ENCODING_8859_16 },
{ "iso-8859-2", XML_CHAR_ENCODING_8859_2 },
{ "iso-8859-3", XML_CHAR_ENCODING_8859_3 },
{ "iso-8859-4", XML_CHAR_ENCODING_8859_4 },
{ "iso-8859-5", XML_CHAR_ENCODING_8859_5 },
{ "iso-8859-6", XML_CHAR_ENCODING_8859_6 },
{ "iso-8859-6-e", XML_CHAR_ENCODING_8859_6 },
{ "iso-8859-6-i", XML_CHAR_ENCODING_8859_6 },
{ "iso-8859-7", XML_CHAR_ENCODING_8859_7 },
{ "iso-8859-8", XML_CHAR_ENCODING_8859_8 },
{ "iso-8859-8-i", XML_CHAR_ENCODING_8859_8 },
{ "iso-8859-9", XML_CHAR_ENCODING_8859_9 },
{ "iso-ir-100", XML_CHAR_ENCODING_8859_1 },
{ "iso-ir-101", XML_CHAR_ENCODING_8859_2 },
{ "iso-ir-109", XML_CHAR_ENCODING_8859_3 },
{ "iso-ir-110", XML_CHAR_ENCODING_8859_4 },
{ "iso-ir-126", XML_CHAR_ENCODING_8859_7 },
{ "iso-ir-127", XML_CHAR_ENCODING_8859_6 },
{ "iso-ir-138", XML_CHAR_ENCODING_8859_8 },
{ "iso-ir-144", XML_CHAR_ENCODING_8859_5 },
{ "iso-ir-148", XML_CHAR_ENCODING_8859_9 },
{ "iso-ir-157", XML_CHAR_ENCODING_8859_10 },
{ "iso-latin-1", XML_CHAR_ENCODING_8859_1 },
{ "iso-latin-2", XML_CHAR_ENCODING_8859_2 },
{ "iso8859-1", XML_CHAR_ENCODING_8859_1 },
{ "iso8859-10", XML_CHAR_ENCODING_8859_1 },
{ "iso8859-13", XML_CHAR_ENCODING_8859_1 },
{ "iso8859-14", XML_CHAR_ENCODING_8859_1 },
{ "iso8859-15", XML_CHAR_ENCODING_8859_1 },
{ "iso8859-2", XML_CHAR_ENCODING_8859_2 },
{ "iso8859-3", XML_CHAR_ENCODING_8859_3 },
{ "iso8859-4", XML_CHAR_ENCODING_8859_4 },
{ "iso8859-5", XML_CHAR_ENCODING_8859_5 },
{ "iso8859-6", XML_CHAR_ENCODING_8859_6 },
{ "iso8859-7", XML_CHAR_ENCODING_8859_7 },
{ "iso8859-8", XML_CHAR_ENCODING_8859_8 },
{ "iso8859-9", XML_CHAR_ENCODING_8859_9 },
{ "iso88591", XML_CHAR_ENCODING_8859_1 },
{ "iso885910", XML_CHAR_ENCODING_8859_10 },
{ "iso885913", XML_CHAR_ENCODING_8859_13 },
{ "iso885914", XML_CHAR_ENCODING_8859_14 },
{ "iso885915", XML_CHAR_ENCODING_8859_15 },
{ "iso88592", XML_CHAR_ENCODING_8859_2 },
{ "iso88593", XML_CHAR_ENCODING_8859_3 },
{ "iso88594", XML_CHAR_ENCODING_8859_4 },
{ "iso88595", XML_CHAR_ENCODING_8859_5 },
{ "iso88596", XML_CHAR_ENCODING_8859_6 },
{ "iso88597", XML_CHAR_ENCODING_8859_7 },
{ "iso88598", XML_CHAR_ENCODING_8859_8 },
{ "iso88599", XML_CHAR_ENCODING_8859_9 },
{ "iso_8859-1", XML_CHAR_ENCODING_8859_1 },
{ "iso_8859-1:1987", XML_CHAR_ENCODING_8859_1 },
{ "iso_8859-2", XML_CHAR_ENCODING_8859_2 },
{ "iso_8859-2:1987", XML_CHAR_ENCODING_8859_2 },
{ "iso_8859-3", XML_CHAR_ENCODING_8859_3 },
{ "iso_8859-3:1988", XML_CHAR_ENCODING_8859_3 },
{ "iso_8859-4", XML_CHAR_ENCODING_8859_4 },
{ "iso_8859-4:1988", XML_CHAR_ENCODING_8859_4 },
{ "iso_8859-5", XML_CHAR_ENCODING_8859_5 },
{ "iso_8859-5:1988", XML_CHAR_ENCODING_8859_5 },
{ "iso_8859-6", XML_CHAR_ENCODING_8859_6 },
{ "iso_8859-6:1987", XML_CHAR_ENCODING_8859_6 },
{ "iso_8859-7", XML_CHAR_ENCODING_8859_7 },
{ "iso_8859-7:1987", XML_CHAR_ENCODING_8859_7 },
{ "iso_8859-8", XML_CHAR_ENCODING_8859_8 },
{ "iso_8859-8:1988", XML_CHAR_ENCODING_8859_8 },
{ "iso_8859-9", XML_CHAR_ENCODING_8859_9 },
{ "iso_8859-9:1989", XML_CHAR_ENCODING_8859_9 },
{ "l1", XML_CHAR_ENCODING_8859_1 },
{ "l2", XML_CHAR_ENCODING_8859_2 },
{ "l3", XML_CHAR_ENCODING_8859_3 },
{ "l4", XML_CHAR_ENCODING_8859_4 },
{ "l5", XML_CHAR_ENCODING_8859_9 },
{ "l6", XML_CHAR_ENCODING_8859_10 },
{ "l9", XML_CHAR_ENCODING_8859_15 },
{ "latin1", XML_CHAR_ENCODING_8859_1 },
{ "latin2", XML_CHAR_ENCODING_8859_2 },
{ "latin3", XML_CHAR_ENCODING_8859_3 },
{ "latin4", XML_CHAR_ENCODING_8859_4 },
{ "latin5", XML_CHAR_ENCODING_8859_9 },
{ "latin6", XML_CHAR_ENCODING_8859_10 },
{ "logical", XML_CHAR_ENCODING_8859_8 },
{ "ms932", XML_CHAR_ENCODING_SHIFT_JIS },
{ "ms_kanji", XML_CHAR_ENCODING_SHIFT_JIS },
{ "shift-jis", XML_CHAR_ENCODING_SHIFT_JIS },
{ "shift_jis", XML_CHAR_ENCODING_SHIFT_JIS },
{ "sjis", XML_CHAR_ENCODING_SHIFT_JIS },
{ "sun_eu_greek", XML_CHAR_ENCODING_8859_7 },
{ "ucs-2", XML_CHAR_ENCODING_UCS2 },
{ "ucs-4", XML_CHAR_ENCODING_UCS4LE },
{ "ucs2", XML_CHAR_ENCODING_UCS2 },
{ "ucs4", XML_CHAR_ENCODING_UCS4LE },
{ "unicode", XML_CHAR_ENCODING_UTF16 },
{ "unicode-1-1-utf-8", XML_CHAR_ENCODING_UTF8 },
{ "unicode11utf8", XML_CHAR_ENCODING_UTF8 },
{ "unicode20utf8", XML_CHAR_ENCODING_UTF8 },
{ "unicodefffe", XML_CHAR_ENCODING_UTF16BE },
{ "unicodefeff", XML_CHAR_ENCODING_UTF16LE },
{ "us-ascii", XML_CHAR_ENCODING_ASCII },
{ "utf-16", XML_CHAR_ENCODING_UTF16 },
{ "utf-16be", XML_CHAR_ENCODING_UTF16BE },
{ "utf-16le", XML_CHAR_ENCODING_UTF16LE },
{ "utf-8", XML_CHAR_ENCODING_UTF8 },
{ "utf16", XML_CHAR_ENCODING_UTF16 },
{ "utf8", XML_CHAR_ENCODING_UTF8 },
{ "visual", XML_CHAR_ENCODING_8859_8 },
{ "windows-1252", XML_CHAR_ENCODING_WINDOWS_1252 },
{ "windows-31j", XML_CHAR_ENCODING_SHIFT_JIS },
{ "x-cp1252", XML_CHAR_ENCODING_WINDOWS_1252 },
{ "x-euc-jp", XML_CHAR_ENCODING_EUC_JP },
{ "x-sjis", XML_CHAR_ENCODING_SHIFT_JIS },
{ "x-unicode20utf8", XML_CHAR_ENCODING_UTF8 }
};
static xmlCharEncError
asciiToAscii(void *vctxt, unsigned char* out, int *outlen,
const unsigned char* in, int *inlen, int flush);
static xmlCharEncError
UTF8ToUTF8(void *vctxt, unsigned char* out, int *outlen,
const unsigned char* inb, int *inlenb, int flush);
static xmlCharEncError
latin1ToUTF8(void *vctxt, unsigned char* out, int *outlen,
const unsigned char* in, int *inlen, int flush);
static xmlCharEncError
UTF16LEToUTF8(void *vctxt, unsigned char* out, int *outlen,
const unsigned char* inb, int *inlenb, int flush);
static xmlCharEncError
UTF16BEToUTF8(void *vctxt, unsigned char* out, int *outlen,
const unsigned char* inb, int *inlenb, int flush);
#ifdef LIBXML_OUTPUT_ENABLED
static xmlCharEncError
UTF8ToLatin1(void *vctxt, unsigned char* outb, int *outlen,
const unsigned char* in, int *inlen, int flush);
static xmlCharEncError
UTF8ToUTF16(void *vctxt, unsigned char* outb, int *outlen,
const unsigned char* in, int *inlen, int flush);
static xmlCharEncError
UTF8ToUTF16LE(void *vctxt, unsigned char* outb, int *outlen,
const unsigned char* in, int *inlen, int flush);
static xmlCharEncError
UTF8ToUTF16BE(void *vctxt, unsigned char* outb, int *outlen,
const unsigned char* in, int *inlen, int flush);
#else /* LIBXML_OUTPUT_ENABLED */
#define UTF8ToLatin1 NULL
#define UTF8ToUTF16 NULL
#define UTF8ToUTF16LE NULL
#define UTF8ToUTF16BE NULL
#endif /* LIBXML_OUTPUT_ENABLED */
#if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTML_ENABLED)
static xmlCharEncError
UTF8ToHtmlWrapper(void *vctxt, unsigned char *out, int *outlen,
const unsigned char *in, int *inlen, int flush);
#else
#define UTF8ToHtmlWrapper NULL
#endif
#include "codegen/charset.inc"
static xmlCharEncError
EightBitToUtf8(void *vctxt, unsigned char* out, int *outlen,
const unsigned char* in, int *inlen, int flush);
static xmlCharEncError
Utf8ToEightBit(void *vctxt, unsigned char *out, int *outlen,
const unsigned char *in, int *inlen, int flush);
#define MAKE_8BIT_HANDLER(name, table) \
{ (char *) name, { EightBitToUtf8 }, { Utf8ToEightBit }, \
(void *) xmlunicodetable_##table, \
(void *) xmltranscodetable_##table, \
NULL, XML_HANDLER_STATIC }
#if !defined(LIBXML_ICONV_ENABLED) && !defined(LIBXML_ICU_ENABLED) && \
defined(LIBXML_ISO8859X_ENABLED)
#define MAKE_ISO_HANDLER(name, n) MAKE_8BIT_HANDLER(name, ISO8859_##n)
#else /* LIBXML_ISO8859X_ENABLED */
#define MAKE_ISO_HANDLER(name, n) \
{ (char *) name, { NULL }, { NULL }, NULL, NULL, NULL, \
XML_HANDLER_STATIC }
#endif /* LIBXML_ISO8859X_ENABLED */
#define MAKE_HANDLER(name, in, out) \
{ (char *) name, { in }, { out }, NULL, NULL, NULL, XML_HANDLER_STATIC }
/*
* The layout must match enum xmlCharEncoding.
*
* Names should match the IANA registry if possible:
* https://www.iana.org/assignments/character-sets/character-sets.xhtml
*/
static const xmlCharEncodingHandler defaultHandlers[32] = {
MAKE_HANDLER(NULL, NULL, NULL), /* NONE */
MAKE_HANDLER("UTF-8", UTF8ToUTF8, UTF8ToUTF8),
MAKE_HANDLER("UTF-16LE", UTF16LEToUTF8, UTF8ToUTF16LE),
MAKE_HANDLER("UTF-16BE", UTF16BEToUTF8, UTF8ToUTF16BE),
MAKE_HANDLER("UCS-4LE", NULL, NULL),
MAKE_HANDLER("UCS-4BE", NULL, NULL),
MAKE_HANDLER("IBM037", NULL, NULL),
MAKE_HANDLER(NULL, NULL, NULL), /* UCS4_2143 */
MAKE_HANDLER(NULL, NULL, NULL), /* UCS4_3412 */
MAKE_HANDLER("UCS-2", NULL, NULL),
MAKE_HANDLER("ISO-8859-1", latin1ToUTF8, UTF8ToLatin1),
MAKE_ISO_HANDLER("ISO-8859-2", 2),
MAKE_ISO_HANDLER("ISO-8859-3", 3),
MAKE_ISO_HANDLER("ISO-8859-4", 4),
MAKE_ISO_HANDLER("ISO-8859-5", 5),
MAKE_ISO_HANDLER("ISO-8859-6", 6),
MAKE_ISO_HANDLER("ISO-8859-7", 7),
MAKE_ISO_HANDLER("ISO-8859-8", 8),
MAKE_ISO_HANDLER("ISO-8859-9", 9),
MAKE_HANDLER("ISO-2022-JP", NULL, NULL),
MAKE_HANDLER("Shift_JIS", NULL, NULL),
MAKE_HANDLER("EUC-JP", NULL, NULL),
MAKE_HANDLER("US-ASCII", asciiToAscii, asciiToAscii),
MAKE_HANDLER("UTF-16", UTF16LEToUTF8, UTF8ToUTF16),
MAKE_HANDLER("HTML", NULL, UTF8ToHtmlWrapper),
MAKE_ISO_HANDLER("ISO-8859-10", 10),
MAKE_ISO_HANDLER("ISO-8859-11", 11),
MAKE_ISO_HANDLER("ISO-8859-13", 13),
MAKE_ISO_HANDLER("ISO-8859-14", 14),
MAKE_ISO_HANDLER("ISO-8859-15", 15),
MAKE_ISO_HANDLER("ISO-8859-16", 16),
MAKE_8BIT_HANDLER("windows-1252", windows_1252)
};
#define NUM_DEFAULT_HANDLERS \
(sizeof(defaultHandlers) / sizeof(defaultHandlers[0]))
/* the size should be growable, but it's not a big deal ... */
#define MAX_ENCODING_HANDLERS 50
static xmlCharEncodingHandlerPtr *globalHandlers = NULL;
static int nbCharEncodingHandler = 0;
#ifdef LIBXML_ICONV_ENABLED
static xmlParserErrors
xmlCharEncIconv(const char *name, xmlCharEncFlags flags,
xmlCharEncodingHandler **out);
#endif
#ifdef LIBXML_ICU_ENABLED
static xmlParserErrors
xmlCharEncUconv(const char *name, xmlCharEncFlags flags,
xmlCharEncodingHandler **out);
#endif
/************************************************************************
* *
* Generic encoding handling routines *
* *
************************************************************************/
/**
* Guess the encoding of the entity using the first bytes of the entity content
* according to the non-normative appendix F of the XML-1.0 recommendation.
*
* @param in a pointer to the first bytes of the XML entity, must be at least
* 2 bytes long (at least 4 if encoding is UTF4 variant).
* @param len pointer to the length of the buffer
* @returns a xmlCharEncoding value.
*/
xmlCharEncoding
xmlDetectCharEncoding(const unsigned char* in, int len)
{
if (in == NULL)
return(XML_CHAR_ENCODING_NONE);
if (len >= 4) {
if ((in[0] == 0x00) && (in[1] == 0x00) &&
(in[2] == 0x00) && (in[3] == 0x3C))
return(XML_CHAR_ENCODING_UCS4BE);
if ((in[0] == 0x3C) && (in[1] == 0x00) &&
(in[2] == 0x00) && (in[3] == 0x00))
return(XML_CHAR_ENCODING_UCS4LE);
if ((in[0] == 0x4C) && (in[1] == 0x6F) &&
(in[2] == 0xA7) && (in[3] == 0x94))
return(XML_CHAR_ENCODING_EBCDIC);
if ((in[0] == 0x3C) && (in[1] == 0x3F) &&
(in[2] == 0x78) && (in[3] == 0x6D))
return(XML_CHAR_ENCODING_UTF8);
/*
* Although not part of the recommendation, we also
* attempt an "auto-recognition" of UTF-16LE and
* UTF-16BE encodings.
*/
if ((in[0] == 0x3C) && (in[1] == 0x00) &&
(in[2] == 0x3F) && (in[3] == 0x00))
return(XML_CHAR_ENCODING_UTF16LE);
if ((in[0] == 0x00) && (in[1] == 0x3C) &&
(in[2] == 0x00) && (in[3] == 0x3F))
return(XML_CHAR_ENCODING_UTF16BE);
}
if (len >= 3) {
/*
* Errata on XML-1.0 June 20 2001
* We now allow an UTF8 encoded BOM
*/
if ((in[0] == 0xEF) && (in[1] == 0xBB) &&
(in[2] == 0xBF))
return(XML_CHAR_ENCODING_UTF8);
}
/* For UTF-16 we can recognize by the BOM */
if (len >= 2) {
if ((in[0] == 0xFE) && (in[1] == 0xFF))
return(XML_CHAR_ENCODING_UTF16BE);
if ((in[0] == 0xFF) && (in[1] == 0xFE))
return(XML_CHAR_ENCODING_UTF16LE);
}
return(XML_CHAR_ENCODING_NONE);
}
/**
* Unregisters all aliases.
*
* @deprecated This function modifies global state and is not
* thread-safe. See #xmlCtxtSetCharEncConvImpl for an alternative.
*
*/
void
xmlCleanupEncodingAliases(void) {
int i;
if (xmlCharEncodingAliases == NULL)
return;
for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
if (xmlCharEncodingAliases[i].name != NULL)
xmlFree((char *) xmlCharEncodingAliases[i].name);
if (xmlCharEncodingAliases[i].alias != NULL)
xmlFree((char *) xmlCharEncodingAliases[i].alias);
}
xmlCharEncodingAliasesNb = 0;
xmlCharEncodingAliasesMax = 0;
xmlFree(xmlCharEncodingAliases);
xmlCharEncodingAliases = NULL;
}
/**
* Lookup an encoding name for the given alias.
*
* @deprecated This function is not thread-safe.
*
* @param alias the alias name as parsed, in UTF-8 format (ASCII actually)
* @returns NULL if not found, otherwise the original name.
*/
const char *
xmlGetEncodingAlias(const char *alias) {
int i;
char upper[100];
if (alias == NULL)
return(NULL);
if (xmlCharEncodingAliases == NULL)
return(NULL);
for (i = 0;i < 99;i++) {
upper[i] = (char) toupper((unsigned char) alias[i]);
if (upper[i] == 0) break;
}
upper[i] = 0;
/*
* Walk down the list looking for a definition of the alias
*/
for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
return(xmlCharEncodingAliases[i].name);
}
}
return(NULL);
}
/**
* Registers an alias `alias` for an encoding named `name`. Existing
* aliases will be overwritten.
*
* @deprecated This function modifies global state and is not
* thread-safe. See #xmlCtxtSetCharEncConvImpl for an alternative.
*
* @param name the encoding name as parsed, in UTF-8 format (ASCII actually)
* @param alias the alias name as parsed, in UTF-8 format (ASCII actually)
* @returns 0 in case of success, -1 in case of error.
*/
int
xmlAddEncodingAlias(const char *name, const char *alias) {
int i;
char upper[100];
char *nameCopy, *aliasCopy;
if ((name == NULL) || (alias == NULL))
return(-1);
for (i = 0;i < 99;i++) {
upper[i] = (char) toupper((unsigned char) alias[i]);
if (upper[i] == 0) break;
}
upper[i] = 0;
if (xmlCharEncodingAliasesNb >= xmlCharEncodingAliasesMax) {
xmlCharEncodingAliasPtr tmp;
int newSize;
newSize = xmlGrowCapacity(xmlCharEncodingAliasesMax, sizeof(tmp[0]),
20, XML_MAX_ITEMS);
if (newSize < 0)
return(-1);
tmp = xmlRealloc(xmlCharEncodingAliases, newSize * sizeof(tmp[0]));
if (tmp == NULL)
return(-1);
xmlCharEncodingAliases = tmp;
xmlCharEncodingAliasesMax = newSize;
}
/*
* Walk down the list looking for a definition of the alias
*/
for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
if (!strcmp(xmlCharEncodingAliases[i].alias, upper)) {
/*
* Replace the definition.
*/
nameCopy = xmlMemStrdup(name);
if (nameCopy == NULL)
return(-1);
xmlFree((char *) xmlCharEncodingAliases[i].name);
xmlCharEncodingAliases[i].name = nameCopy;
return(0);
}
}
/*
* Add the definition
*/
nameCopy = xmlMemStrdup(name);
if (nameCopy == NULL)
return(-1);
aliasCopy = xmlMemStrdup(upper);
if (aliasCopy == NULL) {
xmlFree(nameCopy);
return(-1);
}
xmlCharEncodingAliases[xmlCharEncodingAliasesNb].name = nameCopy;
xmlCharEncodingAliases[xmlCharEncodingAliasesNb].alias = aliasCopy;
xmlCharEncodingAliasesNb++;
return(0);
}
/**
* Unregisters an encoding alias.
*
* @deprecated This function modifies global state and is not
* thread-safe. See #xmlCtxtSetCharEncConvImpl for an alternative.
*
* @param alias the alias name as parsed, in UTF-8 format (ASCII actually)
* @returns 0 in case of success, -1 in case of error.
*/
int
xmlDelEncodingAlias(const char *alias) {
int i;
if (alias == NULL)
return(-1);
if (xmlCharEncodingAliases == NULL)
return(-1);
/*
* Walk down the list looking for a definition of the alias
*/
for (i = 0;i < xmlCharEncodingAliasesNb;i++) {
if (!strcmp(xmlCharEncodingAliases[i].alias, alias)) {
xmlFree((char *) xmlCharEncodingAliases[i].name);
xmlFree((char *) xmlCharEncodingAliases[i].alias);
xmlCharEncodingAliasesNb--;
memmove(&xmlCharEncodingAliases[i], &xmlCharEncodingAliases[i + 1],
sizeof(xmlCharEncodingAlias) * (xmlCharEncodingAliasesNb - i));
return(0);
}
}
return(-1);
}
static int
xmlCompareEncTableEntries(const void *vkey, const void *ventry) {
const char *key = vkey;
const xmlEncTableEntry *entry = ventry;
return(xmlStrcasecmp(BAD_CAST key, BAD_CAST entry->name));
}
static xmlCharEncoding
xmlParseCharEncodingInternal(const char *name)
{
const xmlEncTableEntry *entry;
if (name == NULL)
return(XML_CHAR_ENCODING_NONE);
entry = bsearch(name, xmlEncTable,
sizeof(xmlEncTable) / sizeof(xmlEncTable[0]),
sizeof(xmlEncTable[0]), xmlCompareEncTableEntries);
if (entry != NULL)
return(entry->enc);
return(XML_CHAR_ENCODING_ERROR);
}
/**
* Compare the string to the encoding schemes already known. Note
* that the comparison is case insensitive accordingly to the section
* [XML] 4.3.3 Character Encoding in Entities.
*
* @param name the encoding name as parsed, in UTF-8 format (ASCII actually)
* @returns one of the xmlCharEncoding values or XML_CHAR_ENCODING_NONE
* if not recognized.
*/
xmlCharEncoding
xmlParseCharEncoding(const char *name)
{
xmlCharEncoding enc = xmlParseCharEncodingInternal(name);
/* Backward compatibility */
if (enc == XML_CHAR_ENCODING_UTF16)
enc = XML_CHAR_ENCODING_UTF16LE;
return(enc);
}
/**
* The "canonical" name for XML encoding.
* C.f. http://www.w3.org/TR/REC-xml#charencoding
* Section 4.3.3 Character Encoding in Entities
*
* @param enc the encoding
* @returns the canonical name for the given encoding.
*/
const char*
xmlGetCharEncodingName(xmlCharEncoding enc) {
switch (enc) {
case XML_CHAR_ENCODING_UTF16LE:
return("UTF-16");
case XML_CHAR_ENCODING_UTF16BE:
return("UTF-16");
case XML_CHAR_ENCODING_UCS4LE:
return("UCS-4");
case XML_CHAR_ENCODING_UCS4BE:
return("UCS-4");
default:
break;
}
if ((enc <= 0) || ((size_t) enc >= NUM_DEFAULT_HANDLERS))
return(NULL);
return(defaultHandlers[enc].name);
}
/************************************************************************
* *
* Char encoding handlers *
* *
************************************************************************/
/**
* Create and registers an xmlCharEncodingHandler.
*
* @deprecated This function modifies global state and is not
* thread-safe. See #xmlCtxtSetCharEncConvImpl for an alternative.
*
* @param name the encoding name, in UTF-8 format (ASCII actually)
* @param input the xmlCharEncodingInputFunc to read that encoding
* @param output the xmlCharEncodingOutputFunc to write that encoding
* @returns the xmlCharEncodingHandler created (or NULL in case of error).
*/
xmlCharEncodingHandler *
xmlNewCharEncodingHandler(const char *name,
xmlCharEncodingInputFunc input,
xmlCharEncodingOutputFunc output) {
xmlCharEncodingHandlerPtr handler;
const char *alias;
char upper[500];
int i;
char *up = NULL;
/*
* Do the alias resolution
*/
alias = xmlGetEncodingAlias(name);
if (alias != NULL)
name = alias;
/*
* Keep only the uppercase version of the encoding.
*/
if (name == NULL)
return(NULL);
for (i = 0;i < 499;i++) {
upper[i] = (char) toupper((unsigned char) name[i]);
if (upper[i] == 0) break;
}
upper[i] = 0;
up = xmlMemStrdup(upper);
if (up == NULL)
return(NULL);
/*
* allocate and fill-up an handler block.
*/
handler = (xmlCharEncodingHandlerPtr)
xmlMalloc(sizeof(xmlCharEncodingHandler));
if (handler == NULL) {
xmlFree(up);
return(NULL);
}
memset(handler, 0, sizeof(xmlCharEncodingHandler));
handler->input.legacyFunc = input;
handler->output.legacyFunc = output;
handler->name = up;
handler->flags = XML_HANDLER_STATIC | XML_HANDLER_LEGACY;
/*
* registers and returns the handler.
*/
xmlRegisterCharEncodingHandler(handler);
return(handler);
}
/**
* Create a custom xmlCharEncodingHandler.
*
* @param name the encoding name
* @param input input callback which converts to UTF-8
* @param output output callback which converts from UTF-8
* @param ctxtDtor context destructor
* @param inputCtxt context for input callback
* @param outputCtxt context for output callback
* @param out pointer to resulting handler
* @returns an xmlParserErrors code.
*/
xmlParserErrors
xmlCharEncNewCustomHandler(const char *name,
xmlCharEncConvFunc input, xmlCharEncConvFunc output,
xmlCharEncConvCtxtDtor ctxtDtor,
void *inputCtxt, void *outputCtxt,
xmlCharEncodingHandler **out) {
xmlCharEncodingHandler *handler;
if (out == NULL)
return(XML_ERR_ARGUMENT);
handler = xmlMalloc(sizeof(*handler));
if (handler == NULL)
goto error;
memset(handler, 0, sizeof(*handler));
if (name != NULL) {
handler->name = xmlMemStrdup(name);
if (handler->name == NULL)
goto error;
}
handler->input.func = input;
handler->output.func = output;
handler->ctxtDtor = ctxtDtor;
handler->inputCtxt = inputCtxt;
handler->outputCtxt = outputCtxt;
*out = handler;
return(XML_ERR_OK);
error:
xmlFree(handler);
if (ctxtDtor != NULL) {
if (inputCtxt != NULL)
ctxtDtor(inputCtxt);
if (outputCtxt != NULL)
ctxtDtor(outputCtxt);
}
return(XML_ERR_NO_MEMORY);
}
/**
* @deprecated Alias for #xmlInitParser.
*/
void
xmlInitCharEncodingHandlers(void) {
xmlInitParser();
}
/**
* Initialize the char encoding support.
*/
void
xmlInitEncodingInternal(void) {
unsigned short int tst = 0x1234;
unsigned char *ptr = (unsigned char *) &tst;
if (*ptr == 0x12) xmlLittleEndian = 0;
else xmlLittleEndian = 1;
}
/**
* Cleanup the memory allocated for the char encoding support, it
* unregisters all the encoding handlers and the aliases.
*
* @deprecated This function will be made private. Call #xmlCleanupParser
* to free global state but see the warnings there. #xmlCleanupParser
* should be only called once at program exit. In most cases, you don't
* have call cleanup functions at all.
*
*/
void
xmlCleanupCharEncodingHandlers(void) {
xmlCleanupEncodingAliases();
if (globalHandlers == NULL) return;
for (;nbCharEncodingHandler > 0;) {
xmlCharEncodingHandler *handler;
nbCharEncodingHandler--;
handler = globalHandlers[nbCharEncodingHandler];
if (handler != NULL) {
if (handler->name != NULL)
xmlFree(handler->name);
xmlFree(handler);
}
}
xmlFree(globalHandlers);
globalHandlers = NULL;
nbCharEncodingHandler = 0;
}
/**
* Register the char encoding handler.
*
* @deprecated This function modifies global state and is not
* thread-safe. See #xmlCtxtSetCharEncConvImpl for an alternative.
*
* @param handler the xmlCharEncodingHandler handler block
*/
void
xmlRegisterCharEncodingHandler(xmlCharEncodingHandler *handler) {
if (handler == NULL)
return;
if (globalHandlers == NULL) {
globalHandlers = xmlMalloc(
MAX_ENCODING_HANDLERS * sizeof(globalHandlers[0]));
if (globalHandlers == NULL)
goto free_handler;
}
if (nbCharEncodingHandler >= MAX_ENCODING_HANDLERS)
goto free_handler;
globalHandlers[nbCharEncodingHandler++] = handler;
return;
free_handler:
if (handler != NULL) {
if (handler->name != NULL) {
xmlFree(handler->name);
}
xmlFree(handler);
}
}
/**
* Search the non-default handlers for an exact match.
*
* @param norig name of the char encoding
* @param name potentially aliased name of the encoding
* @param flags bit mask of flags
* @param impl a conversion implementation (optional)
* @param implCtxt user data for conversion implementation (optional)
* @param out pointer to resulting handler
* @returns an xmlParserErrors error code.
*/
static xmlParserErrors
xmlFindExtraHandler(const char *norig, const char *name, xmlCharEncFlags flags,
xmlCharEncConvImpl impl, void *implCtxt,
xmlCharEncodingHandler **out) {
/*
* Try custom implementation before deprecated global handlers.
*
* Note that we pass the original name without deprecated
* alias resolution.
*/
if (impl != NULL)
return(impl(implCtxt, norig, flags, out));
/*
* Deprecated
*/
if (globalHandlers != NULL) {
int i;
for (i = 0; i < nbCharEncodingHandler; i++) {
xmlCharEncodingHandler *h = globalHandlers[i];
if (!xmlStrcasecmp((const xmlChar *) name,
(const xmlChar *) h->name)) {
if ((((flags & XML_ENC_INPUT) == 0) || (h->input.func)) &&
(((flags & XML_ENC_OUTPUT) == 0) || (h->output.func))) {
*out = h;
return(XML_ERR_OK);
}
}
}
}
#ifdef LIBXML_ICONV_ENABLED
{
int ret = xmlCharEncIconv(name, flags, out);
if (ret == XML_ERR_OK)
return(XML_ERR_OK);
if (ret != XML_ERR_UNSUPPORTED_ENCODING)
return(ret);
}
#endif /* LIBXML_ICONV_ENABLED */
#ifdef LIBXML_ICU_ENABLED
{
int ret = xmlCharEncUconv(name, flags, out);
if (ret == XML_ERR_OK)
return(XML_ERR_OK);
if (ret != XML_ERR_UNSUPPORTED_ENCODING)
return(ret);
}
#endif /* LIBXML_ICU_ENABLED */
return(XML_ERR_UNSUPPORTED_ENCODING);
}
/**
* Find or create a handler matching the encoding. The following
* converters are looked up in order:
*
* - Built-in handler (UTF-8, UTF-16, ISO-8859-1, ASCII)
* - User-registered global handler (deprecated)
* - iconv if enabled
* - ICU if enabled
*
* The handler must be closed with #xmlCharEncCloseFunc.
*
* If the encoding is UTF-8, a NULL handler and no error code will
* be returned.
*
* @since 2.13.0
*
* @param enc an xmlCharEncoding value.
* @param out pointer to result
* @returns XML_ERR_OK, XML_ERR_UNSUPPORTED_ENCODING or another
* xmlParserErrors error code.
*/
xmlParserErrors
xmlLookupCharEncodingHandler(xmlCharEncoding enc,
xmlCharEncodingHandler **out) {
const xmlCharEncodingHandler *handler;
if (out == NULL)
return(XML_ERR_ARGUMENT);
*out = NULL;
if ((enc <= 0) || ((size_t) enc >= NUM_DEFAULT_HANDLERS))
return(XML_ERR_UNSUPPORTED_ENCODING);
/* Return NULL handler for UTF-8 */
if ((enc == XML_CHAR_ENCODING_UTF8) ||
(enc == XML_CHAR_ENCODING_NONE))
return(XML_ERR_OK);
handler = &defaultHandlers[enc];
if ((handler->input.func != NULL) || (handler->output.func != NULL)) {
*out = (xmlCharEncodingHandler *) handler;
return(XML_ERR_OK);
}
if (handler->name != NULL) {
xmlCharEncFlags flags = XML_ENC_INPUT;
#ifdef LIBXML_OUTPUT_ENABLED
flags |= XML_ENC_OUTPUT;
#endif
return(xmlFindExtraHandler(handler->name, handler->name, flags,
NULL, NULL, out));
}
return(XML_ERR_UNSUPPORTED_ENCODING);
}
/**
* @deprecated Use #xmlLookupCharEncodingHandler which has better error
* reporting.
*
* @param enc an xmlCharEncoding value.
* @returns the handler or NULL if no handler was found or an error
* occurred.
*/
xmlCharEncodingHandler *
xmlGetCharEncodingHandler(xmlCharEncoding enc) {
xmlCharEncodingHandler *ret;
xmlLookupCharEncodingHandler(enc, &ret);
return(ret);
}
/**
* Find or create a handler matching the encoding. The following
* converters are looked up in order:
*
* - Built-in handler (UTF-8, UTF-16, ISO-8859-1, ASCII)
* - Custom implementation if provided
* - User-registered global handler (deprecated)
* - iconv if enabled
* - ICU if enabled
*
* The handler must be closed with #xmlCharEncCloseFunc.
*
* If the encoding is UTF-8, a NULL handler and no error code will
* be returned.
*
* `flags` can contain XML_ENC_INPUT, XML_ENC_OUTPUT or both.
*
* @since 2.14.0
*
* @param name a string describing the char encoding.
* @param flags bit mask of flags
* @param impl a conversion implementation (optional)
* @param implCtxt user data for conversion implementation (optional)
* @param out pointer to result
* @returns XML_ERR_OK, XML_ERR_UNSUPPORTED_ENCODING or another
* xmlParserErrors error code.
*/
xmlParserErrors
xmlCreateCharEncodingHandler(const char *name, xmlCharEncFlags flags,
xmlCharEncConvImpl impl, void *implCtxt,
xmlCharEncodingHandler **out) {
const xmlCharEncodingHandler *handler;
const char *norig, *nalias;
xmlCharEncoding enc;
if (out == NULL)
return(XML_ERR_ARGUMENT);
*out = NULL;
if ((name == NULL) || (flags == 0))
return(XML_ERR_ARGUMENT);
norig = name;
nalias = xmlGetEncodingAlias(name);
if (nalias != NULL)
name = nalias;
enc = xmlParseCharEncodingInternal(name);
/* Return NULL handler for UTF-8 */
if (enc == XML_CHAR_ENCODING_UTF8)
return(XML_ERR_OK);
if ((enc > 0) && ((size_t) enc < NUM_DEFAULT_HANDLERS)) {
if (flags & XML_ENC_HTML) {
/*
* TODO: HTML5 only allows a fixed set of charset
* labels. We should add an option to enable or
* disable this restriction.
*
* TODO: Map ISO-8859-9 to windows-1254.
*/
switch (enc) {
case XML_CHAR_ENCODING_ASCII:
case XML_CHAR_ENCODING_8859_1:
enc = XML_CHAR_ENCODING_WINDOWS_1252;
break;
case XML_CHAR_ENCODING_UCS2:
case XML_CHAR_ENCODING_UTF16:
enc = XML_CHAR_ENCODING_UTF16LE;
break;
default:
break;
}
}
handler = &defaultHandlers[enc];
if ((((flags & XML_ENC_INPUT) == 0) || (handler->input.func)) &&
(((flags & XML_ENC_OUTPUT) == 0) || (handler->output.func))) {
xmlCharEncodingHandler *ret;
/*
* Return a copy of the handler with the original name.
*/
ret = xmlMalloc(sizeof(*ret));
if (ret == NULL)
return(XML_ERR_NO_MEMORY);
memset(ret, 0, sizeof(*ret));
ret->name = xmlMemStrdup(norig);
if (ret->name == NULL) {
xmlFree(ret);
return(XML_ERR_NO_MEMORY);
}
ret->input = handler->input;
ret->output = handler->output;
ret->inputCtxt = handler->inputCtxt;
ret->outputCtxt = handler->outputCtxt;
ret->ctxtDtor = handler->ctxtDtor;
*out = ret;
return(XML_ERR_OK);
}
}
return(xmlFindExtraHandler(norig, name, flags, impl, implCtxt, out));
}
/**
* Find or create a handler matching the encoding. The following
* converters are looked up in order:
*
* - Built-in handler (UTF-8, UTF-16, ISO-8859-1, ASCII)
* - User-registered global handler (deprecated)
* - iconv if enabled
* - ICU if enabled
*
* The handler must be closed with #xmlCharEncCloseFunc.
*
* If the encoding is UTF-8, a NULL handler and no error code will
* be returned.
*
* @since 2.13.0
*
* @param name a string describing the char encoding.
* @param output boolean, use handler for output
* @param out pointer to result
* @returns XML_ERR_OK, XML_ERR_UNSUPPORTED_ENCODING or another
* xmlParserErrors error code.
*/
xmlParserErrors
xmlOpenCharEncodingHandler(const char *name, int output,
xmlCharEncodingHandler **out) {
xmlCharEncFlags flags = output ? XML_ENC_OUTPUT : XML_ENC_INPUT;
return(xmlCreateCharEncodingHandler(name, flags, NULL, NULL, out));
}
/**
* If the encoding is UTF-8, this will return a no-op handler that
* shouldn't be used.
*
* @deprecated Use #xmlOpenCharEncodingHandler which has better error
* reporting.
*
* @param name a string describing the char encoding.
* @returns the handler or NULL if no handler was found or an error
* occurred.
*/
xmlCharEncodingHandler *
xmlFindCharEncodingHandler(const char *name) {
xmlCharEncodingHandler *ret;
xmlCharEncFlags flags;
/*
* This handler shouldn't be used, but we must return a non-NULL
* handler.
*/
if ((xmlStrcasecmp(BAD_CAST name, BAD_CAST "UTF-8") == 0) ||
(xmlStrcasecmp(BAD_CAST name, BAD_CAST "UTF8") == 0))
return((xmlCharEncodingHandlerPtr)
&defaultHandlers[XML_CHAR_ENCODING_UTF8]);
flags = XML_ENC_INPUT;
#ifdef LIBXML_OUTPUT_ENABLED
flags |= XML_ENC_OUTPUT;
#endif
xmlCreateCharEncodingHandler(name, flags, NULL, NULL, &ret);
return(ret);
}
/************************************************************************
* *
* ICONV based generic conversion functions *
* *
************************************************************************/
#ifdef LIBXML_ICONV_ENABLED
typedef struct {
iconv_t cd;
} xmlIconvCtxt;
/**
* The value of `inlen` after return is the number of bytes consumed.
* The value of `outlen` after return is the number of bytes produced.
*
* @param vctxt conversion context
* @param out a pointer to an array of bytes to store the result
* @param outlen the length of `out`
* @param in a pointer to an array of input bytes
* @param inlen the length of `in`
* @param flush end of input
* @returns an xmlCharEncError code.
*/
static xmlCharEncError
xmlIconvConvert(void *vctxt, unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
xmlIconvCtxt *ctxt = vctxt;
size_t icv_inlen, icv_outlen;
const char *icv_in = (const char *) in;
char *icv_out = (char *) out;
size_t ret;
if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL)) {
if (outlen != NULL) *outlen = 0;
return(XML_ENC_ERR_INTERNAL);
}
icv_inlen = *inlen;
icv_outlen = *outlen;
/*
* Some versions take const, other versions take non-const input.
*/
ret = iconv(ctxt->cd, (void *) &icv_in, &icv_inlen, &icv_out, &icv_outlen);
*inlen -= icv_inlen;
*outlen -= icv_outlen;
if (ret == (size_t) -1) {
if (errno == EILSEQ)
return(XML_ENC_ERR_INPUT);
if (errno == E2BIG)
return(XML_ENC_ERR_SPACE);
/*
* EINVAL means a truncated multi-byte sequence at the end
* of the input buffer. We treat this as success.
*/
if (errno == EINVAL)
return(XML_ENC_ERR_SUCCESS);
#ifdef __APPLE__
/*
* Apple's new libiconv can return EOPNOTSUPP under
* unknown circumstances (detected when fuzzing).
*/
if (errno == EOPNOTSUPP)
return(XML_ENC_ERR_INPUT);
#endif
return(XML_ENC_ERR_INTERNAL);
}
return(XML_ENC_ERR_SUCCESS);
}
static void
xmlIconvFree(void *vctxt) {
xmlIconvCtxt *ctxt = vctxt;
if (ctxt == NULL)
return;
if (ctxt->cd != (iconv_t) -1)
iconv_close(ctxt->cd);
xmlFree(ctxt);
}
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && \
defined(__GLIBC__)
#include <libxml/parserInternals.h>
static int
xmlEncodingMatch(const char *name1, const char *name2) {
/*
* Fuzzy match for encoding names
*/
while (1) {
while ((*name1 != 0) && (!IS_ASCII_LETTER(*name1)))
name1 += 1;
while ((*name2 != 0) && (!IS_ASCII_LETTER(*name2)))
name2 += 1;
if ((*name1 == 0) || (*name2 == 0))
break;
if ((*name1 | 0x20) != (*name2 | 0x20))
return(0);
name1 += 1;
name2 += 1;
}
/* Only check whether name1 starts with name2 */
return(*name2 == 0);
}
#endif /* FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION */
static xmlParserErrors
xmlCharEncIconv(const char *name, xmlCharEncFlags flags,
xmlCharEncodingHandler **out) {
xmlCharEncConvFunc inFunc = NULL, outFunc = NULL;
xmlIconvCtxt *inputCtxt = NULL, *outputCtxt = NULL;
iconv_t icv_in;
iconv_t icv_out;
xmlParserErrors ret;
/*
* POSIX allows "indicator suffixes" like "//IGNORE" to be
* passed to iconv_open. This can change the behavior in
* unexpected ways.
*
* Many iconv implementations also support non-standard
* codesets like "wchar_t", "char" or the empty string "".
* It would make sense to disallow them, but codeset names
* are matched fuzzily, so a string like "w-C.hA_rt" could
* be interpreted as "wchar_t".
*
* When escaping characters that aren't supported in the
* target encoding, we also rely on GNU libiconv behavior to
* stop conversion without trying any kind of fallback.
* This violates the POSIX spec which says:
*
* > If iconv() encounters a character in the input buffer
* > that is valid, but for which an identical character does
* > not exist in the output codeset [...] iconv() shall
* > perform an implementation-defined conversion on the
* > character.
*
* See: https://sourceware.org/bugzilla/show_bug.cgi?id=29913
*
* Unfortunately, strict POSIX compliance makes it impossible
* to detect untranslatable characters.
*/
if (strstr(name, "//") != NULL) {
ret = XML_ERR_UNSUPPORTED_ENCODING;
goto error;
}
#if defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) && \
defined(__GLIBC__)
/*
* This glibc bug can lead to unpredictable results with the
* push parser.
*
* https://sourceware.org/bugzilla/show_bug.cgi?id=32633
*/
if ((xmlEncodingMatch(name, "TSCII")) ||
(xmlEncodingMatch(name, "BIG5-HKSCS"))) {
ret = XML_ERR_UNSUPPORTED_ENCODING;
goto error;
}
#endif
if (flags & XML_ENC_INPUT) {
inputCtxt = xmlMalloc(sizeof(xmlIconvCtxt));
if (inputCtxt == NULL) {
ret = XML_ERR_NO_MEMORY;
goto error;
}
inputCtxt->cd = (iconv_t) -1;
icv_in = iconv_open("UTF-8", name);
if (icv_in == (iconv_t) -1) {
if (errno == EINVAL)
ret = XML_ERR_UNSUPPORTED_ENCODING;
else if (errno == ENOMEM)
ret = XML_ERR_NO_MEMORY;
else
ret = XML_ERR_SYSTEM;
goto error;
}
inputCtxt->cd = icv_in;
inFunc = xmlIconvConvert;
}
if (flags & XML_ENC_OUTPUT) {
outputCtxt = xmlMalloc(sizeof(xmlIconvCtxt));
if (outputCtxt == NULL) {
ret = XML_ERR_NO_MEMORY;
goto error;
}
outputCtxt->cd = (iconv_t) -1;
icv_out = iconv_open(name, "UTF-8");
if (icv_out == (iconv_t) -1) {
if (errno == EINVAL)
ret = XML_ERR_UNSUPPORTED_ENCODING;
else if (errno == ENOMEM)
ret = XML_ERR_NO_MEMORY;
else
ret = XML_ERR_SYSTEM;
goto error;
}
outputCtxt->cd = icv_out;
outFunc = xmlIconvConvert;
}
return(xmlCharEncNewCustomHandler(name, inFunc, outFunc, xmlIconvFree,
inputCtxt, outputCtxt, out));
error:
if (inputCtxt != NULL)
xmlIconvFree(inputCtxt);
if (outputCtxt != NULL)
xmlIconvFree(outputCtxt);
return(ret);
}
#endif /* LIBXML_ICONV_ENABLED */
/************************************************************************
* *
* ICU based generic conversion functions *
* *
************************************************************************/
#ifdef LIBXML_ICU_ENABLED
/* Size of pivot buffer, same as icu/source/common/ucnv.cpp CHUNK_SIZE */
#define ICU_PIVOT_BUF_SIZE 1024
typedef struct _uconv_t xmlUconvCtxt;
struct _uconv_t {
UConverter *uconv; /* for conversion between an encoding and UTF-16 */
UConverter *utf8; /* for conversion between UTF-8 and UTF-16 */
UChar *pivot_source;
UChar *pivot_target;
int isInput;
UChar pivot_buf[ICU_PIVOT_BUF_SIZE];
};
/**
* The value of `inlen` after return is the number of bytes consumed.
* The value of `outlen` after return is the number of bytes produced.
*
* @param vctxt conversion context
* @param out a pointer to an array of bytes to store the result
* @param outlen the length of `out`
* @param in a pointer to an array of input bytes
* @param inlen the length of `in`
* @param flush end of input
* @returns an xmlCharEncError code.
*/
static xmlCharEncError
xmlUconvConvert(void *vctxt, unsigned char *out, int *outlen,
const unsigned char *in, int *inlen, int flush) {
xmlUconvCtxt *cd = vctxt;
const char *ucv_in = (const char *) in;
char *ucv_out = (char *) out;
UConverter *target, *source;
UErrorCode err = U_ZERO_ERROR;
int ret;
if ((out == NULL) || (outlen == NULL) || (inlen == NULL) || (in == NULL)) {
if (outlen != NULL)
*outlen = 0;
return(XML_ENC_ERR_INTERNAL);
}
/*
* The ICU API can consume input, including partial sequences,
* even if the output buffer would overflow. The remaining input
* must be processed by calling ucnv_convertEx with a possibly
* empty input buffer.
*/
if (cd->isInput) {
source = cd->uconv;
target = cd->utf8;
} else {
source = cd->utf8;
target = cd->uconv;
}
ucnv_convertEx(target, source, &ucv_out, ucv_out + *outlen,
&ucv_in, ucv_in + *inlen, cd->pivot_buf,
&cd->pivot_source, &cd->pivot_target,
cd->pivot_buf + ICU_PIVOT_BUF_SIZE,
/* reset */ 0, flush, &err);
*inlen = ucv_in - (const char*) in;
*outlen = ucv_out - (char *) out;
if (U_SUCCESS(err)) {
ret = XML_ENC_ERR_SUCCESS;
} else {
switch (err) {
case U_TRUNCATED_CHAR_FOUND:
/* Should only happen with flush */
ret = XML_ENC_ERR_INPUT;
break;
case U_BUFFER_OVERFLOW_ERROR:
ret = XML_ENC_ERR_SPACE;
break;
case U_INVALID_CHAR_FOUND:
case U_ILLEGAL_CHAR_FOUND:
case U_ILLEGAL_ESCAPE_SEQUENCE:
case U_UNSUPPORTED_ESCAPE_SEQUENCE:
ret = XML_ENC_ERR_INPUT;
break;
case U_MEMORY_ALLOCATION_ERROR:
ret = XML_ENC_ERR_MEMORY;
break;
default:
ret = XML_ENC_ERR_INTERNAL;
break;
}
}
return(ret);
}
static xmlParserErrors
openIcuConverter(const char* name, int isInput, xmlUconvCtxt **out)
{
UErrorCode status;
xmlUconvCtxt *conv;
*out = NULL;
conv = (xmlUconvCtxt *) xmlMalloc(sizeof(xmlUconvCtxt));
if (conv == NULL)
return(XML_ERR_NO_MEMORY);
conv->isInput = isInput;
conv->pivot_source = conv->pivot_buf;
conv->pivot_target = conv->pivot_buf;
status = U_ZERO_ERROR;
conv->uconv = ucnv_open(name, &status);
if (U_FAILURE(status))
goto error;
status = U_ZERO_ERROR;
if (isInput) {
ucnv_setToUCallBack(conv->uconv, UCNV_TO_U_CALLBACK_STOP,
NULL, NULL, NULL, &status);
}
else {
ucnv_setFromUCallBack(conv->uconv, UCNV_FROM_U_CALLBACK_STOP,
NULL, NULL, NULL, &status);
}
if (U_FAILURE(status))
goto error;
status = U_ZERO_ERROR;
conv->utf8 = ucnv_open("UTF-8", &status);
if (U_FAILURE(status))
goto error;
*out = conv;
return(XML_ERR_OK);
error:
if (conv->uconv)
ucnv_close(conv->uconv);
xmlFree(conv);
if (status == U_FILE_ACCESS_ERROR)
return(XML_ERR_UNSUPPORTED_ENCODING);
if (status == U_MEMORY_ALLOCATION_ERROR)
return(XML_ERR_NO_MEMORY);
return(XML_ERR_SYSTEM);
}
static void
closeIcuConverter(xmlUconvCtxt *conv)
{
if (conv == NULL)
return;
ucnv_close(conv->uconv);
ucnv_close(conv->utf8);
xmlFree(conv);
}
static void
xmlUconvFree(void *vctxt) {
closeIcuConverter(vctxt);
}
static xmlParserErrors
xmlCharEncUconv(const char *name, xmlCharEncFlags flags,
xmlCharEncodingHandler **out) {
xmlCharEncConvFunc inFunc = NULL, outFunc = NULL;
xmlUconvCtxt *ucv_in = NULL;
xmlUconvCtxt *ucv_out = NULL;
int ret;
if (flags & XML_ENC_INPUT) {
ret = openIcuConverter(name, 1, &ucv_in);
if (ret != 0)
goto error;
inFunc = xmlUconvConvert;
}
if (flags & XML_ENC_OUTPUT) {
ret = openIcuConverter(name, 0, &ucv_out);
if (ret != 0)
goto error;
outFunc = xmlUconvConvert;
}
return(xmlCharEncNewCustomHandler(name, inFunc, outFunc, xmlUconvFree,
ucv_in, ucv_out, out));
error:
if (ucv_in != NULL)
closeIcuConverter(ucv_in);
if (ucv_out != NULL)
closeIcuConverter(ucv_out);
return(ret);
}
#endif /* LIBXML_ICU_ENABLED */
/************************************************************************
* *
* The real API used by libxml for on-the-fly conversion *
* *
************************************************************************/
/**
* Convert xmlCharEncError to xmlParserErrors code.
*
* @param code xmlCharEncError code
*/
static xmlParserErrors
xmlEncConvertError(xmlCharEncError code) {
xmlParserErrors ret;
switch (code) {
case XML_ENC_ERR_SUCCESS:
ret = XML_ERR_OK;
break;
case XML_ENC_ERR_INPUT:
ret = XML_ERR_INVALID_ENCODING;
break;
case XML_ENC_ERR_MEMORY:
ret = XML_ERR_NO_MEMORY;
break;
default:
ret = XML_ERR_INTERNAL_ERROR;
break;
}
return(ret);
}
/**
* The value of `inlen` after return is the number of bytes consumed.
* The value of `outlen` after return is the number of bytes produced.
*
* @param handler encoding handler
* @param out a pointer to an array of bytes to store the result
* @param outlen the length of `out`
* @param in a pointer to an array of input bytes
* @param inlen the length of `in`
* @param flush end of input
* @returns an xmlCharEncError code.
*/
xmlCharEncError
xmlEncInputChunk(xmlCharEncodingHandler *handler, unsigned char *out,
int *outlen, const unsigned char *in, int *inlen,
int flush) {
xmlCharEncError ret;
if (handler->flags & XML_HANDLER_LEGACY) {
xmlCharEncodingInputFunc func = handler->input.legacyFunc;
if (func == NULL) {
*outlen = 0;
*inlen = 0;
return(XML_ENC_ERR_INTERNAL);
}
ret = func(out, outlen, in, inlen);
} else {
xmlCharEncConvFunc func = handler->input.func;
int oldInlen;
if (func == NULL) {
*outlen = 0;
*inlen = 0;
return(XML_ENC_ERR_INTERNAL);
}
oldInlen = *inlen;
ret = func(handler->inputCtxt, out, outlen, in, inlen, flush);
/*
* Check for truncated multi-byte sequence.
*/
if ((flush) && (ret == XML_ENC_ERR_SUCCESS) && (*inlen != oldInlen))
ret = XML_ENC_ERR_INPUT;
}
if (ret > 0)
ret = XML_ENC_ERR_SUCCESS;
return(ret);
}
/**
* The value of `inlen` after return is the number of bytes consumed.
* The value of `outlen` after return is the number of bytes produced.
*
* @param handler encoding handler
* @param out a pointer to an array of bytes to store the result
* @param outlen the length of `out`
* @param in a pointer to an array of input bytes
* @param inlen the length of `in`
* @returns an xmlCharEncError code.
*/
static xmlCharEncError
xmlEncOutputChunk(xmlCharEncodingHandler *handler, unsigned char *out,
int *outlen, const unsigned char *in, int *inlen) {
xmlCharEncError ret;
if (handler->flags & XML_HANDLER_LEGACY) {
xmlCharEncodingOutputFunc func = handler->output.legacyFunc;
if (func == NULL) {
*outlen = 0;
*inlen = 0;
return(XML_ENC_ERR_INTERNAL);
}
ret = func(out, outlen, in, inlen);
} else {
xmlCharEncConvFunc func = handler->output.func;
if (func == NULL) {
*outlen = 0;
*inlen = 0;
return(XML_ENC_ERR_INTERNAL);
}
ret = func(handler->outputCtxt, out, outlen, in, inlen, /* flush */ 0);
}
if (ret > 0)
ret = XML_ENC_ERR_SUCCESS;
return(ret);
}
/**
* DEPERECATED: Don't use.
*
* @param handler encoding handler
* @param out an xmlBuffer for the output.
* @param in an xmlBuffer for the input
* @returns the number of bytes written or an xmlCharEncError code.
*/
int
xmlCharEncFirstLine(xmlCharEncodingHandler *handler, struct _xmlBuffer *out,
struct _xmlBuffer *in) {
return(xmlCharEncInFunc(handler, out, in));
}
/**
* Generic front-end for input encoding conversion.
*
* `sizeOut` should be set to the maximum output size (or SIZE_MAX).
* After return, it is set to the number of bytes written.
*
* @param input a parser input buffer
* @param sizeOut pointer to output size
* @param flush end of input
* @returns an xmlCharEncError code.
*/
xmlCharEncError
xmlCharEncInput(xmlParserInputBuffer *input, size_t *sizeOut, int flush)
{
xmlBufPtr out, in;
const xmlChar *dataIn;
size_t availIn;
size_t maxOut;
size_t totalIn, totalOut;
xmlCharEncError ret;
out = input->buffer;
in = input->raw;
maxOut = *sizeOut;
totalOut = 0;
*sizeOut = 0;
availIn = xmlBufUse(in);
if ((availIn == 0) && (!flush))
return(0);
dataIn = xmlBufContent(in);
totalIn = 0;
while (1) {
size_t availOut;
int completeOut, completeIn;
int c_out, c_in;
availOut = xmlBufAvail(out);
if (availOut > INT_MAX / 2)
availOut = INT_MAX / 2;
if (availOut < maxOut) {
c_out = availOut;
completeOut = 0;
} else {
c_out = maxOut;
completeOut = 1;
}
if (availIn > INT_MAX / 2) {
c_in = INT_MAX / 2;
completeIn = 0;
} else {
c_in = availIn;
completeIn = 1;
}
ret = xmlEncInputChunk(input->encoder, xmlBufEnd(out), &c_out,
dataIn, &c_in, flush && completeIn);
totalIn += c_in;
dataIn += c_in;
availIn -= c_in;
totalOut += c_out;
maxOut -= c_out;
xmlBufAddLen(out, c_out);
if ((ret != XML_ENC_ERR_SUCCESS) && (ret != XML_ENC_ERR_SPACE)) {
input->error = xmlEncConvertError(ret);
return(ret);
}
if ((completeOut) && (completeIn))
break;
if ((completeOut) && (ret == XML_ENC_ERR_SPACE))
break;
if ((completeIn) && (ret == XML_ENC_ERR_SUCCESS))
break;
if (ret == XML_ENC_ERR_SPACE) {
if (xmlBufGrow(out, 4096) < 0) {
input->error = XML_ERR_NO_MEMORY;
return(XML_ENC_ERR_MEMORY);
}
}
}
xmlBufShrink(in, totalIn);
if (input->rawconsumed > ULONG_MAX - (unsigned long) totalIn)
input->rawconsumed = ULONG_MAX;
else
input->rawconsumed += totalIn;
*sizeOut = totalOut;
return(XML_ENC_ERR_SUCCESS);
}
/**
* Generic front-end for input encoding conversion.
*
* @param handler encoding handler
* @param out an xmlBuffer for the output.
* @param in an xmlBuffer for the input
* @returns the number of bytes written or an xmlCharEncError code.
*/
int
xmlCharEncInFunc(xmlCharEncodingHandler * handler, struct _xmlBuffer *out,
struct _xmlBuffer *in)
{
int ret;
int written;
int toconv;
if (handler == NULL)
return(XML_ENC_ERR_INTERNAL);
if (out == NULL)
return(XML_ENC_ERR_INTERNAL);
if (in == NULL)
return(XML_ENC_ERR_INTERNAL);
toconv = in->use;
if (toconv == 0)
return (0);
written = out->size - out->use -1; /* count '\0' */
if (toconv * 2 >= written) {
xmlBufferGrow(out, out->size + toconv * 2);
written = out->size - out->use - 1;
}
ret = xmlEncInputChunk(handler, &out->content[out->use], &written,
in->content, &toconv, /* flush */ 0);
xmlBufferShrink(in, toconv);
out->use += written;
out->content[out->use] = 0;
return (written? written : ret);
}
/*
* @param buf a char buffer
* @param val a codepoint
*
* Serializes a decimal char ref like `&#38;`.
*
* Writes at most 10 bytes. Does not include a terminating zero byte.
*
* @returns the number of bytes written.
*/
static int
xmlSerializeDecCharRef(char *buf, int val) {
char *out = buf;
int len, i;
*out++ = '&';
*out++ = '#';
if (val < 100) {
len = (val < 10) ? 1 : 2;
} else if (val < 10000) {
len = (val < 1000) ? 3 : 4;
} else if (val < 1000000) {
len = (val < 100000) ? 5 : 6;
} else {
len = 7;
}
for (i = len - 1; i >= 0; i--) {
out[i] = '0' + val % 10;
val /= 10;
}
out[len] = ';';
return(len + 3);
}
#ifdef LIBXML_OUTPUT_ENABLED
/**
* Generic front-end for output encoding conversion.
*
* A first call with `init` set to 1 has to be made to write a BOM.
*
* When using GNU libiconv, unsupported characters in the output
* encoding will be automatically replaced with a numeric character
* reference.
*
* @param output a parser output buffer
* @param init is this an initialization call without data
* @returns the number of bytes written or an xmlCharEncError code.
*/
int
xmlCharEncOutput(xmlOutputBuffer *output, int init)
{
int ret;
size_t written;
int writtentot = 0;
size_t toconv;
int c_in;
int c_out;
xmlBufPtr in;
xmlBufPtr out;
if ((output == NULL) || (output->encoder == NULL) ||
(output->buffer == NULL) || (output->conv == NULL))
return(XML_ENC_ERR_INTERNAL);
out = output->conv;
in = output->buffer;
retry:
written = xmlBufAvail(out);
/*
* First specific handling of the initialization call
*/
if (init) {
c_in = 0;
c_out = written;
/* TODO: Check return value. */
xmlEncOutputChunk(output->encoder, xmlBufEnd(out), &c_out,
NULL, &c_in);
xmlBufAddLen(out, c_out);
return(c_out);
}
/*
* Conversion itself.
*/
toconv = xmlBufUse(in);
if (toconv > 64 * 1024)
toconv = 64 * 1024;
if (toconv * 4 >= written) {
if (xmlBufGrow(out, toconv * 4) < 0) {
ret = XML_ENC_ERR_MEMORY;
goto error;
}
written = xmlBufAvail(out);
}
if (written > 256 * 1024)
written = 256 * 1024;
c_in = toconv;
c_out = written;
ret = xmlEncOutputChunk(output->encoder, xmlBufEnd(out), &c_out,
xmlBufContent(in), &c_in);
xmlBufShrink(in, c_in);
xmlBufAddLen(out, c_out);
writtentot += c_out;
if (ret == XML_ENC_ERR_SPACE)
goto retry;
/*
* Attempt to handle error cases
*/
if (ret == XML_ENC_ERR_INPUT) {
xmlChar charref[20];
int len = xmlBufUse(in);
xmlChar *content = xmlBufContent(in);
int cur, charrefLen;
cur = xmlGetUTF8Char(content, &len);
if (cur <= 0)
goto error;
/*
* Removes the UTF8 sequence, and replace it by a charref
* and continue the transcoding phase, hoping the error
* did not mangle the encoder state.
*/
charrefLen = xmlSerializeDecCharRef((char *) charref, cur);
xmlBufGrow(out, charrefLen * 4);
c_out = xmlBufAvail(out);
c_in = charrefLen;
ret = xmlEncOutputChunk(output->encoder, xmlBufEnd(out), &c_out,
charref, &c_in);
if ((ret < 0) || (c_in != charrefLen)) {
ret = XML_ENC_ERR_INTERNAL;
goto error;
}
xmlBufShrink(in, len);
xmlBufAddLen(out, c_out);
writtentot += c_out;
goto retry;
}
error:
if (((writtentot <= 0) && (ret != 0)) ||
(ret == XML_ENC_ERR_MEMORY)) {
if (output->error == 0)
output->error = xmlEncConvertError(ret);
return(ret);
}
return(writtentot);
}
#endif
/**
* Generic front-end for output encoding conversion.
*
* A first call with `in` set to NULL has to be made to write a BOM.
*
* When using GNU libiconv, unsupported characters in the output
* encoding will be automatically replaced with a numeric character
* reference.
*
* @param handler encoding handler
* @param out an xmlBuffer for the output.
* @param in an xmlBuffer for the input
* @returns the number of bytes written or an xmlCharEncError code.
*/
int
xmlCharEncOutFunc(xmlCharEncodingHandler *handler, struct _xmlBuffer *out,
struct _xmlBuffer *in) {
int ret;
int written;
int writtentot = 0;
int toconv;
if (handler == NULL) return(XML_ENC_ERR_INTERNAL);
if (out == NULL) return(XML_ENC_ERR_INTERNAL);
retry:
written = out->size - out->use;
if (written > 0)
written--; /* Gennady: count '/0' */
/*
* First specific handling of in = NULL, i.e. the initialization call
*/
if (in == NULL) {
toconv = 0;
/* TODO: Check return value. */
xmlEncOutputChunk(handler, &out->content[out->use], &written,
NULL, &toconv);
out->use += written;
out->content[out->use] = 0;
return(0);
}
/*
* Conversion itself.
*/
toconv = in->use;
if (toconv * 4 >= written) {
xmlBufferGrow(out, toconv * 4);
written = out->size - out->use - 1;
}
ret = xmlEncOutputChunk(handler, &out->content[out->use], &written,
in->content, &toconv);
xmlBufferShrink(in, toconv);
out->use += written;
writtentot += written;
out->content[out->use] = 0;
if (ret == XML_ENC_ERR_SPACE)
goto retry;
/*
* Attempt to handle error cases
*/
if (ret == XML_ENC_ERR_INPUT) {
xmlChar charref[20];
int len = in->use;
const xmlChar *utf = (const xmlChar *) in->content;
int cur, charrefLen;
cur = xmlGetUTF8Char(utf, &len);
if (cur <= 0)
return(ret);
/*
* Removes the UTF8 sequence, and replace it by a charref
* and continue the transcoding phase, hoping the error
* did not mangle the encoder state.
*/
charrefLen = xmlSerializeDecCharRef((char *) charref, cur);
xmlBufferShrink(in, len);
xmlBufferGrow(out, charrefLen * 4);
written = out->size - out->use - 1;
toconv = charrefLen;
ret = xmlEncOutputChunk(handler, &out->content[out->use], &written,
charref, &toconv);
if ((ret < 0) || (toconv != charrefLen))
return(XML_ENC_ERR_INTERNAL);
out->use += written;
writtentot += written;
out->content[out->use] = 0;
goto retry;
}
return(writtentot ? writtentot : ret);
}
/**
* Releases an xmlCharEncodingHandler. Must be called after
* a handler is no longer in use.
*
* @param handler encoding handler
* @returns 0.
*/
int
xmlCharEncCloseFunc(xmlCharEncodingHandler *handler) {
if (handler == NULL)
return(0);
if (handler->flags & XML_HANDLER_STATIC)
return(0);
xmlFree(handler->name);
if (handler->ctxtDtor != NULL) {
handler->ctxtDtor(handler->inputCtxt);
handler->ctxtDtor(handler->outputCtxt);
}
xmlFree(handler);
return(0);
}
/**
* This function provides the current index of the parser relative
* to the start of the current entity. This function is computed in
* bytes from the beginning starting at zero and finishing at the
* size in byte of the file if parsing a file. The function is
* of constant cost if the input is UTF-8 but can be costly if run
* on non-UTF-8 input.
*
* @deprecated Don't use.
*
* @param ctxt an XML parser context
* @returns the index in bytes from the beginning of the entity or -1
* in case the index could not be computed.
*/
long
xmlByteConsumed(xmlParserCtxt *ctxt) {
xmlParserInputPtr in;
if (ctxt == NULL)
return(-1);
in = ctxt->input;
if (in == NULL)
return(-1);
if ((in->buf != NULL) && (in->buf->encoder != NULL)) {
int unused = 0;
xmlCharEncodingHandler * handler = in->buf->encoder;
/*
* Encoding conversion, compute the number of unused original
* bytes from the input not consumed and subtract that from
* the raw consumed value, this is not a cheap operation
*/
if (in->end - in->cur > 0) {
unsigned char *convbuf;
const unsigned char *cur = (const unsigned char *)in->cur;
int toconv, ret;
convbuf = xmlMalloc(32000);
if (convbuf == NULL)
return(-1);
toconv = in->end - cur;
unused = 32000;
ret = xmlEncOutputChunk(handler, convbuf, &unused, cur, &toconv);
xmlFree(convbuf);
if (ret != XML_ENC_ERR_SUCCESS)
return(-1);
}
if (in->buf->rawconsumed < (unsigned long) unused)
return(-1);
return(in->buf->rawconsumed - unused);
}
return(in->consumed + (in->cur - in->base));
}
/************************************************************************
* *
* Conversions To/From UTF8 encoding *
* *
************************************************************************/
static xmlCharEncError
asciiToAscii(void *vctxt ATTRIBUTE_UNUSED,
unsigned char* out, int *poutlen,
const unsigned char* in, int *pinlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char *inend;
const unsigned char *instart = in;
int inlen, outlen, ret;
if (in == NULL) {
*pinlen = 0;
*poutlen = 0;
return(XML_ENC_ERR_SUCCESS);
}
inlen = *pinlen;
outlen = *poutlen;
if (outlen < inlen) {
inlen = outlen;
ret = XML_ENC_ERR_SPACE;
} else {
ret = inlen;
}
inend = in + inlen;
*poutlen = inlen;
*pinlen = inlen;
while (in < inend) {
unsigned c = *in;
if (c >= 0x80) {
*poutlen = in - instart;
*pinlen = in - instart;
return(XML_ENC_ERR_INPUT);
}
in++;
*out++ = c;
}
return(ret);
}
static xmlCharEncError
latin1ToUTF8(void *vctxt ATTRIBUTE_UNUSED,
unsigned char* out, int *outlen,
const unsigned char* in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
unsigned char* outstart = out;
const unsigned char* instart = in;
unsigned char* outend;
const unsigned char* inend;
int ret = XML_ENC_ERR_SPACE;
if ((out == NULL) || (in == NULL) || (outlen == NULL) || (inlen == NULL))
return(XML_ENC_ERR_INTERNAL);
outend = out + *outlen;
inend = in + *inlen;
while (in < inend) {
unsigned c = *in;
if (c < 0x80) {
if (out >= outend)
goto done;
*out++ = c;
} else {
if (outend - out < 2)
goto done;
*out++ = (c >> 6) | 0xC0;
*out++ = (c & 0x3F) | 0x80;
}
in++;
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
/**
* Take a block of ISO Latin 1 chars in and try to convert it to an UTF-8
* block of chars out.
*
* The value of `inlen` after return is the number of bytes consumed.
* The value of `outlen` after return is the number of bytes produced.
*
* @param out a pointer to an array of bytes to store the result
* @param outlen the length of `out`
* @param in a pointer to an array of ISO Latin 1 chars
* @param inlen the length of `in`
* @returns the number of bytes written or an xmlCharEncError code.
*/
int
xmlIsolat1ToUTF8(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
return(latin1ToUTF8(/* ctxt */ NULL, out, outlen, in, inlen,
/* flush */ 0));
}
static xmlCharEncError
UTF8ToUTF8(void *vctxt ATTRIBUTE_UNUSED,
unsigned char* out, int *outlen,
const unsigned char* in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
int len;
int ret;
if (in == NULL) {
*inlen = 0;
*outlen = 0;
return(XML_ENC_ERR_SUCCESS);
}
if (*outlen < *inlen) {
len = *outlen;
ret = XML_ENC_ERR_SPACE;
} else {
len = *inlen;
ret = len;
}
memcpy(out, in, len);
*outlen = len;
*inlen = len;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
static xmlCharEncError
UTF8ToLatin1(void *vctxt ATTRIBUTE_UNUSED,
unsigned char* out, int *outlen,
const unsigned char* in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char* outend;
const unsigned char* outstart = out;
const unsigned char* instart = in;
const unsigned char* inend;
unsigned c;
int ret = XML_ENC_ERR_SPACE;
if ((out == NULL) || (outlen == NULL) || (inlen == NULL))
return(XML_ENC_ERR_INTERNAL);
if (in == NULL) {
*inlen = 0;
*outlen = 0;
return(XML_ENC_ERR_SUCCESS);
}
inend = in + *inlen;
outend = out + *outlen;
while (in < inend) {
if (out >= outend)
goto done;
c = *in;
if (c < 0x80) {
*out++ = c;
} else if ((c >= 0xC2) && (c <= 0xC3)) {
if (inend - in < 2)
break;
in++;
*out++ = (unsigned char) ((c << 6) | (*in & 0x3F));
} else {
ret = XML_ENC_ERR_INPUT;
goto done;
}
in++;
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
/**
* Take a block of UTF-8 chars in and try to convert it to an ISO Latin 1
* block of chars out.
*
* The value of `inlen` after return is the number of bytes consumed.
* The value of `outlen` after return is the number of bytes produced.
*
* @param out a pointer to an array of bytes to store the result
* @param outlen the length of `out`
* @param in a pointer to an array of UTF-8 chars
* @param inlen the length of `in`
* @returns the number of bytes written or an xmlCharEncError code.
*/
int
xmlUTF8ToIsolat1(unsigned char* out, int *outlen,
const unsigned char* in, int *inlen) {
if ((out == NULL) || (outlen == NULL) || (in == NULL) || (inlen == NULL))
return(XML_ENC_ERR_INTERNAL);
return(UTF8ToLatin1(/* ctxt */ NULL, out, outlen, in, inlen,
/* flush */ 0));
}
#endif /* LIBXML_OUTPUT_ENABLED */
static xmlCharEncError
UTF16LEToUTF8(void *vctxt ATTRIBUTE_UNUSED,
unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char *instart = in;
const unsigned char *inend = in + (*inlen & ~1);
unsigned char *outstart = out;
unsigned char *outend = out + *outlen;
unsigned c, d;
int ret = XML_ENC_ERR_SPACE;
while (in < inend) {
c = in[0] | (in[1] << 8);
if (c < 0x80) {
if (out >= outend)
goto done;
out[0] = c;
in += 2;
out += 1;
} else if (c < 0x800) {
if (outend - out < 2)
goto done;
out[0] = (c >> 6) | 0xC0;
out[1] = (c & 0x3F) | 0x80;
in += 2;
out += 2;
} else if ((c & 0xF800) != 0xD800) {
if (outend - out < 3)
goto done;
out[0] = (c >> 12) | 0xE0;
out[1] = ((c >> 6) & 0x3F) | 0x80;
out[2] = (c & 0x3F) | 0x80;
in += 2;
out += 3;
} else {
/* Surrogate pair */
if ((c & 0xFC00) != 0xD800) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (inend - in < 4)
break;
d = in[2] | (in[3] << 8);
if ((d & 0xFC00) != 0xDC00) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (outend - out < 4)
goto done;
c = (c << 10) + d - ((0xD800 << 10) + 0xDC00 - 0x10000);
out[0] = (c >> 18) | 0xF0;
out[1] = ((c >> 12) & 0x3F) | 0x80;
out[2] = ((c >> 6) & 0x3F) | 0x80;
out[3] = (c & 0x3F) | 0x80;
in += 4;
out += 4;
}
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
static xmlCharEncError
UTF8ToUTF16LE(void *vctxt ATTRIBUTE_UNUSED,
unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char *instart = in;
const unsigned char *inend;
unsigned char *outstart = out;
unsigned char *outend;
unsigned c, d;
int ret = XML_ENC_ERR_SPACE;
/* UTF16LE encoding has no BOM */
if ((out == NULL) || (outlen == NULL) || (inlen == NULL))
return(XML_ENC_ERR_INTERNAL);
if (in == NULL) {
*outlen = 0;
*inlen = 0;
return(0);
}
inend = in + *inlen;
outend = out + (*outlen & ~1);
while (in < inend) {
c = in[0];
if (c < 0x80) {
if (out >= outend)
goto done;
out[0] = c;
out[1] = 0;
in += 1;
out += 2;
} else {
int i, len;
unsigned min;
if (c < 0xE0) {
if (c < 0xC2) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
c &= 0x1F;
len = 2;
min = 0x80;
} else if (c < 0xF0) {
c &= 0x0F;
len = 3;
min = 0x800;
} else {
c &= 0x0F;
len = 4;
min = 0x10000;
}
if (inend - in < len)
break;
for (i = 1; i < len; i++) {
if ((in[i] & 0xC0) != 0x80) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
c = (c << 6) | (in[i] & 0x3F);
}
if ((c < min) ||
((c >= 0xD800) && (c <= 0xDFFF)) ||
(c > 0x10FFFF)) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (c < 0x10000) {
if (out >= outend)
goto done;
out[0] = c & 0xFF;
out[1] = c >> 8;
out += 2;
} else {
if (outend - out < 4)
goto done;
c -= 0x10000;
d = (c & 0x03FF) | 0xDC00;
c = (c >> 10) | 0xD800;
out[0] = c & 0xFF;
out[1] = c >> 8;
out[2] = d & 0xFF;
out[3] = d >> 8;
out += 4;
}
in += len;
}
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
static xmlCharEncError
UTF8ToUTF16(void *vctxt,
unsigned char* outb, int *outlen,
const unsigned char* in, int *inlen,
int flush) {
if (in == NULL) {
/*
* initialization, add the Byte Order Mark for UTF-16LE
*/
if (*outlen >= 2) {
outb[0] = 0xFF;
outb[1] = 0xFE;
*outlen = 2;
*inlen = 0;
return(2);
}
*outlen = 0;
*inlen = 0;
return(0);
}
return (UTF8ToUTF16LE(vctxt, outb, outlen, in, inlen, flush));
}
#endif /* LIBXML_OUTPUT_ENABLED */
static xmlCharEncError
UTF16BEToUTF8(void *vctxt ATTRIBUTE_UNUSED,
unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char *instart = in;
const unsigned char *inend = in + (*inlen & ~1);
unsigned char *outstart = out;
unsigned char *outend = out + *outlen;
unsigned c, d;
int ret = XML_ENC_ERR_SPACE;
while (in < inend) {
c = (in[0] << 8) | in[1];
if (c < 0x80) {
if (out >= outend)
goto done;
out[0] = c;
in += 2;
out += 1;
} else if (c < 0x800) {
if (outend - out < 2)
goto done;
out[0] = (c >> 6) | 0xC0;
out[1] = (c & 0x3F) | 0x80;
in += 2;
out += 2;
} else if ((c & 0xF800) != 0xD800) {
if (outend - out < 3)
goto done;
out[0] = (c >> 12) | 0xE0;
out[1] = ((c >> 6) & 0x3F) | 0x80;
out[2] = (c & 0x3F) | 0x80;
in += 2;
out += 3;
} else {
/* Surrogate pair */
if ((c & 0xFC00) != 0xD800) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (inend - in < 4)
break;
d = (in[2] << 8) | in[3];
if ((d & 0xFC00) != 0xDC00) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (outend - out < 4)
goto done;
c = (c << 10) + d - ((0xD800 << 10) + 0xDC00 - 0x10000);
out[0] = (c >> 18) | 0xF0;
out[1] = ((c >> 12) & 0x3F) | 0x80;
out[2] = ((c >> 6) & 0x3F) | 0x80;
out[3] = (c & 0x3F) | 0x80;
in += 4;
out += 4;
}
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
#ifdef LIBXML_OUTPUT_ENABLED
static xmlCharEncError
UTF8ToUTF16BE(void *vctxt ATTRIBUTE_UNUSED,
unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char *instart = in;
const unsigned char *inend;
unsigned char *outstart = out;
unsigned char *outend;
unsigned c, d;
int ret = XML_ENC_ERR_SPACE;
/* UTF-16BE has no BOM */
if ((out == NULL) || (outlen == NULL) || (inlen == NULL)) return(-1);
if (in == NULL) {
*outlen = 0;
*inlen = 0;
return(0);
}
inend = in + *inlen;
outend = out + (*outlen & ~1);
while (in < inend) {
c = in[0];
if (c < 0x80) {
if (out >= outend)
goto done;
out[0] = 0;
out[1] = c;
in += 1;
out += 2;
} else {
int i, len;
unsigned min;
if (c < 0xE0) {
if (c < 0xC2) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
c &= 0x1F;
len = 2;
min = 0x80;
} else if (c < 0xF0) {
c &= 0x0F;
len = 3;
min = 0x800;
} else {
c &= 0x0F;
len = 4;
min = 0x10000;
}
if (inend - in < len)
break;
for (i = 1; i < len; i++) {
if ((in[i] & 0xC0) != 0x80) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
c = (c << 6) | (in[i] & 0x3F);
}
if ((c < min) ||
((c >= 0xD800) && (c <= 0xDFFF)) ||
(c > 0x10FFFF)) {
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (c < 0x10000) {
if (out >= outend)
goto done;
out[0] = c >> 8;
out[1] = c & 0xFF;
out += 2;
} else {
if (outend - out < 4)
goto done;
c -= 0x10000;
d = (c & 0x03FF) | 0xDC00;
c = (c >> 10) | 0xD800;
out[0] = c >> 8;
out[1] = c & 0xFF;
out[2] = d >> 8;
out[3] = d & 0xFF;
out += 4;
}
in += len;
}
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
#endif /* LIBXML_OUTPUT_ENABLED */
#if defined(LIBXML_OUTPUT_ENABLED) && defined(LIBXML_HTML_ENABLED)
static xmlCharEncError
UTF8ToHtmlWrapper(void *vctxt ATTRIBUTE_UNUSED,
unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
return(htmlUTF8ToHtml(out, outlen, in, inlen));
}
#endif
static xmlCharEncError
Utf8ToEightBit(void *vctxt,
unsigned char *out, int *outlen,
const unsigned char *in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
const unsigned char *xlattable = vctxt;
const unsigned char *instart = in;
const unsigned char *inend;
unsigned char *outstart = out;
unsigned char *outend;
int ret = XML_ENC_ERR_SPACE;
if (in == NULL) {
/*
* initialization nothing to do
*/
*outlen = 0;
*inlen = 0;
return(XML_ENC_ERR_SUCCESS);
}
inend = in + *inlen;
outend = out + *outlen;
while (in < inend) {
unsigned d = *in;
if (d < 0x80) {
if (out >= outend)
goto done;
in += 1;
} else if (d < 0xE0) {
unsigned c;
if (inend - in < 2)
break;
c = in[1] & 0x3F;
d = d & 0x1F;
d = xlattable [48 + c + xlattable [d] * 64];
if (d == 0) {
/* not in character set */
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (out >= outend)
goto done;
in += 2;
} else if (d < 0xF0) {
unsigned c1;
unsigned c2;
if (inend - in < 3)
break;
c1 = in[1] & 0x3F;
c2 = in[2] & 0x3F;
d = d & 0x0F;
d = xlattable [48 + c2 + xlattable [48 + c1 +
xlattable [32 + d] * 64] * 64];
if (d == 0) {
/* not in character set */
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (out >= outend)
goto done;
in += 3;
} else {
/* cannot transcode >= U+010000 */
ret = XML_ENC_ERR_INPUT;
goto done;
}
*out++ = d;
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}
static xmlCharEncError
EightBitToUtf8(void *vctxt,
unsigned char* out, int *outlen,
const unsigned char* in, int *inlen,
int flush ATTRIBUTE_UNUSED) {
unsigned short const *unicodetable = vctxt;
const unsigned char* instart = in;
const unsigned char* inend;
unsigned char* outstart = out;
unsigned char* outend;
int ret = XML_ENC_ERR_SPACE;
outend = out + *outlen;
inend = in + *inlen;
while (in < inend) {
unsigned c = *in;
if (c < 0x80) {
if (out >= outend)
goto done;
*out++ = c;
} else {
c = unicodetable[c - 0x80];
if (c == 0) {
/* undefined code point */
ret = XML_ENC_ERR_INPUT;
goto done;
}
if (c < 0x800) {
if (outend - out < 2)
goto done;
*out++ = ((c >> 6) & 0x1F) | 0xC0;
*out++ = (c & 0x3F) | 0x80;
} else {
if (outend - out < 3)
goto done;
*out++ = ((c >> 12) & 0x0F) | 0xE0;
*out++ = ((c >> 6) & 0x3F) | 0x80;
*out++ = (c & 0x3F) | 0x80;
}
}
in += 1;
}
ret = out - outstart;
done:
*outlen = out - outstart;
*inlen = in - instart;
return(ret);
}