@helm2/poc_jenki_rce 0.0.1

package/src/xml_node.h

@@ -0,0 +1,73 @@
+// Copyright 2009, Squish Tech, LLC.
+#ifndef SRC_XML_NODE_H_
+#define SRC_XML_NODE_H_
+
+#include "nan.h"
+#include <libxml/tree.h>
+
+namespace libxmljs {
+
+class XmlNode : public Nan::ObjectWrap {
+public:
+  xmlNode *xml_obj;
+
+  // reference to a parent XmlNode or XmlElement
+  xmlNode *ancestor;
+
+  // referencing functions
+  void ref_wrapped_ancestor();
+  void unref_wrapped_ancestor();
+  xmlNode *get_wrapped_ancestor();
+  int refs() { return refs_; };
+
+  // the doc ref'd by this proxy
+  xmlDoc *doc;
+
+  explicit XmlNode(xmlNode *node);
+  virtual ~XmlNode();
+
+  static void Initialize(v8::Local<v8::Object> target);
+  static Nan::Persistent<v8::FunctionTemplate> constructor_template;
+
+  // create new XmlElement, XmlAttribute, etc. to wrap a libxml xmlNode
+  static v8::Local<v8::Value> New(xmlNode *node);
+
+protected:
+  static NAN_METHOD(Doc);
+  static NAN_METHOD(Namespace);
+  static NAN_METHOD(Namespaces);
+  static NAN_METHOD(Parent);
+  static NAN_METHOD(NextSibling);
+  static NAN_METHOD(PrevSibling);
+  static NAN_METHOD(LineNumber);
+  static NAN_METHOD(Type);
+  static NAN_METHOD(ToString);
+  static NAN_METHOD(Remove);
+  static NAN_METHOD(Clone);
+
+  v8::Local<v8::Value> get_doc();
+  v8::Local<v8::Value> remove_namespace();
+  v8::Local<v8::Value> get_namespace();
+  void set_namespace(xmlNs *ns);
+  xmlNs *find_namespace(const char *search_str);
+  v8::Local<v8::Value> get_all_namespaces();
+  v8::Local<v8::Value> get_local_namespaces();
+  v8::Local<v8::Value> get_parent();
+  v8::Local<v8::Value> get_prev_sibling();
+  v8::Local<v8::Value> get_next_sibling();
+  v8::Local<v8::Value> get_line_number();
+  v8::Local<v8::Value> clone(bool recurse);
+  v8::Local<v8::Value> get_type();
+  v8::Local<v8::Value> to_string(int options = 0);
+  void remove();
+  void add_child(xmlNode *child);
+  void add_prev_sibling(xmlNode *element);
+  void add_next_sibling(xmlNode *element);
+  void replace_element(xmlNode *element);
+  void replace_text(const char *content);
+  xmlNode *import_node(xmlNode *node);
+};
+
+} // namespace libxmljs
+
+#endif // SRC_XML_NODE_H_

package/src/xml_pi.cc

@@ -0,0 +1,161 @@
+#include <node.h>
+
+#include <cstring>
+
+#include "libxmljs.h"
+
+#include "xml_attribute.h"
+#include "xml_document.h"
+#include "xml_pi.h"
+#include "xml_xpath_context.h"
+
+using namespace v8;
+
+namespace libxmljs {
+
+Nan::Persistent<FunctionTemplate>
+    XmlProcessingInstruction::constructor_template;
+
+// doc, content
+NAN_METHOD(XmlProcessingInstruction::New) {
+  NAN_CONSTRUCTOR_CHECK(ProcessingInstruction)
+  Nan::HandleScope scope;
+
+  // if we were created for an existing xml node, then we don't need
+  // to create a new node on the document
+  if (info.Length() == 0) {
+    return info.GetReturnValue().Set(info.Holder());
+  }
+
+  DOCUMENT_ARG_CHECK
+  if (!info[1]->IsString()) {
+    Nan::ThrowError("name argument must be of type string");
+    return;
+  }
+
+  XmlDocument *document = Nan::ObjectWrap::Unwrap<XmlDocument>(doc);
+  assert(document);
+
+  Nan::Utf8String name(info[1]);
+
+  Local<Value> contentOpt;
+  if (info[2]->IsString()) {
+    contentOpt = info[2];
+  } else if (!info[2]->IsNullOrUndefined()) {
+    Nan::ThrowError("content argument must be of type string");
+    return;
+  }
+  Nan::Utf8String contentRaw(contentOpt);
+  const char *content = (contentRaw.length()) ? *contentRaw : NULL;
+
+  xmlNode *pi = xmlNewDocPI(document->xml_obj, (const xmlChar *)*name,
+                            (xmlChar *)content);
+
+  XmlProcessingInstruction *processing_instruction =
+      new XmlProcessingInstruction(pi);
+  pi->_private = processing_instruction;
+  processing_instruction->Wrap(info.Holder());
+
+  // this prevents the document from going away
+  Nan::Set(info.Holder(), Nan::New<String>("document").ToLocalChecked(),
+           info[0])
+      .Check();
+
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+NAN_METHOD(XmlProcessingInstruction::Name) {
+  Nan::HandleScope scope;
+  XmlProcessingInstruction *processing_instruction =
+      Nan::ObjectWrap::Unwrap<XmlProcessingInstruction>(info.Holder());
+  assert(processing_instruction);
+
+  if (info.Length() == 0)
+    return info.GetReturnValue().Set(processing_instruction->get_name());
+
+  Nan::Utf8String name(Nan::To<String>(info[0]).ToLocalChecked());
+  processing_instruction->set_name(*name);
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+NAN_METHOD(XmlProcessingInstruction::Text) {
+  Nan::HandleScope scope;
+  XmlProcessingInstruction *processing_instruction =
+      Nan::ObjectWrap::Unwrap<XmlProcessingInstruction>(info.Holder());
+  assert(processing_instruction);
+
+  if (info.Length() == 0) {
+    return info.GetReturnValue().Set(processing_instruction->get_content());
+  } else {
+    processing_instruction->set_content(*Nan::Utf8String(info[0]));
+  }
+
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+void XmlProcessingInstruction::set_name(const char *name) {
+  xmlNodeSetName(xml_obj, (const xmlChar *)name);
+}
+
+Local<Value> XmlProcessingInstruction::get_name() {
+  Nan::EscapableHandleScope scope;
+  if (xml_obj->name)
+    return scope.Escape(
+        Nan::New<String>((const char *)xml_obj->name).ToLocalChecked());
+  else
+    return scope.Escape(Nan::Undefined());
+}
+
+void XmlProcessingInstruction::set_content(const char *content) {
+  xmlNodeSetContent(xml_obj, (xmlChar *)content);
+}
+
+Local<Value> XmlProcessingInstruction::get_content() {
+  Nan::EscapableHandleScope scope;
+  xmlChar *content = xmlNodeGetContent(xml_obj);
+  if (content) {
+    Local<String> ret_content =
+        Nan::New<String>((const char *)content).ToLocalChecked();
+    xmlFree(content);
+    return scope.Escape(ret_content);
+  }
+
+  return scope.Escape(Nan::New<String>("").ToLocalChecked());
+}
+
+Local<Object> XmlProcessingInstruction::New(xmlNode *node) {
+  Nan::EscapableHandleScope scope;
+  if (node->_private) {
+    return scope.Escape(static_cast<XmlNode *>(node->_private)->handle());
+  }
+
+  XmlProcessingInstruction *processing_instruction =
+      new XmlProcessingInstruction(node);
+  Local<Object> obj =
+      Nan::NewInstance(
+          Nan::GetFunction(Nan::New(constructor_template)).ToLocalChecked())
+          .ToLocalChecked();
+  processing_instruction->Wrap(obj);
+  return scope.Escape(obj);
+}
+
+XmlProcessingInstruction::XmlProcessingInstruction(xmlNode *node)
+    : XmlNode(node) {}
+
+void XmlProcessingInstruction::Initialize(Local<Object> target) {
+  Nan::HandleScope scope;
+  Local<FunctionTemplate> t =
+      Nan::New<FunctionTemplate>(static_cast<NAN_METHOD((*))>(New));
+  t->Inherit(Nan::New(XmlNode::constructor_template));
+  t->InstanceTemplate()->SetInternalFieldCount(1);
+  constructor_template.Reset(t);
+
+  Nan::SetPrototypeMethod(t, "name", XmlProcessingInstruction::Name);
+
+  Nan::SetPrototypeMethod(t, "text", XmlProcessingInstruction::Text);
+
+  Nan::Set(target, Nan::New<String>("ProcessingInstruction").ToLocalChecked(),
+           Nan::GetFunction(t).ToLocalChecked());
+}
+
+} // namespace libxmljs

package/src/xml_pi.h

@@ -0,0 +1,34 @@
+#ifndef SRC_XML_PI_H_
+#define SRC_XML_PI_H_
+
+#include "libxmljs.h"
+#include "xml_node.h"
+
+namespace libxmljs {
+
+class XmlProcessingInstruction : public XmlNode {
+public:
+  explicit XmlProcessingInstruction(xmlNode *node);
+
+  static void Initialize(v8::Local<v8::Object> target);
+
+  static Nan::Persistent<v8::FunctionTemplate> constructor_template;
+
+  // create new xml comment to wrap the node
+  static v8::Local<v8::Object> New(xmlNode *node);
+
+protected:
+  static NAN_METHOD(New);
+  static NAN_METHOD(Name);
+  static NAN_METHOD(Text);
+
+  void set_name(const char *name);
+
+  v8::Local<v8::Value> get_name();
+  void set_content(const char *content);
+  v8::Local<v8::Value> get_content();
+};
+
+} // namespace libxmljs
+
+#endif // SRC_XML_PI_H_

package/src/xml_sax_parser.cc

@@ -0,0 +1,424 @@
+// Copyright 2009, Squish Tech, LLC.
+
+#include <node.h>
+
+#include <libxml/parserInternals.h>
+
+#include "libxmljs.h"
+
+#include "xml_sax_parser.h"
+
+libxmljs::XmlSaxParser *LXJS_GET_PARSER_FROM_CONTEXT(void *context) {
+  _xmlParserCtxt *the_context = static_cast<_xmlParserCtxt *>(context);
+  return static_cast<libxmljs::XmlSaxParser *>(the_context->_private);
+}
+
+#define EMIT_SYMBOL_STRING "emit"
+
+using namespace v8;
+Nan::Persistent<String> emit_symbol;
+
+namespace libxmljs {
+
+XmlSaxParser::XmlSaxParser() : context_(NULL) {
+  xmlSAXHandler tmp = {
+      0, // internalSubset;
+      0, // isStandalone;
+      0, // hasInternalSubset;
+      0, // hasExternalSubset;
+      0, // resolveEntity;
+      0, // getEntity;
+      0, // entityDecl;
+      0, // notationDecl;
+      0, // attributeDecl;
+      0, // elementDecl;
+      0, // unparsedEntityDecl;
+      0, // setDocumentLocator;
+      XmlSaxParser::start_document,
+      XmlSaxParser::end_document, // endDocument;
+      0,                          // startElement;
+      0,                          // endElement;
+      0,                          // reference;
+      XmlSaxParser::characters,   // characters;
+      0,                          // ignorableWhitespace;
+      0,                          // processingInstruction;
+      XmlSaxParser::comment,      // comment;
+      XmlSaxParser::warning,      // warning;
+      XmlSaxParser::error,        // error;
+      0, // fatalError; /* unused error() get all the errors */
+      0, // getParameterEntity;
+      XmlSaxParser::cdata_block,      // cdataBlock;
+      0,                              // externalSubset;
+      XML_SAX2_MAGIC,                 /* force SAX2 */
+      this,                           /* _private */
+      XmlSaxParser::start_element_ns, // startElementNs;
+      XmlSaxParser::end_element_ns,   // endElementNs;
+      0 // SaxParserCallback::structured_error // serror
+  };
+
+  sax_handler_ = tmp;
+}
+
+XmlSaxParser::~XmlSaxParser() { this->releaseContext(); }
+
+void XmlSaxParser::initializeContext() {
+  assert(context_);
+  context_->validate = 0;
+  context_->_private = this;
+}
+
+void XmlSaxParser::releaseContext() {
+  if (context_) {
+    context_->_private = 0;
+    if (context_->myDoc != NULL) {
+      xmlFreeDoc(context_->myDoc);
+      context_->myDoc = NULL;
+    }
+
+    xmlFreeParserCtxt(context_);
+    context_ = 0;
+  }
+}
+
+NAN_METHOD(XmlSaxParser::NewParser) {
+  Nan::HandleScope scope;
+  XmlSaxParser *parser = new XmlSaxParser();
+  parser->Wrap(info.Holder());
+
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+NAN_METHOD(XmlSaxParser::NewPushParser) {
+  Nan::HandleScope scope;
+  XmlSaxParser *parser = new XmlSaxParser();
+  parser->initialize_push_parser();
+  parser->Wrap(info.Holder());
+
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+void XmlSaxParser::Callback(const char *what, int argc, Local<Value> argv[]) {
+  Nan::HandleScope scope;
+
+  // new arguments array with first argument being the event name
+  Local<Value> *args = new Local<Value>[argc + 1];
+  args[0] = Nan::New<String>(what).ToLocalChecked();
+  for (int i = 1; i <= argc; ++i) {
+    args[i] = argv[i - 1];
+  }
+
+  // get the 'emit' function from ourselves
+  Local<Value> emit_v =
+      Nan::Get(this->handle(), Nan::New(emit_symbol)).ToLocalChecked();
+  assert(emit_v->IsFunction());
+
+  // trigger the event
+  Nan::AsyncResource res("nan:makeCallback");
+  res.runInAsyncScope(this->handle(), Local<Function>::Cast(emit_v), argc + 1,
+                      args);
+
+  delete[] args;
+}
+
+NAN_METHOD(XmlSaxParser::Push) {
+  Nan::HandleScope scope;
+  LIBXMLJS_ARGUMENT_TYPE_CHECK(info[0], IsString,
+                               "Bad Argument: parseString requires a string");
+
+  XmlSaxParser *parser = Nan::ObjectWrap::Unwrap<XmlSaxParser>(info.Holder());
+
+  Nan::Utf8String parsable(Nan::To<String>(info[0]).ToLocalChecked());
+
+  bool terminate = info.Length() > 1
+                       ? Nan::To<Boolean>(info[1]).ToLocalChecked()->Value()
+                       : false;
+
+  parser->push(*parsable, parsable.length(), terminate);
+
+  return info.GetReturnValue().Set(Nan::True());
+}
+
+void XmlSaxParser::initialize_push_parser() {
+  context_ = xmlCreatePushParserCtxt(&sax_handler_, NULL, NULL, 0, "");
+  context_->replaceEntities = 1;
+  initializeContext();
+}
+
+void XmlSaxParser::push(const char *str, unsigned int size,
+                        bool terminate = false) {
+  xmlParseChunk(context_, str, size, terminate);
+}
+
+NAN_METHOD(XmlSaxParser::ParseString) {
+  Nan::HandleScope scope;
+  LIBXMLJS_ARGUMENT_TYPE_CHECK(info[0], IsString,
+                               "Bad Argument: parseString requires a string");
+
+  XmlSaxParser *parser = Nan::ObjectWrap::Unwrap<XmlSaxParser>(info.Holder());
+
+  Nan::Utf8String parsable(info[0]);
+  parser->parse_string(*parsable, parsable.length());
+
+  // TODO(sprsquish): return based on the parser
+  return info.GetReturnValue().Set(Nan::True());
+}
+
+void XmlSaxParser::parse_string(const char *str, unsigned int size) {
+  context_ = xmlCreateMemoryParserCtxt(str, size);
+  initializeContext();
+  context_->replaceEntities = 1;
+  xmlSAXHandler *old_sax = context_->sax;
+  context_->sax = &sax_handler_;
+  xmlParseDocument(context_);
+  context_->sax = old_sax;
+  releaseContext();
+}
+
+void XmlSaxParser::start_document(void *context) {
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+  parser->Callback("startDocument");
+}
+
+void XmlSaxParser::end_document(void *context) {
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+  parser->Callback("endDocument");
+}
+
+void XmlSaxParser::start_element_ns(void *context, const xmlChar *localname,
+                                    const xmlChar *prefix, const xmlChar *uri,
+                                    int nb_namespaces,
+                                    const xmlChar **namespaces,
+                                    int nb_attributes, int nb_defaulted,
+                                    const xmlChar **attributes) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+
+  const int argc = 5;
+  const xmlChar *nsPref, *nsUri, *attrLocal, *attrPref, *attrUri, *attrVal;
+  int i, j;
+
+  Local<Array> elem;
+
+  // Initialize argv with localname, prefix, and uri
+  Local<Value> argv[argc] = {
+      Nan::New<String>((const char *)localname).ToLocalChecked()};
+
+  // Build attributes list
+  // Each attribute is an array of [localname, prefix, URI, value, end]
+  Local<Array> attrList = Nan::New<Array>(nb_attributes);
+  if (attributes) {
+    for (i = 0, j = 0; j < nb_attributes; i += 5, j++) {
+      attrLocal = attributes[i + 0];
+      attrPref = attributes[i + 1];
+      attrUri = attributes[i + 2];
+      attrVal = attributes[i + 3];
+
+      elem = Nan::New<Array>(4);
+
+      Nan::Set(elem, Nan::New<Integer>(0),
+               Nan::New<String>((const char *)attrLocal, xmlStrlen(attrLocal))
+                   .ToLocalChecked());
+
+      Nan::Set(elem, Nan::New<Integer>(1),
+               Nan::New<String>((const char *)attrPref, xmlStrlen(attrPref))
+                   .ToLocalChecked());
+
+      Nan::Set(elem, Nan::New<Integer>(2),
+               Nan::New<String>((const char *)attrUri, xmlStrlen(attrUri))
+                   .ToLocalChecked());
+
+      Nan::Set(
+          elem, Nan::New<Integer>(3),
+          Nan::New<String>((const char *)attrVal, attributes[i + 4] - attrVal)
+              .ToLocalChecked());
+
+      Nan::Set(attrList, Nan::New<Integer>(j), elem);
+    }
+  }
+  argv[1] = attrList;
+
+  if (prefix) {
+    argv[2] = Nan::New<String>((const char *)prefix).ToLocalChecked();
+  } else {
+    argv[2] = Nan::Null();
+  }
+
+  if (uri) {
+    argv[3] = Nan::New<String>((const char *)uri).ToLocalChecked();
+  } else {
+    argv[3] = Nan::Null();
+  }
+
+  // Build namespace array of arrays [[prefix, ns], [prefix, ns]]
+  Local<Array> nsList = Nan::New<Array>(nb_namespaces);
+  if (namespaces) {
+    for (i = 0, j = 0; j < nb_namespaces; j++) {
+      nsPref = namespaces[i++];
+      nsUri = namespaces[i++];
+
+      elem = Nan::New<Array>(2);
+      if (xmlStrlen(nsPref) == 0) {
+        Nan::Set(elem, Nan::New<Integer>(0), Nan::Null());
+      } else {
+        Nan::Set(elem, Nan::New<Integer>(0),
+                 Nan::New<String>((const char *)nsPref, xmlStrlen(nsPref))
+                     .ToLocalChecked());
+      }
+
+      Nan::Set(elem, Nan::New<Integer>(1),
+               Nan::New<String>((const char *)nsUri, xmlStrlen(nsUri))
+                   .ToLocalChecked());
+
+      Nan::Set(nsList, Nan::New<Integer>(j), elem);
+    }
+  }
+  argv[4] = nsList;
+
+  parser->Callback("startElementNS", argc, argv);
+}
+
+void XmlSaxParser::end_element_ns(void *context, const xmlChar *localname,
+                                  const xmlChar *prefix, const xmlChar *uri) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+
+  Local<Value> argv[3];
+  argv[0] = Nan::New<String>((const char *)localname).ToLocalChecked();
+
+  if (prefix) {
+    argv[1] = Nan::New<String>((const char *)prefix).ToLocalChecked();
+  } else {
+    argv[1] = Nan::Null();
+  }
+
+  if (uri) {
+    argv[2] = Nan::New<String>((const char *)uri).ToLocalChecked();
+  } else {
+    argv[2] = Nan::Null();
+  }
+
+  parser->Callback("endElementNS", 3, argv);
+}
+
+void XmlSaxParser::characters(void *context, const xmlChar *ch, int len) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+
+  Local<Value> argv[1] = {
+      Nan::New<String>((const char *)ch, len).ToLocalChecked()};
+  parser->Callback("characters", 1, argv);
+}
+
+void XmlSaxParser::comment(void *context, const xmlChar *value) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+  Local<Value> argv[1] = {
+      Nan::New<String>((const char *)value).ToLocalChecked()};
+  parser->Callback("comment", 1, argv);
+}
+
+void XmlSaxParser::cdata_block(void *context, const xmlChar *value, int len) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+  Local<Value> argv[1] = {
+      Nan::New<String>((const char *)value, len).ToLocalChecked()};
+  parser->Callback("cdata", 1, argv);
+}
+
+#ifdef WIN32
+// https://github.com/json-c/json-c/blob/master/printbuf.c
+// Copyright (c) 2004, 2005 Metaparadigm Pte Ltd
+static int vasprintf(char **buf, const char *fmt, va_list ap) {
+  int chars;
+  char *b;
+
+  if (!buf) {
+    return -1;
+  }
+
+  chars = _vscprintf(fmt, ap) + 1;
+
+  b = (char *)malloc(sizeof(char) * chars);
+  if (!b) {
+    return -1;
+  }
+
+  if ((chars = vsprintf(b, fmt, ap)) < 0) {
+    free(b);
+  } else {
+    *buf = b;
+  }
+
+  return chars;
+}
+#endif /* WIN32 */
+
+void XmlSaxParser::warning(void *context, const char *msg, ...) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+
+  char *message;
+
+  va_list args;
+  va_start(args, msg);
+  if (vasprintf(&message, msg, args) >= 0) {
+    Local<Value> argv[1] = {
+        Nan::New<String>((const char *)message).ToLocalChecked()};
+    parser->Callback("warning", 1, argv);
+  }
+
+  va_end(args);
+  free(message);
+}
+
+void XmlSaxParser::error(void *context, const char *msg, ...) {
+  Nan::HandleScope scope;
+  libxmljs::XmlSaxParser *parser = LXJS_GET_PARSER_FROM_CONTEXT(context);
+
+  char *message;
+
+  va_list args;
+  va_start(args, msg);
+  if (vasprintf(&message, msg, args) >= 0) {
+    Local<Value> argv[1] = {
+        Nan::New<String>((const char *)message).ToLocalChecked()};
+    parser->Callback("error", 1, argv);
+  }
+
+  va_end(args);
+  free(message);
+}
+
+void XmlSaxParser::Initialize(Local<Object> target) {
+  Nan::HandleScope scope;
+
+  emit_symbol.Reset(Nan::New<String>(EMIT_SYMBOL_STRING).ToLocalChecked());
+
+  // SAX Parser
+  Local<FunctionTemplate> parser_t = Nan::New<FunctionTemplate>(NewParser);
+
+  Nan::Persistent<FunctionTemplate> sax_parser_template;
+  sax_parser_template.Reset(parser_t);
+
+  parser_t->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Nan::SetPrototypeMethod(parser_t, "parseString", XmlSaxParser::ParseString);
+
+  Nan::Set(target, Nan::New<String>("SaxParser").ToLocalChecked(),
+           Nan::GetFunction(parser_t).ToLocalChecked());
+
+  Local<FunctionTemplate> push_parser_t =
+      Nan::New<FunctionTemplate>(NewPushParser);
+
+  // Push Parser
+  Nan::Persistent<FunctionTemplate> sax_push_parser_template;
+  sax_push_parser_template.Reset(push_parser_t);
+
+  push_parser_t->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Nan::SetPrototypeMethod(push_parser_t, "push", XmlSaxParser::Push);
+
+  Nan::Set(target, Nan::New<String>("SaxPushParser").ToLocalChecked(),
+           Nan::GetFunction(push_parser_t).ToLocalChecked());
+}
+} // namespace libxmljs