Update libxml to 2.7.7.

third_party/libxml/SAX2.c

 /*
  * SAX2.c : Default SAX2 handler to build a tree.
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <daniel@veillard.com>
  */
 
 
 #define IN_LIBXML
 #include "libxml.h"
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
 #include <libxml/xmlmemory.h>
 #include <libxml/tree.h>
 #include <libxml/parser.h>
 #include <libxml/parserInternals.h>
 #include <libxml/valid.h>
 #include <libxml/entities.h>
 #include <libxml/xmlerror.h>
 #include <libxml/debugXML.h>
 #include <libxml/xmlIO.h>
 #include <libxml/SAX.h>
 #include <libxml/uri.h>
 #include <libxml/valid.h>
 #include <libxml/HTMLtree.h>
 #include <libxml/globals.h>
 
+/* Define SIZE_T_MAX unless defined through <limits.h>. */
+#ifndef SIZE_T_MAX
+# define SIZE_T_MAX     ((size_t)-1)
+#endif /* !SIZE_T_MAX */
+
 /* #define DEBUG_SAX2 */
 /* #define DEBUG_SAX2_TREE */
 
 /**
  * TODO:
  *
  * macro to flag unimplemented blocks
  * XML_CATALOG_PREFER user env to select between system/public prefered
  * option. C.f. Richard Tobin <richard@cogsci.ed.ac.uk>
  *> Just FYI, I am using an environment variable XML_CATALOG_PREFER with
@@ skipping 534 matching lines @@
                                          ret->ExternalID, &children);
         if (val == 0) {
             xmlAddChildList((xmlNodePtr) ret, children);
         } else {
             xmlFatalErrMsg(ctxt, XML_ERR_ENTITY_PROCESSING,
                            "Failure to process entity %s\n", name, NULL);
             ctxt->validate = 0;
             return(NULL);
         }
         ret->owner = 1;
-        ret->checked = 1;
+        if (ret->checked == 0)
+            ret->checked = 1;
     }
     return(ret);
 }
 
 /**
  * xmlSAX2GetParameterEntity:
  * @ctx: the user data (XML parser context)
  * @name: The entity name
  *
  * Get a parameter entity by name
@@ skipping 356 matching lines @@
     if (ctx == NULL) return;
 
 #ifdef DEBUG_SAX
     xmlGenericError(xmlGenericErrorContext,
             "SAX.xmlSAX2StartDocument()\n");
 #endif
     if (ctxt->html) {
 #ifdef LIBXML_HTML_ENABLED
         if (ctxt->myDoc == NULL)
             ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
+        ctxt->myDoc->properties = XML_DOC_HTML;
+        ctxt->myDoc->parseFlags = ctxt->options;
         if (ctxt->myDoc == NULL) {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
             return;
         }
 #else
         xmlGenericError(xmlGenericErrorContext,
                 "libxml2 built without HTML support\n");
         ctxt->errNo = XML_ERR_INTERNAL_ERROR;
         ctxt->instate = XML_PARSER_EOF;
         ctxt->disableSAX = 1;
         return;
 #endif
     } else {
         doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
         if (doc != NULL) {
+            doc->properties = 0;
+            if (ctxt->options & XML_PARSE_OLD10)
+                doc->properties |= XML_DOC_OLD10;
+            doc->parseFlags = ctxt->options;
             if (ctxt->encoding != NULL)
                 doc->encoding = xmlStrdup(ctxt->encoding);
             else
                 doc->encoding = NULL;
             doc->standalone = ctxt->standalone;
         } else {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2StartDocument");
             return;
         }
         if ((ctxt->dictNames) && (doc != NULL)) {
@@ skipping 100 matching lines @@
             name = xmlStrdup(fullname);
         }
     }
     if (name == NULL) {
         xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
         if (ns != NULL)
             xmlFree(ns);
         return;
     }
 
+#ifdef LIBXML_HTML_ENABLED
+    if ((ctxt->html) &&
+        (value == NULL) && (htmlIsBooleanAttr(fullname))) {
+            nval = xmlStrdup(fullname);
+            value = (const xmlChar *) nval;
+    } else
+#endif
+    {
 #ifdef LIBXML_VALID_ENABLED
-    /*
-     * Do the last stage of the attribute normalization
-     * Needed for HTML too:
-     *   http://www.w3.org/TR/html4/types.html#h-6.2
-     */
-    ctxt->vctxt.valid = 1;
-    nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
-                                           ctxt->myDoc, ctxt->node,
-                                           fullname, value);
-    if (ctxt->vctxt.valid != 1) {
-        ctxt->valid = 0;
+        /*
+         * Do the last stage of the attribute normalization
+         * Needed for HTML too:
+         *   http://www.w3.org/TR/html4/types.html#h-6.2
+         */
+        ctxt->vctxt.valid = 1;
+        nval = xmlValidCtxtNormalizeAttributeValue(&ctxt->vctxt,
+                                               ctxt->myDoc, ctxt->node,
+                                               fullname, value);
+        if (ctxt->vctxt.valid != 1) {
+            ctxt->valid = 0;
+        }
+        if (nval != NULL)
+            value = nval;
+#else
+        nval = NULL;
+#endif /* LIBXML_VALID_ENABLED */
     }
-    if (nval != NULL)
-        value = nval;
-#else
-    nval = NULL;
-#endif /* LIBXML_VALID_ENABLED */
 
     /*
      * Check whether it's a namespace definition
      */
     if ((!ctxt->html) && (ns == NULL) &&
         (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
         (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
         xmlNsPtr nsret;
         xmlChar *val;
 
@@ skipping 103 matching lines @@
         if (name != NULL) 
             xmlFree(name);
         if (nval != NULL)
             xmlFree(nval);
         if (val != value)
             xmlFree(val);
         return;
     }
 
     if (ns != NULL) {
-        xmlAttrPtr prop;
         namespace = xmlSearchNs(ctxt->myDoc, ctxt->node, ns);
+
         if (namespace == NULL) {
             xmlNsErrMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
                     "Namespace prefix %s of attribute %s is not defined\n",
                              ns, name);
-        }
+        } else {
+            xmlAttrPtr prop;
 
-        prop = ctxt->node->properties;
-        while (prop != NULL) {
-            if (prop->ns != NULL) {
-                if ((xmlStrEqual(name, prop->name)) &&
-                    ((namespace == prop->ns) ||
-                     (xmlStrEqual(namespace->href, prop->ns->href)))) {
-                        xmlNsErrMsg(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
-                                "Attribute %s in %s redefined\n",
-                                         name, namespace->href);
-                    ctxt->wellFormed = 0;
-                    if (ctxt->recovery == 0) ctxt->disableSAX = 1;
-                    goto error;
-                }
-            }
-            prop = prop->next;
-        }
+            prop = ctxt->node->properties;
+            while (prop != NULL) {
+                if (prop->ns != NULL) {
+                    if ((xmlStrEqual(name, prop->name)) &&
+                        ((namespace == prop->ns) ||
+                         (xmlStrEqual(namespace->href, prop->ns->href)))) {
+                            xmlNsErrMsg(ctxt, XML_ERR_ATTRIBUTE_REDEFINED,
+                                    "Attribute %s in %s redefined\n",
+                                             name, namespace->href);
+                        ctxt->wellFormed = 0;
+                        if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+                        goto error;
+                    }
+                }
+                prop = prop->next;
+            }
+        }
     } else {
         namespace = NULL;
     }
 
     /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
     ret = xmlNewNsPropEatName(ctxt->node, namespace, name, NULL);
 
     if (ret != NULL) {
         if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
             xmlNodePtr tmp;
@@ skipping 130 matching lines @@
                                         attr->prefix) == NULL)) {
                     xmlChar *fulln;
 
                     if (attr->prefix != NULL) {
                         fulln = xmlStrdup(attr->prefix);
                         fulln = xmlStrcat(fulln, BAD_CAST ":");
                         fulln = xmlStrcat(fulln, attr->name);
                     } else {
                         fulln = xmlStrdup(attr->name);
                     }
+                    if (fulln == NULL) {
+                        xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElement");
+                        break;
+                    }
 
                     /*
                      * Check that the attribute is not declared in the
                      * serialization
                      */
                     att = NULL;
                     if (atts != NULL) {
                         i = 0;
                         att = atts[i];
                         while (att != NULL) {
                             if (xmlStrEqual(att, fulln))
                                 break;
                             i += 2;
                             att = atts[i];
                         }
                     }
                     if (att == NULL) {
                         xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
       "standalone: attribute %s on %s defaulted from external subset\n",
                                     (const char *)fulln,
                                     (const char *)attr->elem);
                     }
+                    xmlFree(fulln);
                 }
                 attr = attr->nexth;
             }
         }
 
         /*
          * Actually insert defaulted values when needed
          */
         attr = elemDecl->attributes;
         while (attr != NULL) {
@@ skipping 388 matching lines @@
     if (intern == NULL) {
         ret->content = xmlStrndup(str, len);
         if (ret->content == NULL) {
             xmlSAX2ErrMemory(ctxt, "xmlSAX2TextNode");
             xmlFree(ret);
             return(NULL);
         }
     } else
         ret->content = (xmlChar *) intern;
 
+    if (ctxt->input != NULL)
+        ret->line = ctxt->input->line;
+
     if ((__xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
         xmlRegisterNodeDefaultValue(ret);
     return(ret);
 }
 
 #ifdef LIBXML_VALID_ENABLED
 /*
  * xmlSAX2DecodeAttrEntities:
  * @ctxt:  the parser context
  * @str:  the input string
@@ skipping 405 matching lines @@
         if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
             ret->ns = xmlSearchNs(ctxt->myDoc, ret, prefix);
         }
         if (ret->ns == NULL) {
             ns = xmlNewNs(ret, NULL, prefix);
             if (ns == NULL) {
 
                 xmlSAX2ErrMemory(ctxt, "xmlSAX2StartElementNs");
                 return;
             }
-            xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
-                        "Namespace prefix %s was not found\n",
-                        prefix, NULL);
+            if (prefix != NULL)
+                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+                             "Namespace prefix %s was not found\n",
+                             prefix, NULL);
+            else
+                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+                             "Namespace default prefix was not found\n",
+                             NULL, NULL);
         }
     }
 
     /*
      * process all the other attributes
      */
     if (nb_attributes > 0) {
         for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
             xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
                                attributes[j+3], attributes[j+4]);
@@ skipping 160 matching lines @@
              * We try to minimaze realloc() uses and avoid copying
              * and recomputing length over and over.
              */
             if (lastChild->content == (xmlChar *)&(lastChild->properties)) {
                 lastChild->content = xmlStrdup(lastChild->content);
                 lastChild->properties = NULL;
             } else if ((ctxt->nodemem == ctxt->nodelen + 1) &&
                        (xmlDictOwns(ctxt->dict, lastChild->content))) {
                 lastChild->content = xmlStrdup(lastChild->content);
             }
+            if (((size_t)ctxt->nodelen + (size_t)len > XML_MAX_TEXT_LENGTH) &&
+                ((ctxt->options & XML_PARSE_HUGE) == 0)) {
+                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters: huge text node");
+                return;
+            }
+            if ((size_t)ctxt->nodelen > SIZE_T_MAX - (size_t)len || 
+                (size_t)ctxt->nodemem + (size_t)len > SIZE_T_MAX / 2) {
+                xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters overflow prevented");
+                return;
+            }
             if (ctxt->nodelen + len >= ctxt->nodemem) {
                 xmlChar *newbuf;
-                int size;
+                size_t size;
 
                 size = ctxt->nodemem + len;
                 size *= 2;
                 newbuf = (xmlChar *) xmlRealloc(lastChild->content,size);
                 if (newbuf == NULL) {
                     xmlSAX2ErrMemory(ctxt, "xmlSAX2Characters");
                     return;
                 }
                 ctxt->nodemem = size;
                 lastChild->content = newbuf;
@@ skipping 60 matching lines @@
 
     if (ctx == NULL) return;
     parent = ctxt->node;
 #ifdef DEBUG_SAX
     xmlGenericError(xmlGenericErrorContext,
             "SAX.xmlSAX2ProcessingInstruction(%s, %s)\n", target, data);
 #endif
 
     ret = xmlNewDocPI(ctxt->myDoc, target, data);
     if (ret == NULL) return;
-    parent = ctxt->node;
 
     if (ctxt->linenumbers) {
         if (ctxt->input != NULL) {
             if (ctxt->input->line < 65535)
                 ret->line = (short) ctxt->input->line;
             else
                 ret->line = 65535;
         }
     }
     if (ctxt->inSubset == 1) {
@@ skipping 348 matching lines @@
  */
 void
 docbDefaultSAXHandlerInit(void)
 {
     xmlSAX2InitDocbDefaultSAXHandler((xmlSAXHandlerPtr) &docbDefaultSAXHandler);
 }
 
 #endif /* LIBXML_DOCB_ENABLED */
 #define bottom_SAX2
 #include "elfgcchack.h"