@helm2/poc_jenki_rce 0.0.1

package/src/xml_sax_parser.h

@@ -0,0 +1,73 @@
+// Copyright 2009, Squish Tech, LLC.
+#ifndef SRC_XML_SAX_PARSER_H_
+#define SRC_XML_SAX_PARSER_H_
+
+#include <node.h>
+
+namespace libxmljs {
+
+class XmlSaxParser : public Nan::ObjectWrap {
+public:
+  XmlSaxParser();
+  virtual ~XmlSaxParser();
+
+  static void Initialize(v8::Local<v8::Object> target);
+
+  static NAN_METHOD(NewParser);
+
+  static NAN_METHOD(NewPushParser);
+
+  static NAN_METHOD(ParseString);
+  static NAN_METHOD(Push);
+
+  void Callback(const char *what, int argc = 0,
+                v8::Local<v8::Value> argv[] = NULL);
+
+  void parse_string(const char *str, unsigned int size);
+
+  void initialize_push_parser();
+
+  void push(const char *str, unsigned int size, bool terminate);
+
+  /// callbacks
+
+  static void start_document(void *context);
+
+  static void end_document(void *context);
+
+  static void start_element(void *context, const xmlChar *name,
+                            const xmlChar **p);
+
+  static void end_element(void *context, const xmlChar *name);
+
+  static void 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);
+
+  static void end_element_ns(void *context, const xmlChar *localname,
+                             const xmlChar *prefix, const xmlChar *uri);
+
+  static void characters(void *context, const xmlChar *ch, int len);
+
+  static void comment(void *context, const xmlChar *value);
+
+  static void cdata_block(void *context, const xmlChar *value, int len);
+
+  static void warning(void *context, const char *msg, ...);
+
+  static void error(void *context, const char *msg, ...);
+
+protected:
+  void initializeContext();
+  void releaseContext();
+
+  xmlParserCtxt *context_;
+
+  xmlSAXHandler sax_handler_;
+};
+
+} // namespace libxmljs
+
+#endif // SRC_XML_SAX_PARSER_H_

package/src/xml_syntax_error.cc

@@ -0,0 +1,66 @@
+// Copyright 2009, Squish Tech, LLC.
+
+#include <cstring>
+
+#include "xml_syntax_error.h"
+
+using namespace v8;
+namespace {
+
+void set_string_field(Local<Object> obj, const char *name, const char *value) {
+  Nan::HandleScope scope;
+  if (!value) {
+    return;
+  }
+  Nan::Set(obj, Nan::New<String>(name).ToLocalChecked(),
+           Nan::New<String>(value, strlen(value)).ToLocalChecked());
+}
+
+void set_numeric_field(Local<Object> obj, const char *name, const int value) {
+  Nan::HandleScope scope;
+  Nan::Set(obj, Nan::New<String>(name).ToLocalChecked(),
+           Nan::New<Int32>(value));
+}
+
+} // anonymous namespace
+
+namespace libxmljs {
+
+Local<Value> XmlSyntaxError::BuildSyntaxError(xmlError *error) {
+  Nan::EscapableHandleScope scope;
+
+  Local<Value> err =
+      Exception::Error(Nan::New<String>(error->message).ToLocalChecked());
+  Local<Object> out = Local<Object>::Cast(err);
+
+  set_numeric_field(out, "domain", error->domain);
+  set_numeric_field(out, "code", error->code);
+  set_string_field(out, "message", error->message);
+  set_numeric_field(out, "level", error->level);
+  set_numeric_field(out, "column", error->int2);
+  set_string_field(out, "file", error->file);
+  set_numeric_field(out, "line", error->line);
+  set_string_field(out, "str1", error->str1);
+  set_string_field(out, "str2", error->str2);
+  set_string_field(out, "str3", error->str3);
+
+  // only add if we have something interesting
+  if (error->int1) {
+    set_numeric_field(out, "int1", error->int1);
+  }
+  return scope.Escape(err);
+}
+
+void XmlSyntaxError::PushToArray(void *errs, xmlError *error) {
+  Nan::HandleScope scope;
+  Local<Array> errors = *reinterpret_cast<Local<Array> *>(errs);
+  // push method for array
+  Local<Function> push = Local<Function>::Cast(
+      Nan::Get(errors, Nan::New<String>("push").ToLocalChecked())
+          .ToLocalChecked());
+
+  Local<Value> argv[1] = {XmlSyntaxError::BuildSyntaxError(error)};
+  Nan::Call(push, errors, 1, argv);
+}
+
+} // namespace libxmljs

package/src/xml_syntax_error.h

@@ -0,0 +1,25 @@
+// Copyright 2009, Squish Tech, LLC.
+#ifndef SRC_XML_SYNTAX_ERROR_H_
+#define SRC_XML_SYNTAX_ERROR_H_
+
+#include <libxml/xmlerror.h>
+
+#include "libxmljs.h"
+
+namespace libxmljs {
+
+// basically being used like a namespace
+class XmlSyntaxError {
+public:
+  // push xmlError onto v8::Array
+  // helper method for xml library
+  static void PushToArray(void *errs, xmlError *error);
+
+  // create a v8 object for the syntax eror
+  // TODO make it a v8 Erorr object
+  static v8::Local<v8::Value> BuildSyntaxError(xmlError *error);
+};
+
+} // namespace libxmljs
+
+#endif // SRC_XML_SYNTAX_ERROR_H_

package/src/xml_text.cc

@@ -0,0 +1,320 @@
+// Copyright 2009, Squish Tech, LLC.
+
+#include <node.h>
+
+#include <cstring>
+
+#include "libxmljs.h"
+
+#include "xml_attribute.h"
+#include "xml_document.h"
+#include "xml_text.h"
+#include "xml_xpath_context.h"
+
+using namespace v8;
+
+namespace libxmljs {
+
+Nan::Persistent<FunctionTemplate> XmlText::constructor_template;
+
+Local<Value> XmlText::get_path() {
+  Nan::EscapableHandleScope scope;
+  xmlChar *path = xmlGetNodePath(xml_obj);
+  const char *return_path = path ? reinterpret_cast<char *>(path) : "";
+  int str_len = xmlStrlen((const xmlChar *)return_path);
+  Local<String> js_obj =
+      Nan::New<String>(return_path, str_len).ToLocalChecked();
+  xmlFree(path);
+  return scope.Escape(js_obj);
+}
+
+// doc, name, content
+NAN_METHOD(XmlText::New) {
+  NAN_CONSTRUCTOR_CHECK(Text)
+  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("content argument must be of type string");
+    return;
+  }
+
+  XmlDocument *document = Nan::ObjectWrap::Unwrap<XmlDocument>(doc);
+  assert(document);
+
+  Local<Value> contentOpt;
+  if (info[1]->IsString()) {
+    contentOpt = info[1];
+  }
+  Nan::Utf8String contentRaw(contentOpt);
+  const char *content = (contentRaw.length()) ? *contentRaw : NULL;
+
+  xmlNode *textNode =
+      xmlNewDocText(document->xml_obj, (const xmlChar *)content);
+
+  XmlText *element = new XmlText(textNode);
+  textNode->_private = element;
+  element->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(XmlText::NextElement) {
+  Nan::HandleScope scope;
+  XmlText *element = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(element);
+
+  return info.GetReturnValue().Set(element->get_next_element());
+}
+
+NAN_METHOD(XmlText::PrevElement) {
+  Nan::HandleScope scope;
+  XmlText *element = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(element);
+
+  return info.GetReturnValue().Set(element->get_prev_element());
+}
+
+NAN_METHOD(XmlText::Text) {
+  Nan::HandleScope scope;
+  XmlText *element = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(element);
+
+  if (info.Length() == 0) {
+    return info.GetReturnValue().Set(element->get_content());
+  } else {
+    element->set_content(*Nan::Utf8String(info[0]));
+  }
+
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+NAN_METHOD(XmlText::AddPrevSibling) {
+  XmlText *text = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(text);
+
+  XmlNode *new_sibling = Nan::ObjectWrap::Unwrap<XmlNode>(
+      Nan::To<Object>(info[0]).ToLocalChecked());
+  assert(new_sibling);
+
+  xmlNode *imported_sibling = text->import_node(new_sibling->xml_obj);
+  if (imported_sibling == NULL) {
+    return Nan::ThrowError(
+        "Could not add sibling. Failed to copy node to new Document.");
+  } else if ((new_sibling->xml_obj == imported_sibling) &&
+             text->prev_sibling_will_merge(imported_sibling)) {
+    imported_sibling = xmlCopyNode(imported_sibling, 0);
+  }
+  text->add_prev_sibling(imported_sibling);
+
+  return info.GetReturnValue().Set(info[0]);
+}
+
+NAN_METHOD(XmlText::AddNextSibling) {
+  XmlText *text = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(text);
+
+  XmlNode *new_sibling = Nan::ObjectWrap::Unwrap<XmlNode>(
+      Nan::To<Object>(info[0]).ToLocalChecked());
+  assert(new_sibling);
+
+  xmlNode *imported_sibling = text->import_node(new_sibling->xml_obj);
+  if (imported_sibling == NULL) {
+    return Nan::ThrowError(
+        "Could not add sibling. Failed to copy node to new Document.");
+  } else if ((new_sibling->xml_obj == imported_sibling) &&
+             text->next_sibling_will_merge(imported_sibling)) {
+    imported_sibling = xmlCopyNode(imported_sibling, 0);
+  }
+  text->add_next_sibling(imported_sibling);
+
+  return info.GetReturnValue().Set(info[0]);
+}
+
+NAN_METHOD(XmlText::Replace) {
+  XmlText *element = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(element);
+
+  if (info[0]->IsString()) {
+    element->replace_text(*Nan::Utf8String(info[0]));
+  } else {
+    XmlText *new_sibling = Nan::ObjectWrap::Unwrap<XmlText>(
+        Nan::To<Object>(info[0]).ToLocalChecked());
+    assert(new_sibling);
+
+    xmlNode *imported_sibling = element->import_node(new_sibling->xml_obj);
+    if (imported_sibling == NULL) {
+      return Nan::ThrowError(
+          "Could not replace. Failed to copy node to new Document.");
+    }
+    element->replace_element(imported_sibling);
+  }
+
+  return info.GetReturnValue().Set(info[0]);
+}
+
+NAN_METHOD(XmlText::Path) {
+  Nan::HandleScope scope;
+  XmlText *text = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(text);
+
+  return info.GetReturnValue().Set(text->get_path());
+}
+
+NAN_METHOD(XmlText::Name) {
+  Nan::HandleScope scope;
+  XmlText *text = Nan::ObjectWrap::Unwrap<XmlText>(info.Holder());
+  assert(text);
+
+  if (info.Length() == 0)
+    return info.GetReturnValue().Set(text->get_name());
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+void XmlText::set_content(const char *content) {
+  xmlChar *encoded =
+      xmlEncodeSpecialChars(xml_obj->doc, (const xmlChar *)content);
+  xmlNodeSetContent(xml_obj, encoded);
+  xmlFree(encoded);
+}
+
+Local<Value> XmlText::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<Value> XmlText::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());
+}
+
+Local<Value> XmlText::get_next_element() {
+  Nan::EscapableHandleScope scope;
+
+  xmlNode *sibling = xml_obj->next;
+  if (!sibling)
+    return scope.Escape(Nan::Null());
+
+  while (sibling && sibling->type != XML_ELEMENT_NODE)
+    sibling = sibling->next;
+
+  if (sibling) {
+    return scope.Escape(XmlText::New(sibling));
+  }
+
+  return scope.Escape(Nan::Null());
+}
+
+Local<Value> XmlText::get_prev_element() {
+  Nan::EscapableHandleScope scope;
+
+  xmlNode *sibling = xml_obj->prev;
+  if (!sibling)
+    return scope.Escape(Nan::Null());
+
+  while (sibling && sibling->type != XML_ELEMENT_NODE) {
+    sibling = sibling->prev;
+  }
+
+  if (sibling) {
+    return scope.Escape(XmlText::New(sibling));
+  }
+
+  return scope.Escape(Nan::Null());
+}
+
+Local<Object> XmlText::New(xmlNode *node) {
+  Nan::EscapableHandleScope scope;
+  if (node->_private) {
+    return scope.Escape(static_cast<XmlNode *>(node->_private)->handle());
+  }
+
+  XmlText *text = new XmlText(node);
+  Local<Object> obj =
+      Nan::NewInstance(
+          Nan::GetFunction(Nan::New(constructor_template)).ToLocalChecked())
+          .ToLocalChecked();
+  text->Wrap(obj);
+  return scope.Escape(obj);
+}
+
+XmlText::XmlText(xmlNode *node) : XmlNode(node) {}
+
+void XmlText::add_prev_sibling(xmlNode *element) {
+  xmlAddPrevSibling(xml_obj, element);
+}
+
+void XmlText::add_next_sibling(xmlNode *element) {
+  xmlAddNextSibling(xml_obj, element);
+}
+
+void XmlText::replace_element(xmlNode *element) {
+  xmlReplaceNode(xml_obj, element);
+}
+
+void XmlText::replace_text(const char *content) {
+  xmlNodePtr txt = xmlNewDocText(xml_obj->doc, (const xmlChar *)content);
+  xmlReplaceNode(xml_obj, txt);
+}
+
+bool XmlText::next_sibling_will_merge(xmlNode *child) {
+  return (child->type == XML_TEXT_NODE);
+}
+
+bool XmlText::prev_sibling_will_merge(xmlNode *child) {
+  return (child->type == XML_TEXT_NODE);
+}
+
+void XmlText::Initialize(Local<Object> target) {
+  Nan::HandleScope scope;
+  Local<FunctionTemplate> tmpl = Nan::New<FunctionTemplate>(New);
+
+  constructor_template.Reset(tmpl);
+
+  tmpl->Inherit(Nan::New(XmlNode::constructor_template));
+  tmpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Nan::SetPrototypeMethod(tmpl, "nextElement", XmlText::NextElement);
+
+  Nan::SetPrototypeMethod(tmpl, "prevElement", XmlText::PrevElement);
+
+  Nan::SetPrototypeMethod(tmpl, "text", XmlText::Text);
+
+  Nan::SetPrototypeMethod(tmpl, "replace", XmlText::Replace);
+
+  Nan::SetPrototypeMethod(tmpl, "path", XmlText::Path);
+
+  Nan::SetPrototypeMethod(tmpl, "name", XmlText::Name);
+
+  Nan::SetPrototypeMethod(tmpl, "addPrevSibling", XmlText::AddPrevSibling);
+
+  Nan::SetPrototypeMethod(tmpl, "addNextSibling", XmlText::AddNextSibling);
+
+  Nan::Set(target, Nan::New<String>("Text").ToLocalChecked(),
+           Nan::GetFunction(tmpl).ToLocalChecked());
+}
+
+} // namespace libxmljs

package/src/xml_text.h

@@ -0,0 +1,48 @@
+#ifndef SRC_XML_TEXT_H_
+#define SRC_XML_TEXT_H_
+
+#include "libxmljs.h"
+#include "xml_node.h"
+
+namespace libxmljs {
+
+class XmlText : public XmlNode {
+public:
+  explicit XmlText(xmlNode *node);
+
+  static void Initialize(v8::Local<v8::Object> target);
+
+  static Nan::Persistent<v8::FunctionTemplate> constructor_template;
+
+  // create new xml element to wrap the node
+  static v8::Local<v8::Object> New(xmlNode *node);
+
+protected:
+  static NAN_METHOD(New);
+  static NAN_METHOD(Text);
+  static NAN_METHOD(Replace);
+  static NAN_METHOD(Path);
+  static NAN_METHOD(Name);
+
+  static NAN_METHOD(NextElement);
+  static NAN_METHOD(PrevElement);
+  static NAN_METHOD(AddPrevSibling);
+  static NAN_METHOD(AddNextSibling);
+
+  v8::Local<v8::Value> get_next_element();
+  v8::Local<v8::Value> get_prev_element();
+  v8::Local<v8::Value> get_content();
+  v8::Local<v8::Value> get_path();
+  v8::Local<v8::Value> get_name();
+  void set_content(const char *content);
+  void replace_text(const char *content);
+  void replace_element(xmlNode *element);
+  void add_prev_sibling(xmlNode *element);
+  void add_next_sibling(xmlNode *element);
+  bool prev_sibling_will_merge(xmlNode *node);
+  bool next_sibling_will_merge(xmlNode *node);
+};
+
+} // namespace libxmljs
+
+#endif // SRC_XML_TEXT_H_