Fix segfaults in destructor using xmlDeregisterNodeDefault callback

[rchipka]

Libxml has a few functions that accept callbacks. One of those functions is xmlDeregisterNodeDefault. This function sets the default callback function that is called when any node is "deregistered" (i.e. before freeing). The callback is also called for all of the node's children.

We can use this function to prevent bad access related segmentation faults by setting a flag saying that the xmlNode has already been freed. The XmlNode destructor code will then check the flag and return if it has already been freed.

In libxmljs.cc:

// set up our callback function that will set the flag

void flagNode(xmlNode* node) {
  if (node->_private) {
    (static_cast<XmlNode*>(node->_private))->isFree = true;
  }
  return;
}

// set the callback function to be called

LibXMLJS::LibXMLJS()
{
    xmlDeregisterNodeDefault(flagNode);

....

}

In xml_node.h:

class XmlNode : public node::ObjectWrap {
public:
    bool isFree;

In xml_node.cc:

// The constructor will set the default value to false

XmlNode::XmlNode(xmlNode* node) : xml_obj(node) {
    this->isFree = false;

...
}


// The destructor will check the value

XmlNode::~XmlNode() {
    if (this->isFree) {
      return;
    }

...
}

Now every time an xmlNode (or any of its children) is freed, the callback will set a flag on the libxmljs Node object saying that the xmlNode has already been freed. Since the destructor will have this information it will not attempt to free the node or access properties of the node causing a segfault. This solution works without any additional ref counting code or memory leaks.