Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/entities.c

 /*
  * entities.c : implementation for the XML entities handling
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 #define IN_LIBXML
 #include "libxml.h"
 
 #include <string.h>
 #ifdef HAVE_STDLIB_H
 #include <stdlib.h>
 #endif
 #include <libxml/xmlmemory.h>
 #include <libxml/hash.h>
 #include <libxml/entities.h>
 #include <libxml/parser.h>
 #include <libxml/parserInternals.h>
 #include <libxml/xmlerror.h>
 #include <libxml/globals.h>
 #include <libxml/dict.h>
 
+#include "save.h"
+
 /*
  * The XML predefined entities.
  */
 
 static xmlEntity xmlEntityLt = {
     NULL, XML_ENTITY_DECL, BAD_CAST "lt",
-    NULL, NULL, NULL, NULL, NULL, NULL, 
+    NULL, NULL, NULL, NULL, NULL, NULL,
     BAD_CAST "<", BAD_CAST "<", 1,
     XML_INTERNAL_PREDEFINED_ENTITY,
     NULL, NULL, NULL, NULL, 0, 1
 };
 static xmlEntity xmlEntityGt = {
     NULL, XML_ENTITY_DECL, BAD_CAST "gt",
-    NULL, NULL, NULL, NULL, NULL, NULL, 
+    NULL, NULL, NULL, NULL, NULL, NULL,
     BAD_CAST ">", BAD_CAST ">", 1,
     XML_INTERNAL_PREDEFINED_ENTITY,
     NULL, NULL, NULL, NULL, 0, 1
 };
 static xmlEntity xmlEntityAmp = {
     NULL, XML_ENTITY_DECL, BAD_CAST "amp",
-    NULL, NULL, NULL, NULL, NULL, NULL, 
+    NULL, NULL, NULL, NULL, NULL, NULL,
     BAD_CAST "&", BAD_CAST "&", 1,
     XML_INTERNAL_PREDEFINED_ENTITY,
     NULL, NULL, NULL, NULL, 0, 1
 };
 static xmlEntity xmlEntityQuot = {
     NULL, XML_ENTITY_DECL, BAD_CAST "quot",
-    NULL, NULL, NULL, NULL, NULL, NULL, 
+    NULL, NULL, NULL, NULL, NULL, NULL,
     BAD_CAST "\"", BAD_CAST "\"", 1,
     XML_INTERNAL_PREDEFINED_ENTITY,
     NULL, NULL, NULL, NULL, 0, 1
 };
 static xmlEntity xmlEntityApos = {
     NULL, XML_ENTITY_DECL, BAD_CAST "apos",
-    NULL, NULL, NULL, NULL, NULL, NULL, 
+    NULL, NULL, NULL, NULL, NULL, NULL,
     BAD_CAST "'", BAD_CAST "'", 1,
     XML_INTERNAL_PREDEFINED_ENTITY,
     NULL, NULL, NULL, NULL, 0, 1
 };
 
 /**
  * xmlEntitiesErrMemory:
  * @extra:  extra informations
  *
  * Handle an out of memory condition
@@ skipping 349 matching lines @@
 }
 
 /**
  * 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.
- * 
+ *
  * Returns A pointer to the entity structure or NULL if not found.
  */
 static xmlEntityPtr
 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.
- * 
+ *
  * 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);
     if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
@@ skipping 10 matching lines @@
 }
 
 /**
  * xmlGetDtdEntity:
  * @doc:  the document referencing the entity
  * @name:  the entity name
  *
  * Do an entity lookup in the DTD entity hash table and
  * returns the corresponding entity, if found.
  * Note: the first argument is the document node, not the DTD node.
- * 
+ *
  * 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);
     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
  * in the predefined entities too.
- * 
+ *
  * Returns A pointer to the entity structure or NULL if not found.
  */
 xmlEntityPtr
-xmlGetDocEntity(xmlDocPtr doc, const xmlChar *name) {
+xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
     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);
             }
         }
     }
     return(xmlGetPredefinedEntity(name));
 }
 
 /*
  * Macro used to grow the current buffer.
  */
 #define growBufferReentrant() {                                         \
-    buffer_size *= 2;                                                   \
-    buffer = (xmlChar *)                                                \
-                xmlRealloc(buffer, buffer_size * sizeof(xmlChar));      \
-    if (buffer == NULL) {                                               \
-        xmlEntitiesErrMemory("xmlEncodeEntitiesReentrant: realloc failed");\
-        return(NULL);                                                   \
-    }                                                                   \
+    xmlChar *tmp;                                                       \
+    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;                                             \
 }
 
-
 /**
- * xmlEncodeEntitiesReentrant:
+ * xmlEncodeEntitiesInternal:
  * @doc:  the document containing the string
  * @input:  A string to convert to XML.
+ * @attr: are we handling an atrbute value
  *
  * 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) {
+static xmlChar *
+xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
     const xmlChar *cur = input;
     xmlChar *buffer = NULL;
     xmlChar *out = NULL;
-    int buffer_size = 0;
+    size_t buffer_size = 0;
     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 * sizeof(xmlChar));
     if (buffer == NULL) {
-        xmlEntitiesErrMemory("xmlEncodeEntitiesReentrant: malloc failed");
+        xmlEntitiesErrMemory("xmlEncodeEntities: malloc failed");
         return(NULL);
     }
     out = buffer;
 
     while (*cur != '\0') {
-        if (out - buffer > buffer_size - 100) {
-            int indx = out - buffer;
+        size_t indx = out - buffer;
+        if (indx + 100 > buffer_size) {
 
             growBufferReentrant();
             out = &buffer[indx];
         }
 
         /*
          * 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;
+            }
             *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;
+            }
             *out++ = '&';
             *out++ = 'a';
             *out++ = 'm';
             *out++ = 'p';
             *out++ = ';';
         } else if (((*cur >= 0x20) && (*cur < 0x80)) ||
             (*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) {
             /*
              * default case, just copy !
              */
@@ skipping 12 matching lines @@
                 *out++ = *cur;
             } else {
                 /*
                  * We assume we have UTF-8 input.
                  */
                 char buf[11], *ptr;
                 int val = 0, l = 1;
 
                 if (*cur < 0xC0) {
                     xmlEntitiesErr(XML_CHECK_NOT_UTF8,
-                            "xmlEncodeEntitiesReentrant : input not UTF-8");
+                            "xmlEncodeEntities: input not UTF-8");
                     if (doc != NULL)
                         doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
                     snprintf(buf, sizeof(buf), "&#%d;", *cur);
                     buf[sizeof(buf) - 1] = 0;
                     ptr = buf;
                     while (*ptr != 0) *out++ = *ptr++;
                     cur++;
                     continue;
                 } else if (*cur < 0xE0) {
                     val = (cur[0]) & 0x1F;
@@ skipping 12 matching lines @@
                     val <<= 6;
                     val |= (cur[1]) & 0x3F;
                     val <<= 6;
                     val |= (cur[2]) & 0x3F;
                     val <<= 6;
                     val |= (cur[3]) & 0x3F;
                     l = 4;
                 }
                 if ((l == 1) || (!IS_CHAR(val))) {
                     xmlEntitiesErr(XML_ERR_INVALID_CHAR,
-                        "xmlEncodeEntitiesReentrant : char out of range\n");
+                        "xmlEncodeEntities: char out of range\n");
                     if (doc != NULL)
                         doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
                     snprintf(buf, sizeof(buf), "&#%d;", *cur);
                     buf[sizeof(buf) - 1] = 0;
                     ptr = buf;
                     while (*ptr != 0) *out++ = *ptr++;
                     cur++;
                     continue;
                 }
                 /*
@@ skipping 11 matching lines @@
 
             snprintf(buf, sizeof(buf), "&#%d;", *cur);
             buf[sizeof(buf) - 1] = 0;
             ptr = buf;
             while (*ptr != 0) *out++ = *ptr++;
         }
         cur++;
     }
     *out = 0;
     return(buffer);
+
+mem_error:
+    xmlEntitiesErrMemory("xmlEncodeEntities: realloc failed");
+    xmlFree(buffer);
+    return(NULL);
 }
 
 /**
+ * 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);
+}
+
+/**
  * 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(xmlDocPtr doc ATTRIBUTE_UNUSED, const xmlChar *input) {
+xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) {
     const xmlChar *cur = input;
     xmlChar *buffer = NULL;
     xmlChar *out = NULL;
-    int buffer_size = 0;
+    size_t buffer_size = 0;
     if (input == NULL) return(NULL);
 
     /*
      * allocate an translation buffer.
      */
     buffer_size = 1000;
     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
     if (buffer == NULL) {
         xmlEntitiesErrMemory("xmlEncodeSpecialChars: malloc failed");
         return(NULL);
     }
     out = buffer;
 
     while (*cur != '\0') {
-        if (out - buffer > buffer_size - 10) {
-            int indx = out - buffer;
+        size_t indx = out - buffer;
+        if (indx + 10 > buffer_size) {
 
             growBufferReentrant();
             out = &buffer[indx];
         }
 
         /*
          * By default one have to encode at least '<', '>', '"' and '&' !
          */
         if (*cur == '<') {
             *out++ = '&';
@@ skipping 28 matching lines @@
             /*
              * Works because on UTF-8, all extended sequences cannot
              * result in bytes in the ASCII range.
              */
             *out++ = *cur;
         }
         cur++;
     }
     *out = 0;
     return(buffer);
+
+mem_error:
+    xmlEntitiesErrMemory("xmlEncodeSpecialChars: realloc failed");
+    xmlFree(buffer);
+    return(NULL);
 }
 
 /**
  * xmlCreateEntitiesTable:
  *
  * create and initialize an empty entities hash table.
  * This really doesn't make sense and should be deprecated
  *
  * Returns the xmlEntitiesTablePtr just created or NULL in case of error.
  */
@@ skipping 26 matching lines @@
 xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
     xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntityWrapper);
 }
 
 #ifdef LIBXML_TREE_ENABLED
 /**
  * xmlCopyEntity:
  * @ent:  An entity
  *
  * Build a copy of an entity
- * 
+ *
  * Returns the new xmlEntitiesPtr or NULL in case of error.
  */
 static xmlEntityPtr
 xmlCopyEntity(xmlEntityPtr ent) {
     xmlEntityPtr cur;
 
     cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
     if (cur == NULL) {
         xmlEntitiesErrMemory("xmlCopyEntity:: malloc failed");
         return(NULL);
@@ skipping 15 matching lines @@
     if (ent->URI != NULL)
         cur->URI = xmlStrdup(ent->URI);
     return(cur);
 }
 
 /**
  * xmlCopyEntitiesTable:
  * @table:  An entity table
  *
  * Build a copy of an entity table.
- * 
+ *
  * Returns the new xmlEntitiesTablePtr or NULL in case of error.
  */
 xmlEntitiesTablePtr
 xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
     return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
 }
 #endif /* LIBXML_TREE_ENABLED */
 
 #ifdef LIBXML_OUTPUT_ENABLED
 
@@ skipping 128 matching lines @@
  * xmlDumpEntityDeclScan:
  * @ent:  An entity table
  * @buf:  An XML buffer.
  *
  * When using the hash table scan function, arguments need to be reversed
  */
 static void
 xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
     xmlDumpEntityDecl(buf, ent);
 }
-      
+
 /**
  * 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) {
     xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
 }
 #endif /* LIBXML_OUTPUT_ENABLED */
 #define bottom_entities
 #include "elfgcchack.h"