Replace libxml2's xmlNode with a custom XML structure

The new structure (rexmpp_xml) is simpler, and should allow
manipulation from Rust without any dependency on libxml2 from the Rust
code (while Rust has its own parsers, such as rxml). Alternative XML
parsers (e.g., libexpat) now can be used from the C code.

The replacement/abstraction is not quite complete yet: the parsing
process itself (xmlParseChunk and friends) should be abstracted out.

1 files changed, 185 insertions, 227 deletions

diff --git a/src/rexmpp_console.c b/src/rexmpp_console.c
index b863672..ce325aa 100644
--- a/src/rexmpp_console.c
+++ b/src/rexmpp_console.c
@@ -13,6 +13,7 @@
 #include <string.h>
 
 #include "rexmpp.h"
+#include "rexmpp_xml.h"
 #include "rexmpp_openpgp.h"
 #include "rexmpp_http_upload.h"
 #include "rexmpp_jingle.h"
@@ -30,61 +31,60 @@ void rexmpp_console_printf (rexmpp_t *s, const char *format, ...)
   }
 }
 
-char *rexmpp_console_message_string (rexmpp_t *s, xmlNodePtr node) {
-  char *ret = NULL;
-  xmlNodePtr openpgp =
+const char *rexmpp_console_message_string (rexmpp_t *s, rexmpp_xml_t *node) {
+  const char *ret = NULL;
+  rexmpp_xml_t *openpgp =
     rexmpp_xml_find_child(node, "urn:xmpp:openpgp:0", "openpgp");
   if (openpgp != NULL) {
     int valid;
-    xmlNodePtr elem = rexmpp_openpgp_decrypt_verify_message(s, node, &valid);
+    rexmpp_xml_t *elem = rexmpp_openpgp_decrypt_verify_message(s, node, &valid);
     if (! valid) {
       rexmpp_console_printf(s, "An invalid OpenPGP message!\n");
     }
 
     if (elem != NULL) {
-      xmlNodePtr payload =
+      rexmpp_xml_t *payload =
         rexmpp_xml_find_child(elem, "urn:xmpp:openpgp:0", "payload");
       if (payload != NULL) {
-        xmlNodePtr pl_body =
+        rexmpp_xml_t *pl_body =
           rexmpp_xml_find_child(payload, "jabber:client", "body");
         if (pl_body != NULL) {
-          ret = xmlNodeGetContent(pl_body);
+          ret = rexmpp_xml_text_child(pl_body);
         }
       }
-      xmlFreeNode(elem);
+      rexmpp_xml_free(elem);
     }
   }
   if (ret == NULL) {
-    xmlNodePtr body = rexmpp_xml_find_child(node, "jabber:client", "body");
-    ret = xmlNodeGetContent(body);
+    rexmpp_xml_t *body =
+      rexmpp_xml_find_child(node, "jabber:client", "body");
+    ret = rexmpp_xml_text_child(body);
   }
   return ret;
 }
 
-void rexmpp_console_on_send (rexmpp_t *s, xmlNodePtr node) {
+void rexmpp_console_on_send (rexmpp_t *s, rexmpp_xml_t *node) {
   if (rexmpp_xml_match(node, "jabber:client", "message")) {
-    char *to = xmlGetProp(node, "to");
+    const char *to = rexmpp_xml_find_attr_val(node, "to");
     if (to != NULL) {
       /* "from" should be set for verification. */
-      char *from = xmlGetProp(node, "from");
-      xmlAttrPtr fromProp = NULL;
-      if (from == NULL) {
-        fromProp = xmlNewProp(node, "from", to);
+      int added_from = 0;
+      if (rexmpp_xml_find_attr_val(node, "from") == NULL) {
+        rexmpp_xml_add_attr(node, "from", to);
+        added_from = 1;
       }
-      char *str = rexmpp_console_message_string(s, node);
-      if (fromProp != NULL) {
-        xmlRemoveProp(fromProp);
+      const char *str = rexmpp_console_message_string(s, node);
+      if (added_from) {
+        rexmpp_xml_remove_attr(node, "from");
       }
       if (str != NULL) {
         rexmpp_console_printf(s, "You tell %s: %s\n", to, str);
-        free(str);
       }
-      free(to);
     }
   }
   if (rexmpp_xml_match(node, "jabber:client", "presence")) {
-    char *presence_type = xmlGetProp(node, "type");
-    char *presence_to = xmlGetProp(node, "to");
+    const char *presence_type = rexmpp_xml_find_attr_val(node, "type");
+    const char *presence_to = rexmpp_xml_find_attr_val(node, "to");
     if (presence_to == NULL) {
       rexmpp_console_printf(s, "Becoming %s\n",
                             (presence_type == NULL) ?
@@ -106,72 +106,58 @@ void rexmpp_console_on_send (rexmpp_t *s, xmlNodePtr node) {
                               "Denying %s's presence subscription request.\n",
                               presence_to);
       }
-      free(presence_to);
-    }
-    if (presence_type != NULL) {
-      free(presence_type);
     }
   }
 }
 
-void rexmpp_console_on_recv (rexmpp_t *s, xmlNodePtr node) {
+void rexmpp_console_on_recv (rexmpp_t *s, rexmpp_xml_t *node) {
   if (rexmpp_xml_match(node, "jabber:client", "message")) {
-    xmlNodePtr sent = rexmpp_xml_find_child(node, "urn:xmpp:carbons:2", "sent");
+    rexmpp_xml_t *sent = rexmpp_xml_find_child(node, "urn:xmpp:carbons:2", "sent");
     if (sent != NULL) {
-      xmlNodePtr fwd =
+      rexmpp_xml_t *fwd =
         rexmpp_xml_find_child(sent, "urn:xmpp:forward:0", "forwarded");
       if (fwd != NULL) {
-        xmlNodePtr msg =
+        rexmpp_xml_t *msg =
           rexmpp_xml_find_child(fwd, "jabber:client", "message");
         if (msg != NULL) {
-          char *to = xmlGetProp(msg, "to");
-          char *str = rexmpp_console_message_string(s, msg);
+          const char *to = rexmpp_xml_find_attr_val(msg, "to");
+          const char *str = rexmpp_console_message_string(s, msg);
           if (str != NULL) {
             rexmpp_console_printf(s, "You tell %s: %s\n", to, str);
-            free(str);
-          }
-          if (to != NULL) {
-            free(to);
           }
         }
       }
     }
 
-    xmlNodePtr received =
+    rexmpp_xml_t *received =
       rexmpp_xml_find_child(node, "urn:xmpp:carbons:2", "received");
     if (received != NULL) {
-      xmlNodePtr fwd =
+      rexmpp_xml_t *fwd =
         rexmpp_xml_find_child(received, "urn:xmpp:forward:0", "forwarded");
       if (fwd != NULL) {
-        xmlNodePtr msg =
+        rexmpp_xml_t *msg =
           rexmpp_xml_find_child(fwd, "jabber:client", "message");
         if (msg != NULL) {
-          char *from = xmlGetProp(msg, "from");
-          char *str = rexmpp_console_message_string(s, msg);
+          const char *from = rexmpp_xml_find_attr_val(msg, "from");
+          const char *str = rexmpp_console_message_string(s, msg);
           if (str != NULL) {
             rexmpp_console_printf(s, "%s tells you: %s\n", from, str);
-            free(str);
-          }
-          if (from != NULL) {
-            free(from);
           }
         }
       }
     }
 
-    char *from = xmlGetProp(node, "from");
+    const char *from = rexmpp_xml_find_attr_val(node, "from");
     if (from != NULL) {
-      char *str = rexmpp_console_message_string(s, node);
+      const char *str = rexmpp_console_message_string(s, node);
       if (str != NULL) {
         rexmpp_console_printf(s, "%s tells you: %s\n", from, str);
-        free(str);
       }
-      free(from);
     }
   }
   if (rexmpp_xml_match(node, "jabber:client", "presence")) {
-    char *presence_type = xmlGetProp(node, "type");
-    char *from = xmlGetProp(node, "from");
+    const char *presence_type = rexmpp_xml_find_attr_val(node, "type");
+    const char *from = rexmpp_xml_find_attr_val(node, "from");
     if (presence_type != NULL && ! strcmp(presence_type, "subscribe")) {
       rexmpp_console_printf(s, "%s requests a presence subscription\n", from);
     } else if (presence_type != NULL && ! strcmp(presence_type, "subscribed")) {
@@ -183,74 +169,64 @@ void rexmpp_console_on_recv (rexmpp_t *s, xmlNodePtr node) {
                             (presence_type == NULL) ?
                             "available" :
                             presence_type);
-      xmlNodePtr show = rexmpp_xml_find_child(node, "jabber:client", "show");
+      rexmpp_xml_t *show =
+        rexmpp_xml_find_child(node, "jabber:client", "show");
       if (show != NULL) {
-        char *show_str = xmlNodeGetContent(show);
-        rexmpp_console_printf(s, " (%s)", show_str);
-        free(show_str);
-        show_str = NULL;
+        rexmpp_console_printf(s, " (%s)",
+                              rexmpp_xml_text_child(show));
       }
-      xmlNodePtr status = rexmpp_xml_find_child(node, "jabber:client", "status");
+      rexmpp_xml_t *status =
+        rexmpp_xml_find_child(node, "jabber:client", "status");
       if (status != NULL) {
-        char *status_str = xmlNodeGetContent(status);
-        rexmpp_console_printf(s, ": %s", status_str);
-        free(status_str);
-        status_str = NULL;
+        rexmpp_console_printf(s, ": %s",
+                              rexmpp_xml_text_child(status));
       }
       rexmpp_console_printf(s, "\n");
     }
-    if (presence_type != NULL) {
-      free(presence_type);
-    }
-    if (from != NULL) {
-      free(from);
-    }
   }
 }
 
 
 void rexmpp_console_roster_deleted (rexmpp_t *s,
                                     void *ptr,
-                                    xmlNodePtr req,
-                                    xmlNodePtr response,
+                                    rexmpp_xml_t *req,
+                                    rexmpp_xml_t *response,
                                     int success)
 {
   (void)ptr;
   (void)response;
-  xmlNodePtr item =
+  rexmpp_xml_t *item =
     rexmpp_xml_find_child(rexmpp_xml_find_child(req,
                                                 "jabber:iq:roster",
                                                 "query"),
                           "jabber:iq:roster", "item");
-  char *jid = xmlGetProp(item, "jid");
+  const char *jid = rexmpp_xml_find_attr_val(item, "jid");
   if (success) {
     rexmpp_console_printf(s, "Deleted %s from the roster.\n", jid);
   } else {
     rexmpp_console_printf(s, "Failed to delete %s from the roster.\n", jid);
   }
-  free(jid);
 }
 
 void rexmpp_console_roster_added (rexmpp_t *s,
                                   void *ptr,
-                                  xmlNodePtr req,
-                                  xmlNodePtr response,
+                                  rexmpp_xml_t *req,
+                                  rexmpp_xml_t *response,
                                   int success)
 {
   (void)ptr;
   (void)response;
-  xmlNodePtr item =
+  rexmpp_xml_t *item =
     rexmpp_xml_find_child(rexmpp_xml_find_child(req,
                                                 "jabber:iq:roster",
                                                 "query"),
                           "jabber:iq:roster", "item");
-  char *jid = xmlGetProp(item, "jid");
+  const char *jid = rexmpp_xml_find_attr_val(item, "jid");
   if (success) {
     rexmpp_console_printf(s, "Added %s into the roster.\n", jid);
   } else {
     rexmpp_console_printf(s, "Failed to add %s into the roster.\n", jid);
   }
-  free(jid);
 }
 
 void rexmpp_console_on_run (rexmpp_t *s, rexmpp_err_t result) {
@@ -272,8 +248,8 @@ void rexmpp_console_on_upload (rexmpp_t *s, void *cb_data, const char *url) {
 
 void rexmpp_console_disco_info (rexmpp_t *s,
                                 void *ptr,
-                                xmlNodePtr req,
-                                xmlNodePtr response,
+                                rexmpp_xml_t *req,
+                                rexmpp_xml_t *response,
                                 int success)
 {
   (void)ptr;
@@ -282,57 +258,44 @@ void rexmpp_console_disco_info (rexmpp_t *s,
     rexmpp_console_printf(s, "Failed to discover info.\n");
     return;
   }
-  xmlNodePtr query =
+  rexmpp_xml_t *query =
     rexmpp_xml_find_child(response, "http://jabber.org/protocol/disco#info",
                           "query");
   if (query == NULL) {
     rexmpp_console_printf(s, "No disco#info query in response.\n");
     return;
   }
-  char *from = xmlGetProp(response, "from");
+  const char *from = rexmpp_xml_find_attr_val(response, "from");
   if (from == NULL) {
     rexmpp_console_printf(s, "No 'from' property in response.\n");
     return;
   }
   rexmpp_console_printf(s, "Discovered info for %s:\n", from);
-  xmlNodePtr child = xmlFirstElementChild(query);
+  rexmpp_xml_t *child = rexmpp_xml_first_elem_child(query);
   while (child != NULL) {
     if (rexmpp_xml_match(child, "http://jabber.org/protocol/disco#info",
                          "feature")) {
-      char *var = xmlGetProp(child, "var");
+      const char *var = rexmpp_xml_find_attr_val(child, "var");
       rexmpp_console_printf(s, "- feature var %s\n", var);
-      if (var != NULL) {
-        free(var);
-      }
     } else if (rexmpp_xml_match(child, "http://jabber.org/protocol/disco#info",
                                 "identity")) {
-      char *category = xmlGetProp(child, "category");
-      char *type = xmlGetProp(child, "type");
-      char *name = xmlGetProp(child, "name");
+      const char *category = rexmpp_xml_find_attr_val(child, "category");
+      const char *type = rexmpp_xml_find_attr_val(child, "type");
+      const char *name = rexmpp_xml_find_attr_val(child, "name");
       rexmpp_console_printf(s, "- identity name %s, type %s, category %s\n",
                             name, type, category);
-      if (category != NULL) {
-        free(category);
-      }
-      if (type != NULL) {
-        free(type);
-      }
-      if (name != NULL) {
-        free(name);
-      }
     } else {
       rexmpp_console_printf(s, "Encountered an unknown disco#info element.\n");
     }
-    child = child->next;
+    child = rexmpp_xml_next_elem_sibling(child);
   }
   rexmpp_console_printf(s, "(end of discovered info for %s)\n", from);
-  free(from);
 }
 
 void rexmpp_console_disco_items (rexmpp_t *s,
                                  void *ptr,
-                                 xmlNodePtr req,
-                                 xmlNodePtr response,
+                                 rexmpp_xml_t *req,
+                                 rexmpp_xml_t *response,
                                  int success)
 {
   (void)ptr;
@@ -341,49 +304,39 @@ void rexmpp_console_disco_items (rexmpp_t *s,
     rexmpp_console_printf(s, "Failed to discover items.\n");
     return;
   }
-  xmlNodePtr query =
+  rexmpp_xml_t *query =
     rexmpp_xml_find_child(response, "http://jabber.org/protocol/disco#items",
                           "query");
   if (query == NULL) {
     rexmpp_console_printf(s, "No disco#items query in response.\n");
     return;
   }
-  char *from = xmlGetProp(response, "from");
+  const char *from = rexmpp_xml_find_attr_val(response, "from");
   if (from == NULL) {
     rexmpp_console_printf(s, "No 'from' property in response.\n");
     return;
   }
   rexmpp_console_printf(s, "Discovered items for %s:\n", from);
-  xmlNodePtr child = xmlFirstElementChild(query);
+  rexmpp_xml_t *child = rexmpp_xml_first_elem_child(query);
   while (child != NULL) {
     if (rexmpp_xml_match(child, "http://jabber.org/protocol/disco#items",
                          "item")) {
-      char *jid = xmlGetProp(child, "jid");
-      char *name = xmlGetProp(child, "name");
-      char *node = xmlGetProp(child, "node");
-      rexmpp_console_printf(s, "- item jid %s, name %s, node %s\n", jid, name);
-      if (jid != NULL) {
-        free(jid);
-      }
-      if (name != NULL) {
-        free(name);
-      }
-      if (node != NULL) {
-        free(node);
-      }
+      const char *jid = rexmpp_xml_find_attr_val(child, "jid");
+      const char *name = rexmpp_xml_find_attr_val(child, "name");
+      const char *node = rexmpp_xml_find_attr_val(child, "node");
+      rexmpp_console_printf(s, "- item jid %s, name %s, node %s\n", jid, name, node);
     } else {
       rexmpp_console_printf(s, "Encountered an unknown disco#items element.\n");
     }
-    child = child->next;
+    child = rexmpp_xml_next_elem_sibling(child);
   }
   rexmpp_console_printf(s, "(end of discovered items for %s)\n", from);
-  free(from);
 }
 
 void rexmpp_console_pubsub_node_deleted (rexmpp_t *s,
                                          void *ptr,
-                                         xmlNodePtr req,
-                                         xmlNodePtr response,
+                                         rexmpp_xml_t *req,
+                                         rexmpp_xml_t *response,
                                          int success)
 {
   (void)ptr;
@@ -398,31 +351,29 @@ void rexmpp_console_pubsub_node_deleted (rexmpp_t *s,
 
 void rexmpp_console_blocklist (rexmpp_t *s,
                                void *ptr,
-                               xmlNodePtr req,
-                               xmlNodePtr response,
+                               rexmpp_xml_t *req,
+                               rexmpp_xml_t *response,
                                int success)
 {
   (void)ptr;
   (void)req;
   if (success) {
-    xmlNodePtr bl = rexmpp_xml_find_child(response, "urn:xmpp:blocking", "blocklist");
+    rexmpp_xml_t *bl =
+      rexmpp_xml_find_child(response, "urn:xmpp:blocking", "blocklist");
     if (bl == NULL) {
       rexmpp_console_printf(s, "No blocklist element in the response.\n");
       return;
     }
     rexmpp_console_printf(s, "Block list:");
-    xmlNodePtr child = xmlFirstElementChild(bl);
+    rexmpp_xml_t *child = rexmpp_xml_first_elem_child(bl);
     while (child != NULL) {
       if (rexmpp_xml_match(child, "urn:xmpp:blocking", "item")) {
-        char *jid = xmlGetProp(child, "jid");
+        const char *jid = rexmpp_xml_find_attr_val(child, "jid");
         rexmpp_console_printf(s, " %s", jid);
-        if (jid != NULL) {
-          free(jid);
-        }
       } else {
         rexmpp_console_printf(s, "Encountered an unknown blocklist child element.\n");
       }
-      child = child->next;
+      child = rexmpp_xml_next_elem_sibling(child);
     }
     rexmpp_console_printf(s, "\n");
   } else {
@@ -432,8 +383,8 @@ void rexmpp_console_blocklist (rexmpp_t *s,
 
 void rexmpp_console_blocklist_blocked (rexmpp_t *s,
                                        void *ptr,
-                                       xmlNodePtr req,
-                                       xmlNodePtr response,
+                                       rexmpp_xml_t *req,
+                                       rexmpp_xml_t *response,
                                        int success)
 {
   (void)ptr;
@@ -448,8 +399,8 @@ void rexmpp_console_blocklist_blocked (rexmpp_t *s,
 
 void rexmpp_console_blocklist_unblocked (rexmpp_t *s,
                                          void *ptr,
-                                         xmlNodePtr req,
-                                         xmlNodePtr response,
+                                         rexmpp_xml_t *req,
+                                         rexmpp_xml_t *response,
                                          int success)
 {
   (void)ptr;
@@ -466,7 +417,7 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
   /* todo: buffering */
   (void)str_len;                /* Unused for now (todo). */
   char *words_save_ptr;
-  xmlNodePtr presence;
+  rexmpp_xml_t *presence;
   char *word, *jid_str, *msg_text;
   struct rexmpp_jid jid;
   word = strtok_r(str, " ", &words_save_ptr);
@@ -536,11 +487,14 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       return;
     }
     msg_text = jid_str + strlen(jid_str) + 1;
-    xmlNodePtr msg = rexmpp_xml_add_id(s, xmlNewNode(NULL, "message"));
-    xmlNewNs(msg, "jabber:client", NULL);
-    xmlNewProp(msg, "to", jid.full);
-    xmlNewProp(msg, "type", "chat");
-    xmlNewTextChild(msg, NULL, "body", msg_text);
+
+    rexmpp_xml_t *msg = rexmpp_xml_new_elem("message", "jabber:client");
+    rexmpp_xml_add_id(s, msg);
+    rexmpp_xml_add_attr(msg, "to", jid.full);
+    rexmpp_xml_add_attr(msg, "type", "chat");
+    rexmpp_xml_t *body = rexmpp_xml_new_elem("body", NULL);
+    rexmpp_xml_add_text(body, msg_text);
+    rexmpp_xml_add_child(msg, body);
     rexmpp_send(s, msg);
   }
 
@@ -552,9 +506,9 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       return;
     }
     msg_text = jid_str + strlen(jid_str) + 1;
-    xmlNodePtr body = xmlNewNode(NULL, "body");
-    xmlNewNs(body, "jabber:client", NULL);
-    xmlNodeAddContent(body, msg_text);
+    rexmpp_xml_t *body =
+      rexmpp_xml_new_elem("body", "jabber:client");
+    rexmpp_xml_add_text(body, msg_text);
     const char *rcpt[2];
     rcpt[0] = jid.full;
     rcpt[1] = NULL;
@@ -566,21 +520,20 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
     } else if (strcmp(word, "crypt") == 0) {
       b64 = rexmpp_openpgp_payload(s, body, rcpt, NULL, REXMPP_OX_CRYPT);
     }
-    xmlNodePtr openpgp = xmlNewNode(NULL, "openpgp");
-    openpgp->ns = xmlNewNs(openpgp, "urn:xmpp:openpgp:0", NULL);
-    xmlNodeAddContent(openpgp, b64);
+    rexmpp_xml_t *openpgp =
+      rexmpp_xml_new_elem("openpgp", "urn:xmpp:openpgp:0");
+    rexmpp_xml_add_text(openpgp, b64);
     free(b64);
 
-    xmlNodePtr msg = rexmpp_xml_add_id(s, xmlNewNode(NULL, "message"));
-    xmlNewNs(msg, "jabber:client", NULL);
-    xmlNewProp(msg, "to", jid.full);
-    xmlNewProp(msg, "type", "chat");
-    xmlAddChild(msg, openpgp);
+    rexmpp_xml_t *msg = rexmpp_xml_new_elem("message", "jabber:client");
+    rexmpp_xml_add_id(s, msg);
+    rexmpp_xml_add_attr(msg, "to", jid.full);
+    rexmpp_xml_add_attr(msg, "type", "chat");
+    rexmpp_xml_add_child(msg, openpgp);
 
-    body = xmlNewNode(NULL, "body");
-    xmlNewNs(body, "jabber:client", NULL);
-    xmlNodeAddContent(body, "This is a secret message.");
-    xmlAddChild(msg, body);
+    body = rexmpp_xml_new_elem("body", "jabber:client");
+    rexmpp_xml_add_text(body, "This is a secret message.");
+    rexmpp_xml_add_child(msg, body);
 
     rexmpp_send(s, msg);
   }
@@ -593,11 +546,14 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
         return;
       }
       msg_text = jid_str + strlen(jid_str) + 1;
-      xmlNodePtr msg = rexmpp_xml_add_id(s, xmlNewNode(NULL, "message"));
-      xmlNewNs(msg, "jabber:client", NULL);
-      xmlNewProp(msg, "to", jid.full);
-      xmlNewProp(msg, "type", "groupchat");
-      xmlNewTextChild(msg, NULL, "body", msg_text);
+
+      rexmpp_xml_t *msg = rexmpp_xml_new_elem("message", "jabber:client");
+      rexmpp_xml_add_id(s, msg);
+      rexmpp_xml_add_attr(msg, "to", jid.full);
+      rexmpp_xml_add_attr(msg, "type", "groupchat");
+      rexmpp_xml_t *body = rexmpp_xml_new_elem("body", NULL);
+      rexmpp_xml_add_text(body, msg_text);
+      rexmpp_xml_add_child(msg, body);
       rexmpp_send(s, msg);
     }
     if (! strcmp(word, "join")) {
@@ -615,12 +571,13 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       char *full_jid = malloc(strlen(jid.bare) + strlen(word) + 2);
       snprintf(full_jid, strlen(jid_str) + strlen(word) + 2, "%s/%s",
                jid.bare, word);
-      presence = rexmpp_xml_add_id(s, xmlNewNode(NULL, "presence"));
-      xmlNewProp(presence, "from", s->assigned_jid.full);
-      xmlNewProp(presence, "to", full_jid);
-      xmlNodePtr x = xmlNewNode(NULL, "x");
-      xmlNewNs(x, "http://jabber.org/protocol/muc", NULL);
-      xmlAddChild(presence, x);
+      presence = rexmpp_xml_new_elem("presence", "jabber:client");
+      rexmpp_xml_add_id(s, presence);
+      rexmpp_xml_add_attr(presence, "from", s->assigned_jid.full);
+      rexmpp_xml_add_attr(presence, "to", full_jid);
+      rexmpp_xml_t *x =
+        rexmpp_xml_new_elem("x", "http://jabber.org/protocol/muc");
+      rexmpp_xml_add_child(presence, x);
       rexmpp_send(s, presence);
       free(full_jid);
     }
@@ -639,10 +596,11 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       char *full_jid = malloc(strlen(jid.bare) + strlen(word) + 2);
       snprintf(full_jid, strlen(jid_str) + strlen(word) + 2, "%s/%s",
                jid.bare, word);
-      presence = rexmpp_xml_add_id(s, xmlNewNode(NULL, "presence"));
-      xmlNewProp(presence, "from", s->assigned_jid.full);
-      xmlNewProp(presence, "to", full_jid);
-      xmlNewProp(presence, "type", "unavailable");
+      presence = rexmpp_xml_new_elem("presence", "jabber:client");
+      rexmpp_xml_add_id(s, presence);
+      rexmpp_xml_add_attr(presence, "from", s->assigned_jid.full);
+      rexmpp_xml_add_attr(presence, "to", full_jid);
+      rexmpp_xml_add_attr(presence, "type", "unavailable");
       rexmpp_send(s, presence);
       free(full_jid);
     }
@@ -654,25 +612,26 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       return;
     }
     if (! strcmp(word, "list")) {
-      xmlNodePtr item;
+      rexmpp_xml_t *item;
       for (item = s->roster_items;
            item != NULL;
-           item = xmlNextElementSibling(item)) {
-        char *item_jid = xmlGetProp(item, "jid");
-        char *item_ask = xmlGetProp(item, "ask");
-        char *item_subscription = xmlGetProp(item, "subscription");
+           item = item->next) {
+        const char *item_jid = rexmpp_xml_find_attr_val(item, "jid");
+        const char *item_ask = rexmpp_xml_find_attr_val(item, "ask");
+        const char *item_subscription =
+          rexmpp_xml_find_attr_val(item, "subscription");
         char *item_presence = "unavailable";
         if (s->track_roster_presence) {
           for (presence = s->roster_presence;
                presence != NULL;
-               presence = xmlNextElementSibling(presence)) {
-            char *presence_from = xmlGetProp(presence, "from");
+               presence = presence->next) {
+            const char *presence_from =
+              rexmpp_xml_find_attr_val(presence, "from");
             if (presence_from != NULL) {
               rexmpp_jid_parse(presence_from, &jid);
               if (! strcmp(jid.bare, item_jid)) {
                 item_presence = "available";
               }
-              free(presence_from);
             }
           }
         }
@@ -681,28 +640,19 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
                               "presence = %s\n",
                               item_jid, item_subscription, item_ask,
                               item_presence);
-        if (item_jid != NULL) {
-          free(item_jid);
-        }
-        if (item_ask != NULL) {
-          free(item_ask);
-        }
-        if (item_subscription != NULL) {
-          free(item_subscription);
-        }
       }
     } else if (! strcmp(word, "delete")) {
       word = strtok_r(NULL, " ", &words_save_ptr);
       if (word == NULL) {
         return;
       }
-      xmlNodePtr delete_item = xmlNewNode(NULL, "item");
-      delete_item->ns = xmlNewNs(delete_item, "jabber:iq:roster", NULL);
-      xmlNewProp(delete_item, "jid", word);
-      xmlNewProp(delete_item, "subscription", "remove");
-      xmlNodePtr delete_query = xmlNewNode(NULL, "query");
-      delete_query->ns = xmlNewNs(delete_query, "jabber:iq:roster", NULL);
-      xmlAddChild(delete_query, delete_item);
+      rexmpp_xml_t *delete_item =
+        rexmpp_xml_new_elem("item", "jabber:iq:roster");
+      rexmpp_xml_add_attr(delete_item, "jid", word);
+      rexmpp_xml_add_attr(delete_item, "subscription", "remove");
+      rexmpp_xml_t *delete_query =
+        rexmpp_xml_new_elem("query", "jabber:iq:roster");
+      rexmpp_xml_add_child(delete_query, delete_item);
       rexmpp_iq_new(s, "set", NULL, delete_query,
                     rexmpp_console_roster_deleted, NULL);
     } else if (! strcmp(word, "add")) {
@@ -710,13 +660,13 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       if (word == NULL) {
         return;
       }
-      xmlNodePtr delete_item = xmlNewNode(NULL, "item");
-      delete_item->ns = xmlNewNs(delete_item, "jabber:iq:roster", NULL);
-      xmlNewProp(delete_item, "jid", word);
-      xmlNodePtr delete_query = xmlNewNode(NULL, "query");
-      delete_query->ns = xmlNewNs(delete_query, "jabber:iq:roster", NULL);
-      xmlAddChild(delete_query, delete_item);
-      rexmpp_iq_new(s, "set", NULL, delete_query,
+      rexmpp_xml_t *add_item =
+        rexmpp_xml_new_elem("item", "jabber:iq:roster");
+      rexmpp_xml_add_attr(add_item, "jid", word);
+      rexmpp_xml_t *add_query =
+        rexmpp_xml_new_elem("query", "jabber:iq:roster");
+      rexmpp_xml_add_child(add_query, add_item);
+      rexmpp_iq_new(s, "set", NULL, add_query,
                     rexmpp_console_roster_added, NULL);
     }
   }
@@ -731,9 +681,10 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       if (word == NULL) {
         return;
       }
-      presence = rexmpp_xml_add_id(s, xmlNewNode(NULL, "presence"));
-      xmlNewProp(presence, "to", word);
-      xmlNewProp(presence, "type", "subscribe");
+      presence = rexmpp_xml_new_elem("presence", "jabber:client");
+      rexmpp_xml_add_id(s, presence);
+      rexmpp_xml_add_attr(presence, "to",  word);
+      rexmpp_xml_add_attr(presence, "type", "subscribe");
       rexmpp_send(s, presence);
     }
     if (! strcmp(word, "approve")) {
@@ -741,9 +692,10 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       if (word == NULL) {
         return;
       }
-      presence = rexmpp_xml_add_id(s, xmlNewNode(NULL, "presence"));
-      xmlNewProp(presence, "to", word);
-      xmlNewProp(presence, "type", "subscribed");
+      presence = rexmpp_xml_new_elem("presence", "jabber:client");
+      rexmpp_xml_add_id(s, presence);
+      rexmpp_xml_add_attr(presence, "to", word);
+      rexmpp_xml_add_attr(presence, "type", "subscribed");
       rexmpp_send(s, presence);
     }
     if (! strcmp(word, "deny")) {
@@ -751,9 +703,10 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       if (word == NULL) {
         return;
       }
-      presence = rexmpp_xml_add_id(s, xmlNewNode(NULL, "presence"));
-      xmlNewProp(presence, "to", word);
-      xmlNewProp(presence, "type", "unsubscribed");
+      presence = rexmpp_xml_new_elem("presence", "jabber:client");
+      rexmpp_xml_add_id(s, presence);
+      rexmpp_xml_add_attr(presence, "to",  word);
+      rexmpp_xml_add_attr(presence, "type", "unsubscribed");
       rexmpp_send(s, presence);
     }
   }
@@ -773,7 +726,7 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       char *sid = strtok_r(NULL, " ", &words_save_ptr);
       if (sid != NULL) {
         rexmpp_jingle_session_terminate(s, sid,
-                                        rexmpp_xml_new_node("success",
+                                        rexmpp_xml_new_elem("success",
                                                             "urn:xmpp:jingle:1"),
                                         NULL);
       }
@@ -781,7 +734,7 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       char *sid = strtok_r(NULL, " ", &words_save_ptr);
       if (sid != NULL) {
         rexmpp_jingle_session_terminate(s, sid,
-                                        rexmpp_xml_new_node("decline",
+                                        rexmpp_xml_new_elem("decline",
                                                             "urn:xmpp:jingle:1"),
                                         NULL);
       }
@@ -824,8 +777,8 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       if (jid == NULL) {
         return;
       }
-      xmlNodePtr query =
-        rexmpp_xml_new_node("query",
+      rexmpp_xml_t *query =
+        rexmpp_xml_new_elem("query",
                             "http://jabber.org/protocol/disco#info");
       rexmpp_iq_new(s, "get", jid, query, rexmpp_console_disco_info, NULL);
     }
@@ -834,8 +787,8 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
       if (jid == NULL) {
         return;
       }
-      xmlNodePtr query =
-        rexmpp_xml_new_node("query",
+      rexmpp_xml_t *query =
+        rexmpp_xml_new_elem("query",
                             "http://jabber.org/protocol/disco#items");
       rexmpp_iq_new(s, "get", jid, query, rexmpp_console_disco_items, NULL);
     }
@@ -865,27 +818,32 @@ void rexmpp_console_feed (rexmpp_t *s, char *str, ssize_t str_len) {
   if (! strcmp(word, "blocklist")) {
     word = strtok_r(NULL, " ", &words_save_ptr);
     if (word == NULL) {
-      xmlNodePtr bl = rexmpp_xml_new_node("blocklist", "urn:xmpp:blocking");
+      rexmpp_xml_t *bl =
+        rexmpp_xml_new_elem("blocklist", "urn:xmpp:blocking");
       rexmpp_iq_new(s, "get", NULL, bl, rexmpp_console_blocklist, NULL);
     } else if (! strcmp(word, "block")) {
       char *jid = strtok_r(NULL, " ", &words_save_ptr);
       if (jid == NULL) {
         return;
       }
-      xmlNodePtr bl = rexmpp_xml_new_node("block", "urn:xmpp:blocking");
-      xmlNodePtr item = rexmpp_xml_new_node("item", "urn:xmpp:blocking");
-      xmlNewProp(item, "jid", jid);
-      xmlAddChild(bl, item);
+      rexmpp_xml_t *bl =
+        rexmpp_xml_new_elem("block", "urn:xmpp:blocking");
+      rexmpp_xml_t *item =
+        rexmpp_xml_new_elem("item", "urn:xmpp:blocking");
+      rexmpp_xml_add_attr(item, "jid", jid);
+      rexmpp_xml_add_child(bl, item);
       rexmpp_iq_new(s, "set", NULL, bl, rexmpp_console_blocklist_blocked, NULL);
     } else if (! strcmp(word, "unblock")) {
       char *jid = strtok_r(NULL, " ", &words_save_ptr);
       if (jid == NULL) {
         return;
       }
-      xmlNodePtr bl = rexmpp_xml_new_node("unblock", "urn:xmpp:blocking");
-      xmlNodePtr item = rexmpp_xml_new_node("item", "urn:xmpp:blocking");
-      xmlNewProp(item, "jid", jid);
-      xmlAddChild(bl, item);
+      rexmpp_xml_t *bl =
+        rexmpp_xml_new_elem("unblock", "urn:xmpp:blocking");
+      rexmpp_xml_t *item =
+        rexmpp_xml_new_elem("item", "urn:xmpp:blocking");
+      rexmpp_xml_add_attr(item, "jid", jid);
+      rexmpp_xml_add_child(bl, item);
       rexmpp_iq_new(s, "set", NULL, bl, rexmpp_console_blocklist_unblocked, NULL);
     }
   }