Upgrade to libxml 2.9.2 and libxslt 1.1.28

third_party/libxml/src/HTMLtree.c

 /*
  * HTMLtree.c : implementation of access function for an HTML tree.
  *
  * See Copyright for the status of this software.
  *
  * daniel@veillard.com
  */
 
 
 #define IN_LIBXML
@@ skipping 12 matching lines @@
 #include <libxml/xmlmemory.h>
 #include <libxml/HTMLparser.h>
 #include <libxml/HTMLtree.h>
 #include <libxml/entities.h>
 #include <libxml/valid.h>
 #include <libxml/xmlerror.h>
 #include <libxml/parserInternals.h>
 #include <libxml/globals.h>
 #include <libxml/uri.h>
 
+#include "buf.h"
+
 /************************************************************************
  *                                                                      *
- *              Getting/Setting encoding meta tags                      *
+ *              Getting/Setting encoding meta tags                      *
  *                                                                      *
  ************************************************************************/
 
 /**
  * htmlGetMetaEncoding:
  * @doc:  the document
- * 
+ *
  * Encoding definition lookup in the Meta tags
  *
  * Returns the current encoding as flagged in the HTML source
  */
 const xmlChar *
 htmlGetMetaEncoding(htmlDocPtr doc) {
     htmlNodePtr cur;
     const xmlChar *content;
     const xmlChar *encoding;
 
@@ skipping 66 matching lines @@
                     attr = attr->next;
                 }
             }
         }
         cur = cur->next;
     }
     return(NULL);
 
 found_content:
     encoding = xmlStrstr(content, BAD_CAST"charset=");
-    if (encoding == NULL) 
+    if (encoding == NULL)
         encoding = xmlStrstr(content, BAD_CAST"Charset=");
-    if (encoding == NULL) 
+    if (encoding == NULL)
         encoding = xmlStrstr(content, BAD_CAST"CHARSET=");
     if (encoding != NULL) {
         encoding += 8;
     } else {
         encoding = xmlStrstr(content, BAD_CAST"charset =");
-        if (encoding == NULL) 
+        if (encoding == NULL)
             encoding = xmlStrstr(content, BAD_CAST"Charset =");
-        if (encoding == NULL) 
+        if (encoding == NULL)
             encoding = xmlStrstr(content, BAD_CAST"CHARSET =");
         if (encoding != NULL)
             encoding += 9;
     }
     if (encoding != NULL) {
         while ((*encoding == ' ') || (*encoding == '\t')) encoding++;
     }
     return(encoding);
 }
 
 /**
  * htmlSetMetaEncoding:
  * @doc:  the document
  * @encoding:  the encoding string
- * 
+ *
  * Sets the current encoding in the Meta tags
  * NOTE: this will not change the document content encoding, just
  * the META flag associated.
  *
  * Returns 0 in case of success and -1 in case of error
  */
 int
 htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {
     htmlNodePtr cur, meta = NULL, head = NULL;
     const xmlChar *content = NULL;
     char newcontent[100];
 
+    newcontent[0] = 0;
 
     if (doc == NULL)
         return(-1);
 
     /* html isn't a real encoding it's just libxml2 way to get entities */
     if (!xmlStrcasecmp(encoding, BAD_CAST "html"))
         return(-1);
 
     if (encoding != NULL) {
         snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",
@@ skipping 60 matching lines @@
                 while (attr != NULL) {
                     if ((attr->children != NULL) &&
                         (attr->children->type == XML_TEXT_NODE) &&
                         (attr->children->next == NULL)) {
                         value = attr->children->content;
                         if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
                          && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
                             http = 1;
                         else
                         {
-                           if ((value != NULL) && 
+                           if ((value != NULL) &&
                                (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
                                content = value;
                         }
                         if ((http != 0) && (content != NULL))
                             break;
                     }
                     attr = attr->next;
                 }
                 if ((http != 0) && (content != NULL)) {
                     meta = cur;
@@ skipping 13 matching lines @@
 
             meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
             if (head->children == NULL)
                 xmlAddChild(head, meta);
             else
                 xmlAddPrevSibling(head->children, meta);
             xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
             xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
         }
     } else {
+        /* remove the meta tag if NULL is passed */
+        if (encoding == NULL) {
+            xmlUnlinkNode(meta);
+            xmlFreeNode(meta);
+        }
         /* change the document only if there is a real encoding change */
-        if (xmlStrcasestr(content, encoding) == NULL) {
+        else if (xmlStrcasestr(content, encoding) == NULL) {
             xmlSetProp(meta, BAD_CAST"content", BAD_CAST newcontent);
         }
     }
 
 
     return(0);
 }
 
 /**
  * booleanHTMLAttrs:
  *
  * These are the HTML attributes which will be output
  * in minimized form, i.e. <option selected="selected"> will be
  * output as <option selected>, as per XSLT 1.0 16.2 "HTML Output Method"
  *
  */
 static const char* htmlBooleanAttrs[] = {
   "checked", "compact", "declare", "defer", "disabled", "ismap",
   "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
   "selected", NULL
 };
 
 
 /**
  * htmlIsBooleanAttr:
  * @name:  the name of the attribute to check
  *
  * Determine if a given attribute is a boolean attribute.
- * 
+ *
  * returns: false if the attribute is not boolean, true otherwise.
  */
 int
 htmlIsBooleanAttr(const xmlChar *name)
 {
     int i = 0;
 
     while (htmlBooleanAttrs[i] != NULL) {
         if (xmlStrcasecmp((const xmlChar *)htmlBooleanAttrs[i], name) == 0)
             return 1;
         i++;
     }
     return 0;
 }
 
 #ifdef LIBXML_OUTPUT_ENABLED
 /*
  * private routine exported from xmlIO.c
  */
 xmlOutputBufferPtr
 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder);
 /************************************************************************
  *                                                                      *
- *                      Output error handlers                           *
+ *                      Output error handlers                           *
  *                                                                      *
  ************************************************************************/
 /**
  * htmlSaveErrMemory:
  * @extra:  extra informations
  *
  * Handle an out of memory condition
  */
 static void
 htmlSaveErrMemory(const char *extra)
@@ skipping 28 matching lines @@
             msg = "HTML has no DOCTYPE\n";
             break;
         default:
             msg = "unexpected error number\n";
     }
     __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
 }
 
 /************************************************************************
  *                                                                      *
- *              Dumping HTML tree content to a simple buffer            *
+ *              Dumping HTML tree content to a simple buffer            *
  *                                                                      *
  ************************************************************************/
 
-static int
-htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
-                   int format);
-
 /**
- * htmlNodeDumpFormat:
- * @buf:  the HTML buffer output
+ * htmlBufNodeDumpFormat:
+ * @buf:  the xmlBufPtr output
  * @doc:  the document
  * @cur:  the current node
  * @format:  should formatting spaces been added
  *
  * Dump an HTML node, recursive behaviour,children are printed too.
  *
  * Returns the number of byte written or -1 in case of error
  */
-static int
-htmlNodeDumpFormat(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur,
+static size_t
+htmlBufNodeDumpFormat(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur,
                    int format) {
-    unsigned int use;
+    size_t use;
     int ret;
     xmlOutputBufferPtr outbuf;
 
     if (cur == NULL) {
         return (-1);
     }
     if (buf == NULL) {
         return (-1);
     }
     outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
     if (outbuf == NULL) {
         htmlSaveErrMemory("allocating HTML output buffer");
         return (-1);
     }
     memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
     outbuf->buffer = buf;
     outbuf->encoder = NULL;
     outbuf->writecallback = NULL;
     outbuf->closecallback = NULL;
     outbuf->context = NULL;
     outbuf->written = 0;
 
-    use = buf->use;
+    use = xmlBufUse(buf);
     htmlNodeDumpFormatOutput(outbuf, doc, cur, NULL, format);
     xmlFree(outbuf);
-    ret = buf->use - use;
+    ret = xmlBufUse(buf) - use;
     return (ret);
 }
 
 /**
  * htmlNodeDump:
  * @buf:  the HTML buffer output
  * @doc:  the document
  * @cur:  the current node
  *
  * Dump an HTML node, recursive behaviour,children are printed too,
  * and formatting returns are added.
  *
  * Returns the number of byte written or -1 in case of error
  */
 int
 htmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur) {
+    xmlBufPtr buffer;
+    size_t ret;
+
+    if ((buf == NULL) || (cur == NULL))
+        return(-1);
+
     xmlInitParser();
+    buffer = xmlBufFromBuffer(buf);
+    if (buffer == NULL)
+        return(-1);
 
-    return(htmlNodeDumpFormat(buf, doc, cur, 1));
+    ret = htmlBufNodeDumpFormat(buffer, doc, cur, 1);
+
+    xmlBufBackToBuffer(buffer);
+
+    if (ret > INT_MAX)
+        return(-1);
+    return((int) ret);
 }
 
 /**
  * htmlNodeDumpFileFormat:
  * @out:  the FILE pointer
  * @doc:  the document
  * @cur:  the current node
  * @encoding: the document encoding
  * @format:  should formatting spaces been added
  *
@@ skipping 12 matching lines @@
 
     xmlInitParser();
 
     if (encoding != NULL) {
         xmlCharEncoding enc;
 
         enc = xmlParseCharEncoding(encoding);
         if (enc != XML_CHAR_ENCODING_UTF8) {
             handler = xmlFindCharEncodingHandler(encoding);
             if (handler == NULL)
-                return(-1);
+                htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
         }
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("ascii");
 
-    /* 
+    /*
      * save the content to a temp buffer.
      */
     buf = xmlOutputBufferCreateFile(out, handler);
     if (buf == NULL) return(0);
 
     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
 
     ret = xmlOutputBufferClose(buf);
     return(ret);
 }
@@ skipping 48 matching lines @@
             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
                 /*
                  * Not supported yet
                  */
                 *mem = NULL;
                 *size = 0;
                 return;
             }
 
             handler = xmlFindCharEncodingHandler(encoding);
-            if (handler == NULL) {
-                *mem = NULL;
-                *size = 0;
-                return;
-            }
+            if (handler == NULL)
+                htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
+
         } else {
             handler = xmlFindCharEncodingHandler(encoding);
         }
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("ascii");
 
     buf = xmlAllocOutputBufferInternal(handler);
     if (buf == NULL) {
         *mem = NULL;
         *size = 0;
         return;
     }
 
-        htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
+    htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
 
     xmlOutputBufferFlush(buf);
     if (buf->conv != NULL) {
-        *size = buf->conv->use;
-        *mem = xmlStrndup(buf->conv->content, *size);
+        *size = xmlBufUse(buf->conv);
+        *mem = xmlStrndup(xmlBufContent(buf->conv), *size);
     } else {
-        *size = buf->buffer->use;
-        *mem = xmlStrndup(buf->buffer->content, *size);
+        *size = xmlBufUse(buf->buffer);
+        *mem = xmlStrndup(xmlBufContent(buf->buffer), *size);
     }
     (void)xmlOutputBufferClose(buf);
 }
 
 /**
  * htmlDocDumpMemory:
  * @cur:  the document
  * @mem:  OUT: the memory pointer
  * @size:  OUT: the memory length
  *
  * Dump an HTML document in memory and return the xmlChar * and it's size.
  * It's up to the caller to free the memory.
  */
 void
 htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
         htmlDocDumpMemoryFormat(cur, mem, size, 1);
 }
 
 
 /************************************************************************
  *                                                                      *
- *              Dumping HTML tree content to an I/O output buffer       *
+ *              Dumping HTML tree content to an I/O output buffer       *
  *                                                                      *
  ************************************************************************/
 
 void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
 
 /**
  * htmlDtdDumpOutput:
  * @buf:  the HTML buffer output
  * @doc:  the document
  * @encoding:  the encoding string
- * 
+ *
  * TODO: check whether encoding is needed
  *
  * Dump the HTML document DTD, if any.
  */
 static void
 htmlDtdDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
                   const char *encoding ATTRIBUTE_UNUSED) {
     xmlDtdPtr cur = doc->intSubset;
 
     if (cur == NULL) {
         htmlSaveErr(XML_SAVE_NO_DOCTYPE, (xmlNodePtr) doc, NULL);
         return;
     }
     xmlOutputBufferWriteString(buf, "<!DOCTYPE ");
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
     if (cur->ExternalID != NULL) {
         xmlOutputBufferWriteString(buf, " PUBLIC ");
-        xmlBufferWriteQuotedString(buf->buffer, cur->ExternalID);
+        xmlBufWriteQuotedString(buf->buffer, cur->ExternalID);
         if (cur->SystemID != NULL) {
             xmlOutputBufferWriteString(buf, " ");
-            xmlBufferWriteQuotedString(buf->buffer, cur->SystemID);
-        } 
+            xmlBufWriteQuotedString(buf->buffer, cur->SystemID);
+        }
     }  else if (cur->SystemID != NULL) {
         xmlOutputBufferWriteString(buf, " SYSTEM ");
-        xmlBufferWriteQuotedString(buf->buffer, cur->SystemID);
+        xmlBufWriteQuotedString(buf->buffer, cur->SystemID);
     }
     xmlOutputBufferWriteString(buf, ">\n");
 }
 
 /**
  * htmlAttrDumpOutput:
  * @buf:  the HTML buffer output
  * @doc:  the document
  * @cur:  the attribute pointer
  * @encoding:  the encoding string
  *
  * Dump an HTML attribute
  */
 static void
 htmlAttrDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur,
                    const char *encoding ATTRIBUTE_UNUSED) {
     xmlChar *value;
 
     /*
-     * TODO: The html output method should not escape a & character
-     *       occurring in an attribute value immediately followed by
-     *       a { character (see Section B.7.1 of the HTML 4.0 Recommendation).
+     * The html output method should not escape a & character
+     * occurring in an attribute value immediately followed by
+     * a { character (see Section B.7.1 of the HTML 4.0 Recommendation).
+     * This is implemented in xmlEncodeEntitiesReentrant
      */
 
     if (cur == NULL) {
         return;
     }
     xmlOutputBufferWriteString(buf, " ");
     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
         xmlOutputBufferWriteString(buf, ":");
     }
     xmlOutputBufferWriteString(buf, (const char *)cur->name);
     if ((cur->children != NULL) && (!htmlIsBooleanAttr(cur->name))) {
         value = xmlNodeListGetString(doc, cur->children, 0);
         if (value) {
             xmlOutputBufferWriteString(buf, "=");
             if ((cur->ns == NULL) && (cur->parent != NULL) &&
                 (cur->parent->ns == NULL) &&
                 ((!xmlStrcasecmp(cur->name, BAD_CAST "href")) ||
                  (!xmlStrcasecmp(cur->name, BAD_CAST "action")) ||
                  (!xmlStrcasecmp(cur->name, BAD_CAST "src")) ||
                  ((!xmlStrcasecmp(cur->name, BAD_CAST "name")) &&
                   (!xmlStrcasecmp(cur->parent->name, BAD_CAST "a"))))) {
-                xmlChar *escaped;
                 xmlChar *tmp = value;
+                /* xmlURIEscapeStr() escapes '"' so it can be safely used. */
+                xmlBufCCat(buf->buffer, "\"");
 
                 while (IS_BLANK_CH(*tmp)) tmp++;
 
-                escaped = xmlURIEscapeStr(tmp, BAD_CAST"@/:=?;#%&,+");
-                if (escaped != NULL) {
-                    xmlBufferWriteQuotedString(buf->buffer, escaped);
-                    xmlFree(escaped);
-                } else {
-                    xmlBufferWriteQuotedString(buf->buffer, value);
+                /* URI Escape everything, except server side includes. */
+                for ( ; ; ) {
+                    xmlChar *escaped;
+                    xmlChar endChar;
+                    xmlChar *end = NULL;
+                    xmlChar *start = (xmlChar *)xmlStrstr(tmp, BAD_CAST "<!--");
+                    if (start != NULL) {
+                        end = (xmlChar *)xmlStrstr(tmp, BAD_CAST "-->");
+                        if (end != NULL) {
+                            *start = '\0';
+                        }
+                    }
+
+                    /* Escape the whole string, or until start (set to '\0'). */
+                    escaped = xmlURIEscapeStr(tmp, BAD_CAST"@/:=?;#%&,+");
+                    if (escaped != NULL) {
+                        xmlBufCat(buf->buffer, escaped);
+                        xmlFree(escaped);
+                    } else {
+                        xmlBufCat(buf->buffer, tmp);
+                    }
+
+                    if (end == NULL) { /* Everything has been written. */
+                        break;
+                    }
+
+                    /* Do not escape anything within server side includes. */
+                    *start = '<'; /* Restore the first character of "<!--". */
+                    end += 3; /* strlen("-->") */
+                    endChar = *end;
+                    *end = '\0';
+                    xmlBufCat(buf->buffer, start);
+                    *end = endChar;
+                    tmp = end;
                 }
+
+                xmlBufCCat(buf->buffer, "\"");
             } else {
-                xmlBufferWriteQuotedString(buf->buffer, value);
+                xmlBufWriteQuotedString(buf->buffer, value);
             }
             xmlFree(value);
         } else  {
             xmlOutputBufferWriteString(buf, "=\"\"");
         }
     }
 }
 
 /**
  * htmlAttrListDumpOutput:
@@ skipping 329 matching lines @@
         if (enc != cur->charset) {
             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
                 /*
                  * Not supported yet
                  */
                 return(-1);
             }
 
             handler = xmlFindCharEncodingHandler(encoding);
             if (handler == NULL)
-                return(-1);
+                htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
         } else {
             handler = xmlFindCharEncodingHandler(encoding);
         }
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
@@ skipping 19 matching lines @@
  */
 int
 htmlSaveFile(const char *filename, xmlDocPtr cur) {
     xmlOutputBufferPtr buf;
     xmlCharEncodingHandlerPtr handler = NULL;
     const char *encoding;
     int ret;
 
     if ((cur == NULL) || (filename == NULL))
         return(-1);
-       
+
     xmlInitParser();
 
     encoding = (const char *) htmlGetMetaEncoding(cur);
 
     if (encoding != NULL) {
         xmlCharEncoding enc;
 
         enc = xmlParseCharEncoding(encoding);
         if (enc != cur->charset) {
             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
                 /*
                  * Not supported yet
                  */
                 return(-1);
             }
 
             handler = xmlFindCharEncodingHandler(encoding);
             if (handler == NULL)
-                return(-1);
+                htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
         }
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("ascii");
 
-    /* 
+    /*
      * save the content to a temp buffer.
      */
     buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
     if (buf == NULL) return(0);
 
     htmlDocContentDumpOutput(buf, cur, NULL);
 
     ret = xmlOutputBufferClose(buf);
     return(ret);
 }
 
 /**
  * htmlSaveFileFormat:
  * @filename:  the filename
  * @cur:  the document
  * @format:  should formatting spaces been added
  * @encoding: the document encoding
  *
  * Dump an HTML document to a file using a given encoding.
- * 
+ *
  * returns: the number of byte written or -1 in case of failure.
  */
 int
 htmlSaveFileFormat(const char *filename, xmlDocPtr cur,
                    const char *encoding, int format) {
     xmlOutputBufferPtr buf;
     xmlCharEncodingHandlerPtr handler = NULL;
     int ret;
 
     if ((cur == NULL) || (filename == NULL))
         return(-1);
 
     xmlInitParser();
 
     if (encoding != NULL) {
         xmlCharEncoding enc;
 
         enc = xmlParseCharEncoding(encoding);
         if (enc != cur->charset) {
             if (cur->charset != XML_CHAR_ENCODING_UTF8) {
                 /*
                  * Not supported yet
                  */
                 return(-1);
             }
 
             handler = xmlFindCharEncodingHandler(encoding);
             if (handler == NULL)
-                return(-1);
+                htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
         }
         htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
     } else {
         htmlSetMetaEncoding(cur, (const xmlChar *) "UTF-8");
     }
 
     /*
      * Fallback to HTML or ASCII when the encoding is unspecified
      */
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("HTML");
     if (handler == NULL)
         handler = xmlFindCharEncodingHandler("ascii");
 
-    /* 
+    /*
      * save the content to a temp buffer.
      */
     buf = xmlOutputBufferCreateFilename(filename, handler, 0);
     if (buf == NULL) return(0);
 
     htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
 
     ret = xmlOutputBufferClose(buf);
     return(ret);
 }
 
 /**
  * htmlSaveFileEnc:
  * @filename:  the filename
  * @cur:  the document
  * @encoding: the document encoding
  *
  * Dump an HTML document to a file using a given encoding
  * and formatting returns/spaces are added.
- * 
+ *
  * returns: the number of byte written or -1 in case of failure.
  */
 int
 htmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
     return(htmlSaveFileFormat(filename, cur, encoding, 1));
 }
 
 #endif /* LIBXML_OUTPUT_ENABLED */
 
 #define bottom_HTMLtree
 #include "elfgcchack.h"
 #endif /* LIBXML_HTML_ENABLED */