@helm2/poc_jenki_rce 0.0.1

package/src/xml_textwriter.cc

@@ -0,0 +1,315 @@
+// Copyright 2011, Squish Tech, LLC.
+
+#include "xml_textwriter.h"
+#include "libxmljs.h"
+
+using namespace v8;
+namespace libxmljs {
+
+#define THROW_ON_ERROR(text)                                                   \
+  if (result == -1) {                                                          \
+    Nan::ThrowError(text);                                                     \
+    return;                                                                    \
+  }
+
+XmlTextWriter::XmlTextWriter() {
+  textWriter = NULL;
+  writerBuffer = NULL;
+}
+
+XmlTextWriter::~XmlTextWriter() {
+  if (textWriter) {
+    xmlFreeTextWriter(textWriter);
+  }
+  if (writerBuffer) {
+    xmlBufferFree(writerBuffer);
+  }
+}
+
+NAN_METHOD(XmlTextWriter::NewTextWriter) {
+  Nan::HandleScope scope;
+  XmlTextWriter *writer = new XmlTextWriter();
+  writer->Wrap(info.Holder());
+  writer->OpenMemory(info);
+
+  return info.GetReturnValue().Set(info.Holder());
+}
+
+NAN_METHOD(XmlTextWriter::OpenMemory) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  writer->writerBuffer = xmlBufferCreate();
+  if (!writer->writerBuffer) {
+    return Nan::ThrowError("Failed to create memory buffer");
+  }
+
+  writer->textWriter = xmlNewTextWriterMemory(writer->writerBuffer, 0);
+  if (!writer->textWriter) {
+    xmlBufferFree(writer->writerBuffer);
+    return Nan::ThrowError("Failed to create buffer writer");
+  }
+
+  return info.GetReturnValue().Set(Nan::Undefined());
+}
+
+NAN_METHOD(XmlTextWriter::BufferContent) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  // Flush the output buffer of the libxml writer instance in order to push all
+  // the content to our writerBuffer.
+  xmlTextWriterFlush(writer->textWriter);
+
+  // Receive bytes from the writerBuffer
+  const xmlChar *buf = xmlBufferContent(writer->writerBuffer);
+
+  return info.GetReturnValue().Set(
+      Nan::New<String>((const char *)buf, xmlBufferLength(writer->writerBuffer))
+          .ToLocalChecked());
+}
+
+void XmlTextWriter::clearBuffer() {
+  // Flush the output buffer of the libxml writer instance in order to push all
+  // the content to our writerBuffer.
+  xmlTextWriterFlush(textWriter);
+  // Clear the memory buffer
+  xmlBufferEmpty(writerBuffer);
+}
+
+NAN_METHOD(XmlTextWriter::BufferEmpty) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  writer->clearBuffer();
+
+  return info.GetReturnValue().Set(Nan::Undefined());
+}
+
+NAN_METHOD(XmlTextWriter::StartDocument) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  Nan::Utf8String version(info[0]);
+  Nan::Utf8String encoding(info[1]);
+  const char *standalone = NULL;
+
+  if (info[2]->IsBoolean()) {
+    const char *wordBool =
+        Nan::To<bool>(info[2]).FromMaybe(false) ? "yes" : "no";
+    standalone = *Nan::Utf8String(Nan::New<String>(wordBool).ToLocalChecked());
+  } else if (info[2]->IsString()) {
+    standalone = *Nan::Utf8String(info[2]);
+  }
+
+  int result = xmlTextWriterStartDocument(
+      writer->textWriter, info[0]->IsUndefined() ? NULL : *version,
+      info[1]->IsUndefined() ? NULL : *encoding, standalone);
+
+  THROW_ON_ERROR("Failed to start document");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::EndDocument) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterEndDocument(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to end document");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::StartElementNS) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  Nan::Utf8String prefix(info[0]);
+  Nan::Utf8String name(info[1]);
+  Nan::Utf8String namespaceURI(info[2]);
+
+  int result = xmlTextWriterStartElementNS(
+      writer->textWriter,
+      info[0]->IsUndefined() ? NULL : (const xmlChar *)*prefix,
+      info[1]->IsUndefined() ? NULL : (const xmlChar *)*name,
+      info[2]->IsUndefined() ? NULL : (const xmlChar *)*namespaceURI);
+
+  THROW_ON_ERROR("Failed to start element");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::EndElement) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterEndElement(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to end element");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::StartAttributeNS) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  Nan::Utf8String prefix(info[0]);
+  Nan::Utf8String name(info[1]);
+  Nan::Utf8String namespaceURI(info[2]);
+
+  int result = xmlTextWriterStartAttributeNS(
+      writer->textWriter,
+      info[0]->IsUndefined() ? NULL : (const xmlChar *)*prefix,
+      info[1]->IsUndefined() ? NULL : (const xmlChar *)*name,
+      info[2]->IsUndefined() ? NULL : (const xmlChar *)*namespaceURI);
+
+  THROW_ON_ERROR("Failed to start attribute");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::EndAttribute) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterEndAttribute(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to end attribute");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::StartCdata) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterStartCDATA(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to start CDATA section");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::EndCdata) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterEndCDATA(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to end CDATA section");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::StartComment) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterStartComment(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to start Comment section");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::EndComment) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  int result = xmlTextWriterEndComment(writer->textWriter);
+
+  THROW_ON_ERROR("Failed to end Comment section");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::WriteString) {
+  Nan::HandleScope scope;
+
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  Nan::Utf8String string(info[0]);
+
+  int result =
+      xmlTextWriterWriteString(writer->textWriter, (const xmlChar *)*string);
+
+  THROW_ON_ERROR("Failed to write string");
+
+  return info.GetReturnValue().Set(Nan::New<Number>((double)result));
+}
+
+NAN_METHOD(XmlTextWriter::OutputMemory) {
+  bool clear = info.Length() == 0 || Nan::To<bool>(info[0]).FromMaybe(true);
+  XmlTextWriter *writer = Nan::ObjectWrap::Unwrap<XmlTextWriter>(info.Holder());
+
+  BufferContent(info);
+
+  if (clear) {
+    writer->clearBuffer();
+  }
+}
+
+void XmlTextWriter::Initialize(Local<Object> target) {
+  Nan::HandleScope scope;
+
+  Local<FunctionTemplate> writer_t = Nan::New<FunctionTemplate>(NewTextWriter);
+
+  Nan::Persistent<FunctionTemplate> xml_writer_template;
+  xml_writer_template.Reset(writer_t);
+
+  writer_t->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Nan::SetPrototypeMethod(writer_t, "toString", XmlTextWriter::BufferContent);
+
+  Nan::SetPrototypeMethod(writer_t, "outputMemory",
+                          XmlTextWriter::OutputMemory);
+
+  Nan::SetPrototypeMethod(writer_t, "clear", XmlTextWriter::BufferEmpty);
+
+  Nan::SetPrototypeMethod(writer_t, "startDocument",
+                          XmlTextWriter::StartDocument);
+
+  Nan::SetPrototypeMethod(writer_t, "endDocument", XmlTextWriter::EndDocument);
+
+  Nan::SetPrototypeMethod(writer_t, "startElementNS",
+                          XmlTextWriter::StartElementNS);
+
+  Nan::SetPrototypeMethod(writer_t, "endElement", XmlTextWriter::EndElement);
+
+  Nan::SetPrototypeMethod(writer_t, "startAttributeNS",
+                          XmlTextWriter::StartAttributeNS);
+
+  Nan::SetPrototypeMethod(writer_t, "endAttribute",
+                          XmlTextWriter::EndAttribute);
+
+  Nan::SetPrototypeMethod(writer_t, "startCdata", XmlTextWriter::StartCdata);
+
+  Nan::SetPrototypeMethod(writer_t, "endCdata", XmlTextWriter::EndCdata);
+
+  Nan::SetPrototypeMethod(writer_t, "startComment",
+                          XmlTextWriter::StartComment);
+
+  Nan::SetPrototypeMethod(writer_t, "endComment", XmlTextWriter::EndComment);
+
+  Nan::SetPrototypeMethod(writer_t, "writeString", XmlTextWriter::WriteString);
+
+  Nan::Set(target, Nan::New<String>("TextWriter").ToLocalChecked(),
+           Nan::GetFunction(writer_t).ToLocalChecked());
+}
+} // namespace libxmljs

package/src/xml_textwriter.h

@@ -0,0 +1,62 @@
+// Copyright 2009, Squish Tech, LLC.
+#ifndef SRC_XML_TEXTWRITER_H_
+#define SRC_XML_TEXTWRITER_H_
+
+#include "libxmljs.h"
+#include <libxml/xmlwriter.h>
+#include <node.h>
+
+namespace libxmljs {
+
+class XmlTextWriter : public Nan::ObjectWrap {
+public:
+  XmlTextWriter();
+  virtual ~XmlTextWriter();
+
+  static void Initialize(v8::Local<v8::Object> target);
+
+  static NAN_METHOD(NewTextWriter);
+
+  static NAN_METHOD(OpenMemory);
+
+  static NAN_METHOD(BufferContent);
+
+  static NAN_METHOD(BufferEmpty);
+
+  static NAN_METHOD(StartDocument);
+
+  static NAN_METHOD(EndDocument);
+
+  static NAN_METHOD(StartElementNS);
+
+  static NAN_METHOD(EndElement);
+
+  static NAN_METHOD(StartAttributeNS);
+
+  static NAN_METHOD(EndAttribute);
+
+  static NAN_METHOD(StartCdata);
+
+  static NAN_METHOD(EndCdata);
+
+  static NAN_METHOD(StartComment);
+
+  static NAN_METHOD(EndComment);
+
+  static NAN_METHOD(WriteString);
+
+  static NAN_METHOD(OutputMemory);
+
+private:
+  xmlTextWriterPtr textWriter;
+  xmlBufferPtr writerBuffer;
+
+  void clearBuffer();
+
+  bool is_open();
+
+  bool is_inmemory();
+};
+} // namespace libxmljs
+
+#endif // SRC_XML_TEXTWRITER_H_

package/src/xml_xpath_context.cc

@@ -0,0 +1,70 @@
+// Copyright 2009, Squish Tech, LLC.
+
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+
+#include "xml_element.h"
+#include "xml_xpath_context.h"
+
+using namespace v8;
+
+namespace libxmljs {
+
+XmlXpathContext::XmlXpathContext(xmlNode *node) {
+  ctxt = xmlXPathNewContext(node->doc);
+  ctxt->node = node;
+}
+
+XmlXpathContext::~XmlXpathContext() { xmlXPathFreeContext(ctxt); }
+
+void XmlXpathContext::register_ns(const xmlChar *prefix, const xmlChar *uri) {
+  xmlXPathRegisterNs(ctxt, prefix, uri);
+}
+
+Local<Value> XmlXpathContext::evaluate(const xmlChar *xpath) {
+  Nan::EscapableHandleScope scope;
+  xmlXPathObject *xpathobj = xmlXPathEval(xpath, ctxt);
+  Local<Value> res;
+
+  if (xpathobj) {
+    switch (xpathobj->type) {
+    case XPATH_NODESET: {
+      if (xmlXPathNodeSetIsEmpty(xpathobj->nodesetval)) {
+        res = Nan::New<Array>(0);
+        break;
+      }
+
+      Local<Array> nodes = Nan::New<Array>(xpathobj->nodesetval->nodeNr);
+      for (int i = 0; i != xpathobj->nodesetval->nodeNr; ++i) {
+        Nan::Set(nodes, i, XmlNode::New(xpathobj->nodesetval->nodeTab[i]));
+      }
+
+      res = nodes;
+      break;
+    }
+
+    case XPATH_BOOLEAN:
+      res = Nan::New<Boolean>(xpathobj->boolval);
+      break;
+
+    case XPATH_NUMBER:
+      res = Nan::New<Number>(xpathobj->floatval);
+      break;
+
+    case XPATH_STRING:
+      res = Nan::New<String>((const char *)xpathobj->stringval,
+                             xmlStrlen(xpathobj->stringval))
+                .ToLocalChecked();
+      break;
+
+    default:
+      res = Nan::Null();
+      break;
+    }
+  }
+
+  xmlXPathFreeObject(xpathobj);
+  return scope.Escape(res);
+}
+
+} // namespace libxmljs

package/src/xml_xpath_context.h

@@ -0,0 +1,23 @@
+// Copyright 2009, Squish Tech, LLC.
+#ifndef SRC_XML_XPATH_CONTEXT_H_
+#define SRC_XML_XPATH_CONTEXT_H_
+
+#include <libxml/xpath.h>
+
+#include "libxmljs.h"
+
+namespace libxmljs {
+
+class XmlXpathContext {
+public:
+  explicit XmlXpathContext(xmlNode *node);
+  ~XmlXpathContext();
+
+  void register_ns(const xmlChar *prefix, const xmlChar *uri);
+  v8::Local<v8::Value> evaluate(const xmlChar *xpath);
+
+  xmlXPathContext *ctxt;
+};
+} // namespace libxmljs
+
+#endif // SRC_XML_XPATH_CONTEXT_H_

package/vendor/libxml/Copyright

@@ -0,0 +1,23 @@
+Except where otherwise noted in the source code (e.g. the files hash.c,
+list.c and the trio files, which are covered by a similar licence but
+with different Copyright notices) all the files are:
+
+ Copyright (C) 1998-2012 Daniel Veillard.  All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is fur-
+nished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
+NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.