xmlrpc-c/SOURCES/0001-cleanup-and-fix-libxml2-backend.patch

From 22c63b6ca838d257ce6b044fd893f3374d038e3f Mon Sep 17 00:00:00 2001
From: Igor Gnatenko <i.gnatenko.brain@gmail.com>
Date: Sun, 18 Dec 2016 11:49:03 +0100
Subject: [PATCH] cleanup and fix libxml2 backend

Signed-off-by: Igor Gnatenko <i.gnatenko.brain@gmail.com>
---
 src/xmlrpc_libxml2.c | 138 +++++++++++++++++++++++++++------------------------
 1 file changed, 73 insertions(+), 65 deletions(-)

diff --git a/src/xmlrpc_libxml2.c b/src/xmlrpc_libxml2.c
index 207036ff..bf3d6914 100644
--- a/src/xmlrpc_libxml2.c
+++ b/src/xmlrpc_libxml2.c
@@ -43,14 +43,15 @@
 #include "xmlrpc-c/base.h"
 #include "xmlrpc-c/base_int.h"
 #include "xmlrpc-c/string_int.h"
+#include "xmlrpc-c/util.h"
 
 #include "xmlparser.h"
 
 struct _xml_element {
     xml_element * parentP;
     const char * name;
-    xmlrpc_mem_block cdata;    /* char */
-    xmlrpc_mem_block children; /* xml_element* */
+    xmlrpc_mem_block * cdataP;    /* char */
+    xmlrpc_mem_block * childrenP; /* xml_element* */
 };
 
 #define XMLRPC_ASSERT_ELEM_OK(elem) \
@@ -102,7 +103,7 @@ xmlElementNew(xmlrpc_env * const envP,
     bool childrenAreValid;
 
     XMLRPC_ASSERT_ENV_OK(envP);
-    assert(name != NULL);
+    XMLRPC_ASSERT(name != NULL);
 
     /* Set up our error-handling preconditions. */
     retval = NULL;
@@ -112,21 +113,20 @@ xmlElementNew(xmlrpc_env * const envP,
     XMLRPC_FAIL_IF_NULL(retval, envP, XMLRPC_INTERNAL_ERROR,
                         "Couldn't allocate memory for XML element");
 
+    /* Set our parent field to NULL. */
     retval->parentP = NULL;
-    
+
     /* Copy over the element name. */
-    retval->name = strdup(name);
+    retval->name = xmlrpc_strdupnull(name);
     XMLRPC_FAIL_IF_NULL(retval->name, envP, XMLRPC_INTERNAL_ERROR,
                         "Couldn't allocate memory for XML element");
     nameIsValid = true;
 
-    /* Initialize a block to hold our CDATA. */
-    XMLRPC_TYPED_MEM_BLOCK_INIT(char, envP, &retval->cdata, 0);
+    retval->cdataP = XMLRPC_MEMBLOCK_NEW(char, envP, 0);
     XMLRPC_FAIL_IF_FAULT(envP);
     cdataIsValid = true;
 
-    /* Initialize a block to hold our child elements. */
-    XMLRPC_TYPED_MEM_BLOCK_INIT(xml_element *, envP, &retval->children, 0);
+    retval->childrenP = XMLRPC_MEMBLOCK_NEW(xml_element *, envP, 0);
     XMLRPC_FAIL_IF_FAULT(envP);
     childrenAreValid = true;
 
@@ -136,48 +136,50 @@ cleanup:
             if (nameIsValid)
                 xmlrpc_strfree(retval->name);
             if (cdataIsValid)
-                xmlrpc_mem_block_clean(&retval->cdata);
+                XMLRPC_MEMBLOCK_FREE(char, retval->cdataP);
             if (childrenAreValid)
-                xmlrpc_mem_block_clean(&retval->children);
+                XMLRPC_MEMBLOCK_FREE(xml_element *, retval->childrenP);
             free(retval);
         }
-        retval = NULL;
+        return NULL;
+    } else {
+        return retval;
     }
-    return retval;
 }
 
 
-
+/*=========================================================================
+**  xml_element_free
+**=========================================================================
+**  Blow away an existing element & all of its child elements.
+*/
 void
 xml_element_free(xml_element * const elemP) {
-/*----------------------------------------------------------------------------
-  Blow away an existing element & all of its child elements.
------------------------------------------------------------------------------*/
-    xmlrpc_mem_block * children;
-    unsigned int size;
-    unsigned int i;
+
+    xmlrpc_mem_block * childrenP;
+    size_t size, i;
     xml_element ** contents;
 
     XMLRPC_ASSERT_ELEM_OK(elemP);
 
     xmlrpc_strfree(elemP->name);
     elemP->name = XMLRPC_BAD_POINTER;
-    xmlrpc_mem_block_clean(&elemP->cdata);
+
+    XMLRPC_MEMBLOCK_FREE(char, elemP->cdataP);
 
     /* Deallocate all of our children recursively. */
-    children = &elemP->children;
-    contents = XMLRPC_TYPED_MEM_BLOCK_CONTENTS(xml_element *, children);
-    size = XMLRPC_TYPED_MEM_BLOCK_SIZE(xml_element *, children);
+    childrenP = elemP->childrenP;
+    contents = XMLRPC_MEMBLOCK_CONTENTS(xml_element *, childrenP);
+    size = XMLRPC_MEMBLOCK_SIZE(xml_element *, childrenP);
     for (i = 0; i < size; ++i)
         xml_element_free(contents[i]);
 
-    xmlrpc_mem_block_clean(&elemP->children);
+    XMLRPC_MEMBLOCK_FREE(xml_element *, elemP->childrenP);
 
     free(elemP);
 }
 
 
-
 /*=========================================================================
 **  Miscellaneous Accessors
 **=========================================================================
@@ -185,36 +187,47 @@ xml_element_free(xml_element * const elemP) {
 **  documentation on each function works.
 */
 
+
+
 const char *
 xml_element_name(const xml_element * const elemP) {
 
     XMLRPC_ASSERT_ELEM_OK(elemP);
+
     return elemP->name;
 }
 
+
+
 size_t
-xml_element_cdata_size(const xml_element * const elemP) {
-    /* The result of this function is NOT VALID until the end_element handler
-       has been called!
-    */
+xml_element_cdata_size (const xml_element * const elemP) {
+/*----------------------------------------------------------------------------
+  The result of this function is NOT VALID until the end_element handler
+  has been called!
+-----------------------------------------------------------------------------*/
     XMLRPC_ASSERT_ELEM_OK(elemP);
-    return XMLRPC_TYPED_MEM_BLOCK_SIZE(char, &elemP->cdata) - 1;
+
+    return XMLRPC_MEMBLOCK_SIZE(char, elemP->cdataP) - 1;
 }
 
 
 
 const char *
 xml_element_cdata(const xml_element * const elemP) {
+
     XMLRPC_ASSERT_ELEM_OK(elemP);
-    return XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, &elemP->cdata);
+
+    return XMLRPC_TYPED_MEM_BLOCK_CONTENTS(const char, elemP->cdataP);
 }
 
 
 
 unsigned int
 xml_element_children_size(const xml_element * const elemP) {
+
     XMLRPC_ASSERT_ELEM_OK(elemP);
-    return XMLRPC_TYPED_MEM_BLOCK_SIZE(xml_element *, &elemP->children);
+
+    return XMLRPC_MEMBLOCK_SIZE(xml_element *, elemP->childrenP);
 }
 
 
@@ -222,47 +235,42 @@ xml_element_children_size(const xml_element * const elemP) {
 xml_element **
 xml_element_children(const xml_element * const elemP) {
     XMLRPC_ASSERT_ELEM_OK(elemP);
-    return XMLRPC_TYPED_MEM_BLOCK_CONTENTS(xml_element *, &elemP->children);
+    return XMLRPC_MEMBLOCK_CONTENTS(xml_element *, elemP->childrenP);
 }
 
 
 
-/*=========================================================================
-**  Internal xml_element Utility Functions
-**=========================================================================
-*/
+/*=============================================================================
+  Internal xml_element Utility Functions
+=============================================================================*/
 
 static void
-xmlElementAppendCdata(xmlrpc_env *  const envP,
-				      xml_element * const elemP,
-				      const char *  const cdata,
-				      size_t        const size) {
+xml_element_append_cdata(xmlrpc_env *  const envP,
+                         xml_element * const elemP,
+                         const char *  const cdata,
+                         size_t        const size) {
 
     XMLRPC_ASSERT_ENV_OK(envP);
-    XMLRPC_ASSERT_ELEM_OK(elemP);    
+    XMLRPC_ASSERT_ELEM_OK(elemP);
 
-    XMLRPC_TYPED_MEM_BLOCK_APPEND(char, envP, &elemP->cdata, cdata, size);
+    XMLRPC_MEMBLOCK_APPEND(char, envP, elemP->cdataP, cdata, size);
 }
 
 
 
 static void
-xmlElementAppendChild(xmlrpc_env *  const envP,
-				      xml_element * const elemP,
-				      xml_element * const childP) {
-
-    /* Whether or not this function succeeds, it takes ownership of the 'child'
-       argument.
-       WARNING - This is the exact opposite of the usual memory ownership
-       rules for xmlrpc_value! So please pay attention.
-    */
+xml_element_append_child(xmlrpc_env *  const envP,
+                         xml_element * const elemP,
+                         xml_element * const childP) {
+/*----------------------------------------------------------------------------
+  Whether or not this function succeeds, it takes ownership of *childP.
+-----------------------------------------------------------------------------*/
     XMLRPC_ASSERT_ENV_OK(envP);
     XMLRPC_ASSERT_ELEM_OK(elemP);
     XMLRPC_ASSERT_ELEM_OK(childP);
-    assert(childP->parentP == NULL);
+    XMLRPC_ASSERT(childP->parentP == NULL);
 
-    XMLRPC_TYPED_MEM_BLOCK_APPEND(xml_element *, envP, &elemP->children,
-                                  &childP, 1);
+    XMLRPC_MEMBLOCK_APPEND(xml_element *, envP, elemP->childrenP, &childP, 1);
     if (!envP->fault_occurred)
         childP->parentP = elemP;
     else
@@ -317,7 +325,7 @@ startElement_(void *           const userData,
             /* (We need to watch our error handling invariants very carefully
             ** here. Read the docs for xml_elementAppendChild. */
             newCurrentP = elemP;
-            xmlElementAppendChild(&contextP->env, contextP->currentP, elemP);
+            xml_element_append_child(&contextP->env, contextP->currentP, elemP);
             elemP = NULL;
             XMLRPC_FAIL_IF_FAULT(&contextP->env);
             contextP->currentP = newCurrentP;
@@ -348,7 +356,7 @@ endElement_(void *          const userData,
                contextP->currentP == contextP->rootP);
 
         /* Add a trailing '\0' to our cdata. */
-        xmlElementAppendCdata(&contextP->env, contextP->currentP, "\0", 1);
+        xml_element_append_cdata(&contextP->env, contextP->currentP, "\0", 1);
         if (!contextP->env.fault_occurred) {
             /* Pop our "stack" of elements. */
             contextP->currentP = contextP->currentP->parentP;
@@ -370,9 +378,9 @@ characterData(void *          const userData,
     /* Get our context and see if an error has already occured. */
     contextP = (ParseContext*)userData;
     if (!contextP->env.fault_occurred) {
-        assert(contextP->currentP != NULL);
+        XMLRPC_ASSERT(contextP->currentP != NULL);
 	
-        xmlElementAppendCdata(&contextP->env,
+        xml_element_append_cdata(&contextP->env,
                               contextP->currentP,
                               (char *)s,
                               len);
@@ -428,7 +436,7 @@ static xmlSAXHandler const saxHandler = {
 
 
 static void
-removeDocSizeLimit(xmlParserCtx * const parserP ATTR_UNUSED) {
+removeDocSizeLimit(xmlParserCtxt * const parserP ATTR_UNUSED) {
 /*----------------------------------------------------------------------------
    Set up *parserP to accept a document of any size.
 
@@ -451,13 +459,13 @@ removeDocSizeLimit(xmlParserCtx * const parserP ATTR_UNUSED) {
 
 
 static void
-createParser(xmlrpc_env *    const envP,
-             ParseContext *  const contextP,
-             xmlParserCtx ** const parserPP) {
+createParser(xmlrpc_env *     const envP,
+             ParseContext *   const contextP,
+             xmlParserCtxt ** const parserPP) {
 /*----------------------------------------------------------------------------
    Create an appropriate Libxml2 parser for our purpose.
 -----------------------------------------------------------------------------*/
-    xmlParserCtx * parserP;
+    xmlParserCtxt * parserP;
 
     parserP = xmlCreatePushParserCtxt((xmlSAXHandler *)&saxHandler, contextP,
                                         NULL, 0, NULL);
-- 
2.11.0