1
0
mirror of https://gitlab.gnome.org/GNOME/libxml2.git synced 2024-12-24 21:33:51 +03:00
libxml2/entities.c

978 lines
25 KiB
C
Raw Normal View History

2001-02-23 20:55:21 +03:00
/*
* entities.c : implementation for the XML entities handling
2001-02-23 20:55:21 +03:00
*
* See Copyright for the status of this software.
*
* daniel@veillard.com
2001-02-23 20:55:21 +03:00
*/
/* To avoid EBCDIC trouble when parsing on zOS */
#if defined(__MVS__)
#pragma convert("ISO8859-1")
#endif
#define IN_LIBXML
2001-04-21 20:57:29 +04:00
#include "libxml.h"
2001-02-23 20:55:21 +03:00
#include <string.h>
#include <stdlib.h>
2001-02-23 20:55:21 +03:00
#include <libxml/xmlmemory.h>
#include <libxml/hash.h>
#include <libxml/entities.h>
#include <libxml/parser.h>
#include <libxml/parserInternals.h>
2001-02-23 20:55:21 +03:00
#include <libxml/xmlerror.h>
#include <libxml/dict.h>
#include <libxml/xmlsave.h>
2001-02-23 20:55:21 +03:00
#include "private/entities.h"
#include "private/error.h"
2001-02-23 20:55:21 +03:00
/*
* The XML predefined entities.
*/
static xmlEntity xmlEntityLt = {
NULL, XML_ENTITY_DECL, BAD_CAST "lt",
NULL, NULL, NULL, NULL, NULL, NULL,
BAD_CAST "<", BAD_CAST "<", 1,
XML_INTERNAL_PREDEFINED_ENTITY,
NULL, NULL, NULL, NULL, 0, 0, 0
2001-02-23 20:55:21 +03:00
};
static xmlEntity xmlEntityGt = {
NULL, XML_ENTITY_DECL, BAD_CAST "gt",
NULL, NULL, NULL, NULL, NULL, NULL,
BAD_CAST ">", BAD_CAST ">", 1,
XML_INTERNAL_PREDEFINED_ENTITY,
NULL, NULL, NULL, NULL, 0, 0, 0
};
static xmlEntity xmlEntityAmp = {
NULL, XML_ENTITY_DECL, BAD_CAST "amp",
NULL, NULL, NULL, NULL, NULL, NULL,
BAD_CAST "&", BAD_CAST "&", 1,
XML_INTERNAL_PREDEFINED_ENTITY,
NULL, NULL, NULL, NULL, 0, 0, 0
};
static xmlEntity xmlEntityQuot = {
NULL, XML_ENTITY_DECL, BAD_CAST "quot",
NULL, NULL, NULL, NULL, NULL, NULL,
BAD_CAST "\"", BAD_CAST "\"", 1,
XML_INTERNAL_PREDEFINED_ENTITY,
NULL, NULL, NULL, NULL, 0, 0, 0
};
static xmlEntity xmlEntityApos = {
NULL, XML_ENTITY_DECL, BAD_CAST "apos",
NULL, NULL, NULL, NULL, NULL, NULL,
BAD_CAST "'", BAD_CAST "'", 1,
XML_INTERNAL_PREDEFINED_ENTITY,
NULL, NULL, NULL, NULL, 0, 0, 0
2001-02-23 20:55:21 +03:00
};
/*
2024-05-20 14:58:22 +03:00
* xmlFreeEntity:
* @entity: an entity
*
* Frees the entity.
2001-02-23 20:55:21 +03:00
*/
2023-10-06 11:43:38 +03:00
void
xmlFreeEntity(xmlEntityPtr entity)
{
xmlDictPtr dict = NULL;
if (entity == NULL)
return;
if (entity->doc != NULL)
dict = entity->doc->dict;
2001-02-23 20:55:21 +03:00
if ((entity->children) &&
(entity == (xmlEntityPtr) entity->children->parent))
xmlFreeNodeList(entity->children);
if ((entity->name != NULL) &&
((dict == NULL) || (!xmlDictOwns(dict, entity->name))))
xmlFree((char *) entity->name);
if (entity->ExternalID != NULL)
xmlFree((char *) entity->ExternalID);
if (entity->SystemID != NULL)
xmlFree((char *) entity->SystemID);
if (entity->URI != NULL)
xmlFree((char *) entity->URI);
if (entity->content != NULL)
xmlFree((char *) entity->content);
if (entity->orig != NULL)
xmlFree((char *) entity->orig);
2001-02-23 20:55:21 +03:00
xmlFree(entity);
}
/*
* xmlCreateEntity:
*
2019-09-30 18:04:54 +03:00
* internal routine doing the entity node structures allocations
2001-02-23 20:55:21 +03:00
*/
static xmlEntityPtr
xmlCreateEntity(xmlDocPtr doc, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
2001-02-23 20:55:21 +03:00
xmlEntityPtr ret;
ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (ret == NULL)
2001-02-23 20:55:21 +03:00
return(NULL);
memset(ret, 0, sizeof(xmlEntity));
ret->doc = doc;
2001-02-23 20:55:21 +03:00
ret->type = XML_ENTITY_DECL;
/*
* fill the structure.
*/
ret->etype = (xmlEntityType) type;
if ((doc == NULL) || (doc->dict == NULL))
ret->name = xmlStrdup(name);
else
ret->name = xmlDictLookup(doc->dict, name, -1);
if (ret->name == NULL)
goto error;
if (ExternalID != NULL) {
ret->ExternalID = xmlStrdup(ExternalID);
if (ret->ExternalID == NULL)
goto error;
}
if (SystemID != NULL) {
ret->SystemID = xmlStrdup(SystemID);
if (ret->SystemID == NULL)
goto error;
}
2001-02-23 20:55:21 +03:00
if (content != NULL) {
ret->length = xmlStrlen(content);
ret->content = xmlStrndup(content, ret->length);
if (ret->content == NULL)
goto error;
2001-02-23 20:55:21 +03:00
} else {
ret->length = 0;
ret->content = NULL;
}
ret->URI = NULL; /* to be computed by the layer knowing
the defining entity */
ret->orig = NULL;
return(ret);
error:
xmlFreeEntity(ret);
return(NULL);
}
/**
* xmlAddEntity:
* @doc: the document
* @extSubset: add to the external or internal subset
* @name: the entity name
* @type: the entity type XML_xxx_yyy_ENTITY
* @ExternalID: the entity external ID if available
* @SystemID: the entity system ID if available
* @content: the entity content
* @out: pointer to resulting entity (optional)
*
* Register a new entity for this document.
*
2024-05-20 14:58:22 +03:00
* Available since 2.13.0.
*
* Returns an xmlParserErrors error code.
*/
int
xmlAddEntity(xmlDocPtr doc, int extSubset, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content, xmlEntityPtr *out) {
xmlDtdPtr dtd;
xmlDictPtr dict = NULL;
xmlEntitiesTablePtr table = NULL;
xmlEntityPtr ret, predef;
int res;
if (out != NULL)
*out = NULL;
if ((doc == NULL) || (name == NULL))
return(XML_ERR_ARGUMENT);
dict = doc->dict;
if (extSubset)
dtd = doc->extSubset;
else
dtd = doc->intSubset;
if (dtd == NULL)
return(XML_DTD_NO_DTD);
switch (type) {
case XML_INTERNAL_GENERAL_ENTITY:
case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
predef = xmlGetPredefinedEntity(name);
if (predef != NULL) {
int valid = 0;
/* 4.6 Predefined Entities */
if ((type == XML_INTERNAL_GENERAL_ENTITY) &&
(content != NULL)) {
int c = predef->content[0];
if (((content[0] == c) && (content[1] == 0)) &&
((c == '>') || (c == '\'') || (c == '"'))) {
valid = 1;
} else if ((content[0] == '&') && (content[1] == '#')) {
if (content[2] == 'x') {
xmlChar *hex = BAD_CAST "0123456789ABCDEF";
xmlChar ref[] = "00;";
ref[0] = hex[c / 16 % 16];
ref[1] = hex[c % 16];
if (xmlStrcasecmp(&content[3], ref) == 0)
valid = 1;
} else {
xmlChar ref[] = "00;";
ref[0] = '0' + c / 10 % 10;
ref[1] = '0' + c % 10;
if (xmlStrEqual(&content[2], ref))
valid = 1;
}
}
}
if (!valid)
return(XML_ERR_REDECL_PREDEF_ENTITY);
}
if (dtd->entities == NULL) {
dtd->entities = xmlHashCreateDict(0, dict);
if (dtd->entities == NULL)
return(XML_ERR_NO_MEMORY);
}
table = dtd->entities;
break;
case XML_INTERNAL_PARAMETER_ENTITY:
case XML_EXTERNAL_PARAMETER_ENTITY:
if (dtd->pentities == NULL) {
dtd->pentities = xmlHashCreateDict(0, dict);
if (dtd->pentities == NULL)
return(XML_ERR_NO_MEMORY);
}
table = dtd->pentities;
break;
default:
return(XML_ERR_ARGUMENT);
}
ret = xmlCreateEntity(dtd->doc, name, type, ExternalID, SystemID, content);
if (ret == NULL)
return(XML_ERR_NO_MEMORY);
2001-02-23 20:55:21 +03:00
res = xmlHashAdd(table, name, ret);
if (res < 0) {
xmlFreeEntity(ret);
return(XML_ERR_NO_MEMORY);
} else if (res == 0) {
2001-02-23 20:55:21 +03:00
/*
* entity was already defined at another level.
*/
xmlFreeEntity(ret);
return(XML_WAR_ENTITY_REDEFINED);
2001-02-23 20:55:21 +03:00
}
/*
* Link it to the DTD
*/
ret->parent = dtd;
ret->doc = dtd->doc;
if (dtd->last == NULL) {
dtd->children = dtd->last = (xmlNodePtr) ret;
} else {
dtd->last->next = (xmlNodePtr) ret;
ret->prev = dtd->last;
dtd->last = (xmlNodePtr) ret;
}
if (out != NULL)
*out = ret;
return(0);
2001-02-23 20:55:21 +03:00
}
/**
* xmlGetPredefinedEntity:
* @name: the entity name
*
* Check whether this name is an predefined entity.
*
* Returns NULL if not, otherwise the entity
2001-02-23 20:55:21 +03:00
*/
xmlEntityPtr
xmlGetPredefinedEntity(const xmlChar *name) {
if (name == NULL) return(NULL);
switch (name[0]) {
case 'l':
if (xmlStrEqual(name, BAD_CAST "lt"))
return(&xmlEntityLt);
break;
case 'g':
if (xmlStrEqual(name, BAD_CAST "gt"))
return(&xmlEntityGt);
break;
case 'a':
if (xmlStrEqual(name, BAD_CAST "amp"))
return(&xmlEntityAmp);
if (xmlStrEqual(name, BAD_CAST "apos"))
return(&xmlEntityApos);
break;
case 'q':
if (xmlStrEqual(name, BAD_CAST "quot"))
return(&xmlEntityQuot);
break;
default:
break;
}
return(NULL);
2001-02-23 20:55:21 +03:00
}
/**
* xmlAddDtdEntity:
* @doc: the document
* @name: the entity name
* @type: the entity type XML_xxx_yyy_ENTITY
* @ExternalID: the entity external ID if available
* @SystemID: the entity system ID if available
* @content: the entity content
*
* Register a new entity for this document DTD external subset.
*
* Returns a pointer to the entity or NULL in case of error
*/
xmlEntityPtr
xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
xmlEntityPtr ret;
xmlAddEntity(doc, 1, name, type, ExternalID, SystemID, content, &ret);
2001-02-23 20:55:21 +03:00
return(ret);
}
/**
* xmlAddDocEntity:
* @doc: the document
* @name: the entity name
* @type: the entity type XML_xxx_yyy_ENTITY
* @ExternalID: the entity external ID if available
* @SystemID: the entity system ID if available
* @content: the entity content
*
* Register a new entity for this document.
*
* Returns a pointer to the entity or NULL in case of error
*/
xmlEntityPtr
xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
xmlEntityPtr ret;
xmlAddEntity(doc, 0, name, type, ExternalID, SystemID, content, &ret);
2001-02-23 20:55:21 +03:00
return(ret);
}
/**
* xmlNewEntity:
* @doc: the document
* @name: the entity name
* @type: the entity type XML_xxx_yyy_ENTITY
* @ExternalID: the entity external ID if available
* @SystemID: the entity system ID if available
* @content: the entity content
*
* Create a new entity, this differs from xmlAddDocEntity() that if
* the document is NULL or has no internal subset defined, then an
2019-09-30 18:04:54 +03:00
* unlinked entity structure will be returned, it is then the responsibility
* of the caller to link it to the document later or free it when not needed
* anymore.
*
* Returns a pointer to the entity or NULL in case of error
*/
xmlEntityPtr
xmlNewEntity(xmlDocPtr doc, const xmlChar *name, int type,
const xmlChar *ExternalID, const xmlChar *SystemID,
const xmlChar *content) {
if ((doc != NULL) && (doc->intSubset != NULL)) {
return(xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content));
}
if (name == NULL)
return(NULL);
return(xmlCreateEntity(doc, name, type, ExternalID, SystemID, content));
}
2001-02-23 20:55:21 +03:00
/**
* xmlGetEntityFromTable:
* @table: an entity table
* @name: the entity name
* @parameter: look for parameter entities
*
* Do an entity lookup in the table.
* returns the corresponding parameter entity, if found.
*
2001-02-23 20:55:21 +03:00
* Returns A pointer to the entity structure or NULL if not found.
*/
static xmlEntityPtr
2001-02-23 20:55:21 +03:00
xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
return((xmlEntityPtr) xmlHashLookup(table, name));
}
/**
* xmlGetParameterEntity:
* @doc: the document referencing the entity
* @name: the entity name
*
* Do an entity lookup in the internal and external subsets and
* returns the corresponding parameter entity, if found.
*
2001-02-23 20:55:21 +03:00
* Returns A pointer to the entity structure or NULL if not found.
*/
xmlEntityPtr
xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
xmlEntitiesTablePtr table;
xmlEntityPtr ret;
if (doc == NULL)
return(NULL);
2001-02-23 20:55:21 +03:00
if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
ret = xmlGetEntityFromTable(table, name);
if (ret != NULL)
return(ret);
}
if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
return(xmlGetEntityFromTable(table, name));
}
return(NULL);
}
/**
* xmlGetDtdEntity:
* @doc: the document referencing the entity
* @name: the entity name
*
* Do an entity lookup in the DTD entity hash table and
2001-02-23 20:55:21 +03:00
* returns the corresponding entity, if found.
* Note: the first argument is the document node, not the DTD node.
*
2001-02-23 20:55:21 +03:00
* Returns A pointer to the entity structure or NULL if not found.
*/
xmlEntityPtr
xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
xmlEntitiesTablePtr table;
if (doc == NULL)
return(NULL);
2001-02-23 20:55:21 +03:00
if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities;
return(xmlGetEntityFromTable(table, name));
}
return(NULL);
}
/**
* xmlGetDocEntity:
* @doc: the document referencing the entity
* @name: the entity name
*
* Do an entity lookup in the document entity hash table and
* returns the corresponding entity, otherwise a lookup is done
2001-02-23 20:55:21 +03:00
* in the predefined entities too.
*
2001-02-23 20:55:21 +03:00
* Returns A pointer to the entity structure or NULL if not found.
*/
xmlEntityPtr
xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
2001-02-23 20:55:21 +03:00
xmlEntityPtr cur;
xmlEntitiesTablePtr table;
if (doc != NULL) {
if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->intSubset->entities;
cur = xmlGetEntityFromTable(table, name);
if (cur != NULL)
return(cur);
}
if (doc->standalone != 1) {
if ((doc->extSubset != NULL) &&
(doc->extSubset->entities != NULL)) {
table = (xmlEntitiesTablePtr) doc->extSubset->entities;
cur = xmlGetEntityFromTable(table, name);
if (cur != NULL)
return(cur);
}
2001-02-23 20:55:21 +03:00
}
}
return(xmlGetPredefinedEntity(name));
2001-02-23 20:55:21 +03:00
}
/*
* Macro used to grow the current buffer.
*/
#define growBufferReentrant() { \
xmlChar *tmp; \
2012-07-20 11:41:34 +04:00
size_t new_size = buffer_size * 2; \
if (new_size < buffer_size) goto mem_error; \
tmp = (xmlChar *) xmlRealloc(buffer, new_size); \
if (tmp == NULL) goto mem_error; \
buffer = tmp; \
buffer_size = new_size; \
2001-02-23 20:55:21 +03:00
}
/**
* xmlEncodeEntitiesInternal:
2001-02-23 20:55:21 +03:00
* @doc: the document containing the string
* @input: A string to convert to XML.
2019-09-30 18:04:54 +03:00
* @attr: are we handling an attribute value
2001-02-23 20:55:21 +03:00
*
* Do a global encoding of a string, replacing the predefined entities
* and non ASCII values with their entities and CharRef counterparts.
* Contrary to xmlEncodeEntities, this routine is reentrant, and result
* must be deallocated.
*
* Returns A newly allocated string with the substitution done.
*/
static xmlChar *
xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
2001-02-23 20:55:21 +03:00
const xmlChar *cur = input;
xmlChar *buffer = NULL;
xmlChar *out = NULL;
size_t buffer_size = 0;
2001-02-23 20:55:21 +03:00
int html = 0;
if (input == NULL) return(NULL);
if (doc != NULL)
html = (doc->type == XML_HTML_DOCUMENT_NODE);
/*
* allocate an translation buffer.
*/
buffer_size = 1000;
buffer = (xmlChar *) xmlMalloc(buffer_size);
if (buffer == NULL)
2001-02-23 20:55:21 +03:00
return(NULL);
out = buffer;
while (*cur != '\0') {
size_t indx = out - buffer;
if (indx + 100 > buffer_size) {
2001-02-23 20:55:21 +03:00
growBufferReentrant();
out = &buffer[indx];
2001-02-23 20:55:21 +03:00
}
/*
* By default one have to encode at least '<', '>', '"' and '&' !
*/
if (*cur == '<') {
const xmlChar *end;
/*
* Special handling of server side include in HTML attributes
*/
if (html && attr &&
(cur[1] == '!') && (cur[2] == '-') && (cur[3] == '-') &&
((end = xmlStrstr(cur, BAD_CAST "-->")) != NULL)) {
while (cur != end) {
*out++ = *cur++;
indx = out - buffer;
if (indx + 100 > buffer_size) {
growBufferReentrant();
out = &buffer[indx];
}
}
*out++ = *cur++;
*out++ = *cur++;
*out++ = *cur++;
continue;
}
2001-02-23 20:55:21 +03:00
*out++ = '&';
*out++ = 'l';
*out++ = 't';
*out++ = ';';
} else if (*cur == '>') {
*out++ = '&';
*out++ = 'g';
*out++ = 't';
*out++ = ';';
} else if (*cur == '&') {
/*
* Special handling of &{...} construct from HTML 4, see
* http://www.w3.org/TR/html401/appendix/notes.html#h-B.7.1
*/
if (html && attr && (cur[1] == '{') &&
(strchr((const char *) cur, '}'))) {
while (*cur != '}') {
*out++ = *cur++;
indx = out - buffer;
if (indx + 100 > buffer_size) {
growBufferReentrant();
out = &buffer[indx];
}
}
*out++ = *cur++;
continue;
}
2001-02-23 20:55:21 +03:00
*out++ = '&';
*out++ = 'a';
*out++ = 'm';
*out++ = 'p';
*out++ = ';';
} else if (((*cur >= 0x20) && (*cur < 0x80)) ||
(*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) {
2001-02-23 20:55:21 +03:00
/*
* default case, just copy !
*/
*out++ = *cur;
} else if (*cur >= 0x80) {
if (((doc != NULL) && (doc->encoding != NULL)) || (html)) {
2001-02-23 20:55:21 +03:00
/*
* Bjørn Reese <br@sseusa.com> provided the patch
2001-02-23 20:55:21 +03:00
xmlChar xc;
xc = (*cur & 0x3F) << 6;
if (cur[1] != 0) {
xc += *(++cur) & 0x3F;
*out++ = xc;
} else
*/
*out++ = *cur;
2001-02-23 20:55:21 +03:00
} else {
/*
* We assume we have UTF-8 input.
* It must match either:
* 110xxxxx 10xxxxxx
* 1110xxxx 10xxxxxx 10xxxxxx
* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
* That is:
* cur[0] is 11xxxxxx
* cur[1] is 10xxxxxx
* cur[2] is 10xxxxxx if cur[0] is 111xxxxx
* cur[3] is 10xxxxxx if cur[0] is 1111xxxx
* cur[0] is not 11111xxx
2001-02-23 20:55:21 +03:00
*/
char buf[13], *ptr;
int val, l;
l = 4;
val = xmlGetUTF8Char(cur, &l);
if (val < 0) {
val = 0xFFFD;
cur++;
} else {
if (!IS_CHAR(val))
val = 0xFFFD;
cur += l;
2001-02-23 20:55:21 +03:00
}
/*
* We could do multiple things here. Just save as a char ref
*/
snprintf(buf, sizeof(buf), "&#x%X;", val);
2001-02-23 20:55:21 +03:00
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
continue;
}
} else if (IS_BYTE_CHAR(*cur)) {
char buf[11], *ptr;
2001-02-23 20:55:21 +03:00
snprintf(buf, sizeof(buf), "&#%d;", *cur);
buf[sizeof(buf) - 1] = 0;
ptr = buf;
while (*ptr != 0) *out++ = *ptr++;
}
cur++;
}
*out = 0;
2001-02-23 20:55:21 +03:00
return(buffer);
mem_error:
xmlFree(buffer);
return(NULL);
2001-02-23 20:55:21 +03:00
}
/**
* xmlEncodeAttributeEntities:
* @doc: the document containing the string
* @input: A string to convert to XML.
*
* Do a global encoding of a string, replacing the predefined entities
* and non ASCII values with their entities and CharRef counterparts for
* attribute values.
*
* Returns A newly allocated string with the substitution done.
*/
xmlChar *
xmlEncodeAttributeEntities(xmlDocPtr doc, const xmlChar *input) {
return xmlEncodeEntitiesInternal(doc, input, 1);
}
/**
* xmlEncodeEntitiesReentrant:
* @doc: the document containing the string
* @input: A string to convert to XML.
*
* Do a global encoding of a string, replacing the predefined entities
* and non ASCII values with their entities and CharRef counterparts.
* Contrary to xmlEncodeEntities, this routine is reentrant, and result
* must be deallocated.
*
* Returns A newly allocated string with the substitution done.
*/
xmlChar *
xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
return xmlEncodeEntitiesInternal(doc, input, 0);
}
2001-02-23 20:55:21 +03:00
/**
* xmlEncodeSpecialChars:
* @doc: the document containing the string
* @input: A string to convert to XML.
*
* Do a global encoding of a string, replacing the predefined entities
* this routine is reentrant, and result must be deallocated.
*
* Returns A newly allocated string with the substitution done.
*/
xmlChar *
xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) {
2001-02-23 20:55:21 +03:00
const xmlChar *cur = input;
xmlChar *buffer = NULL;
xmlChar *out = NULL;
size_t buffer_size = 0;
if (input == NULL) return(NULL);
2001-02-23 20:55:21 +03:00
/*
* allocate an translation buffer.
*/
buffer_size = 1000;
buffer = (xmlChar *) xmlMalloc(buffer_size);
if (buffer == NULL)
2001-02-23 20:55:21 +03:00
return(NULL);
out = buffer;
while (*cur != '\0') {
size_t indx = out - buffer;
if (indx + 10 > buffer_size) {
2001-02-23 20:55:21 +03:00
growBufferReentrant();
out = &buffer[indx];
2001-02-23 20:55:21 +03:00
}
/*
* By default one have to encode at least '<', '>', '"' and '&' !
*/
if (*cur == '<') {
*out++ = '&';
*out++ = 'l';
*out++ = 't';
*out++ = ';';
} else if (*cur == '>') {
*out++ = '&';
*out++ = 'g';
*out++ = 't';
*out++ = ';';
} else if (*cur == '&') {
*out++ = '&';
*out++ = 'a';
*out++ = 'm';
*out++ = 'p';
*out++ = ';';
} else if (*cur == '"') {
*out++ = '&';
*out++ = 'q';
*out++ = 'u';
*out++ = 'o';
*out++ = 't';
*out++ = ';';
} else if (*cur == '\r') {
*out++ = '&';
*out++ = '#';
*out++ = '1';
*out++ = '3';
*out++ = ';';
2001-02-23 20:55:21 +03:00
} else {
/*
* Works because on UTF-8, all extended sequences cannot
* result in bytes in the ASCII range.
*/
*out++ = *cur;
}
cur++;
}
*out = 0;
2001-02-23 20:55:21 +03:00
return(buffer);
mem_error:
xmlFree(buffer);
return(NULL);
2001-02-23 20:55:21 +03:00
}
/**
* xmlCreateEntitiesTable:
*
* create and initialize an empty entities hash table.
* This really doesn't make sense and should be deprecated
2001-02-23 20:55:21 +03:00
*
* Returns the xmlEntitiesTablePtr just created or NULL in case of error.
*/
xmlEntitiesTablePtr
xmlCreateEntitiesTable(void) {
return((xmlEntitiesTablePtr) xmlHashCreate(0));
}
/**
* xmlFreeEntityWrapper:
* @entity: An entity
* @name: its name
*
* Deallocate the memory used by an entities in the hash table.
*/
static void
xmlFreeEntityWrapper(void *entity, const xmlChar *name ATTRIBUTE_UNUSED) {
if (entity != NULL)
xmlFreeEntity((xmlEntityPtr) entity);
}
2001-02-23 20:55:21 +03:00
/**
* xmlFreeEntitiesTable:
* @table: An entity table
*
* Deallocate the memory used by an entities hash table.
*/
void
xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
xmlHashFree(table, xmlFreeEntityWrapper);
2001-02-23 20:55:21 +03:00
}
/**
* xmlCopyEntity:
* @ent: An entity
*
* Build a copy of an entity
*
2001-02-23 20:55:21 +03:00
* Returns the new xmlEntitiesPtr or NULL in case of error.
*/
static void *
xmlCopyEntity(void *payload, const xmlChar *name ATTRIBUTE_UNUSED) {
xmlEntityPtr ent = (xmlEntityPtr) payload;
2001-02-23 20:55:21 +03:00
xmlEntityPtr cur;
cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
if (cur == NULL)
2001-02-23 20:55:21 +03:00
return(NULL);
memset(cur, 0, sizeof(xmlEntity));
cur->type = XML_ENTITY_DECL;
2001-02-23 20:55:21 +03:00
cur->etype = ent->etype;
if (ent->name != NULL) {
2001-02-23 20:55:21 +03:00
cur->name = xmlStrdup(ent->name);
if (cur->name == NULL)
goto error;
}
if (ent->ExternalID != NULL) {
2001-02-23 20:55:21 +03:00
cur->ExternalID = xmlStrdup(ent->ExternalID);
if (cur->ExternalID == NULL)
goto error;
}
if (ent->SystemID != NULL) {
2001-02-23 20:55:21 +03:00
cur->SystemID = xmlStrdup(ent->SystemID);
if (cur->SystemID == NULL)
goto error;
}
if (ent->content != NULL) {
2001-02-23 20:55:21 +03:00
cur->content = xmlStrdup(ent->content);
if (cur->content == NULL)
goto error;
}
if (ent->orig != NULL) {
2001-02-23 20:55:21 +03:00
cur->orig = xmlStrdup(ent->orig);
if (cur->orig == NULL)
goto error;
}
if (ent->URI != NULL) {
cur->URI = xmlStrdup(ent->URI);
if (cur->URI == NULL)
goto error;
}
2001-02-23 20:55:21 +03:00
return(cur);
error:
xmlFreeEntity(cur);
return(NULL);
2001-02-23 20:55:21 +03:00
}
/**
* xmlCopyEntitiesTable:
* @table: An entity table
*
* Build a copy of an entity table.
*
2001-02-23 20:55:21 +03:00
* Returns the new xmlEntitiesTablePtr or NULL in case of error.
*/
xmlEntitiesTablePtr
xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
return(xmlHashCopySafe(table, xmlCopyEntity, xmlFreeEntityWrapper));
2001-02-23 20:55:21 +03:00
}
#ifdef LIBXML_OUTPUT_ENABLED
2001-02-23 20:55:21 +03:00
/**
* xmlDumpEntityDecl:
* @buf: An XML buffer.
* @ent: An entity table
*
* This will dump the content of the entity table as an XML DTD definition
*/
void
xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
xmlSaveCtxtPtr save;
if ((buf == NULL) || (ent == NULL))
return;
save = xmlSaveToBuffer(buf, NULL, 0);
xmlSaveTree(save, (xmlNodePtr) ent);
if (xmlSaveFinish(save) != XML_ERR_OK)
xmlFree(xmlBufferDetach(buf));
2001-02-23 20:55:21 +03:00
}
/**
* xmlDumpEntityDeclScan:
* @ent: An entity table
* @buf: An XML buffer.
*
* When using the hash table scan function, arguments need to be reversed
*/
static void
xmlDumpEntityDeclScan(void *ent, void *save,
const xmlChar *name ATTRIBUTE_UNUSED) {
xmlSaveTree(save, ent);
}
2001-02-23 20:55:21 +03:00
/**
* xmlDumpEntitiesTable:
* @buf: An XML buffer.
* @table: An entity table
*
* This will dump the content of the entity table as an XML DTD definition
*/
void
xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
xmlSaveCtxtPtr save;
if ((buf == NULL) || (table == NULL))
return;
save = xmlSaveToBuffer(buf, NULL, 0);
xmlHashScan(table, xmlDumpEntityDeclScan, save);
if (xmlSaveFinish(save) != XML_ERR_OK)
xmlFree(xmlBufferDetach(buf));
2001-02-23 20:55:21 +03:00
}
#endif /* LIBXML_OUTPUT_ENABLED */