nokogiri 1.10.3 → 1.13.2

data/ext/nokogiri/xml_schema.c

@@ -1,6 +1,9 @@
-#include <xml_schema.h>
+#include <nokogiri.h>
 
-static void dealloc(xmlSchemaPtr schema)
+VALUE cNokogiriXmlSchema;
+
+static void
+dealloc(xmlSchemaPtr schema)
 {
   NOKOGIRI_DEBUG_START(schema);
   xmlSchemaFree(schema);
@@ -13,7 +16,8 @@ static void dealloc(xmlSchemaPtr schema)
  *
  * Validate a Nokogiri::XML::Document against this Schema.
  */
-static VALUE validate_document(VALUE self, VALUE document)
+static VALUE
+validate_document(VALUE self, VALUE document)
 {
   xmlDocPtr doc;
   xmlSchemaPtr schema;
@@ -27,7 +31,7 @@ static VALUE validate_document(VALUE self, VALUE document)
 
   valid_ctxt = xmlSchemaNewValidCtxt(schema);
 
-  if(NULL == valid_ctxt) {
+  if (NULL == valid_ctxt) {
     /* we have a problem */
     rb_raise(rb_eRuntimeError, "Could not create a validation context");
   }
@@ -53,7 +57,8 @@ static VALUE validate_document(VALUE self, VALUE document)
  *
  * Validate a file against this Schema.
  */
-static VALUE validate_file(VALUE self, VALUE rb_filename)
+static VALUE
+validate_file(VALUE self, VALUE rb_filename)
 {
   xmlSchemaPtr schema;
   xmlSchemaValidCtxtPtr valid_ctxt;
@@ -61,13 +66,13 @@ static VALUE validate_file(VALUE self, VALUE rb_filename)
   VALUE errors;
 
   Data_Get_Struct(self, xmlSchema, schema);
-  filename = (const char*)StringValueCStr(rb_filename) ;
+  filename = (const char *)StringValueCStr(rb_filename) ;
 
   errors = rb_ary_new();
 
   valid_ctxt = xmlSchemaNewValidCtxt(schema);
 
-  if(NULL == valid_ctxt) {
+  if (NULL == valid_ctxt) {
     /* we have a problem */
     rb_raise(rb_eRuntimeError, "Could not create a validation context");
   }
@@ -93,15 +98,28 @@ static VALUE validate_file(VALUE self, VALUE rb_filename)
  *
  * Create a new Schema from the contents of +string+
  */
-static VALUE read_memory(VALUE klass, VALUE content)
+static VALUE
+read_memory(int argc, VALUE *argv, VALUE klass)
 {
+  VALUE content;
+  VALUE parse_options;
+  int parse_options_int;
+  xmlSchemaParserCtxtPtr ctx;
   xmlSchemaPtr schema;
-  xmlSchemaParserCtxtPtr ctx = xmlSchemaNewMemParserCtxt(
-      (const char *)StringValuePtr(content),
-      (int)RSTRING_LEN(content)
-  );
+  VALUE errors;
   VALUE rb_schema;
-  VALUE errors = rb_ary_new();
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &content, &parse_options);
+  if (scanned_args == 1) {
+    parse_options = rb_const_get_at(rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  ctx = xmlSchemaNewMemParserCtxt((const char *)StringValuePtr(content), (int)RSTRING_LEN(content));
+
+  errors = rb_ary_new();
   xmlSetStructuredErrorFunc((void *)errors, Nokogiri_error_array_pusher);
 
 #ifdef HAVE_XMLSCHEMASETPARSERSTRUCTUREDERRORS
@@ -112,45 +130,97 @@ static VALUE read_memory(VALUE klass, VALUE content)
   );
 #endif
 
-   schema = xmlSchemaParse(ctx);
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
+  schema = xmlSchemaParse(ctx);
+
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
 
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSchemaFreeParserCtxt(ctx);
 
-  if(NULL == schema) {
+  if (NULL == schema) {
     xmlErrorPtr error = xmlGetLastError();
-    if(error)
+    if (error) {
       Nokogiri_error_raise(NULL, error);
-    else
+    } else {
       rb_raise(rb_eRuntimeError, "Could not parse document");
+    }
 
     return Qnil;
   }
 
   rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
 
   return rb_schema;
 }
 
+/* Schema creation will remove and deallocate "blank" nodes.
+ * If those blank nodes have been exposed to Ruby, they could get freed
+ * out from under the VALUE pointer.  This function checks to see if any of
+ * those nodes have been exposed to Ruby, and if so we should raise an exception.
+ */
+static int
+has_blank_nodes_p(VALUE cache)
+{
+  long i;
+
+  if (NIL_P(cache)) {
+    return 0;
+  }
+
+  for (i = 0; i < RARRAY_LEN(cache); i++) {
+    xmlNodePtr node;
+    VALUE element = rb_ary_entry(cache, i);
+    Data_Get_Struct(element, xmlNode, node);
+    if (xmlIsBlankNode(node)) {
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
 /*
  * call-seq:
  *  from_document(doc)
  *
  * Create a new Schema from the Nokogiri::XML::Document +doc+
  */
-static VALUE from_document(VALUE klass, VALUE document)
+static VALUE
+from_document(int argc, VALUE *argv, VALUE klass)
 {
+  VALUE document;
+  VALUE parse_options;
+  int parse_options_int;
   xmlDocPtr doc;
   xmlSchemaParserCtxtPtr ctx;
   xmlSchemaPtr schema;
   VALUE errors;
   VALUE rb_schema;
+  int scanned_args = 0;
+  xmlExternalEntityLoader old_loader = 0;
+
+  scanned_args = rb_scan_args(argc, argv, "11", &document, &parse_options);
 
   Data_Get_Struct(document, xmlDoc, doc);
+  doc = doc->doc; /* In case someone passes us a node. ugh. */
 
-  /* In case someone passes us a node. ugh. */
-  doc = doc->doc;
+  if (scanned_args == 1) {
+    parse_options = rb_const_get_at(rb_const_get_at(mNokogiriXml, rb_intern("ParseOptions")), rb_intern("DEFAULT_SCHEMA"));
+  }
+  parse_options_int = (int)NUM2INT(rb_funcall(parse_options, rb_intern("to_i"), 0));
+
+  if (has_blank_nodes_p(DOC_NODE_CACHE(doc))) {
+    rb_raise(rb_eArgError, "Creating a schema from a document that has blank nodes exposed to Ruby is dangerous");
+  }
 
   ctx = xmlSchemaNewDocParserCtxt(doc);
 
@@ -165,41 +235,50 @@ static VALUE from_document(VALUE klass, VALUE document)
   );
 #endif
 
+  if (parse_options_int & XML_PARSE_NONET) {
+    old_loader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(xmlNoNetExternalEntityLoader);
+  }
+
   schema = xmlSchemaParse(ctx);
 
+  if (old_loader) {
+    xmlSetExternalEntityLoader(old_loader);
+  }
+
   xmlSetStructuredErrorFunc(NULL, NULL);
   xmlSchemaFreeParserCtxt(ctx);
 
-  if(NULL == schema) {
+  if (NULL == schema) {
     xmlErrorPtr error = xmlGetLastError();
-    if(error)
+    if (error) {
       Nokogiri_error_raise(NULL, error);
-    else
+    } else {
       rb_raise(rb_eRuntimeError, "Could not parse document");
+    }
 
     return Qnil;
   }
 
   rb_schema = Data_Wrap_Struct(klass, 0, dealloc, schema);
   rb_iv_set(rb_schema, "@errors", errors);
+  rb_iv_set(rb_schema, "@parse_options", parse_options);
 
   return rb_schema;
 
   return Qnil;
 }
 
-VALUE cNokogiriXmlSchema;
-void init_xml_schema()
+void
+noko_init_xml_schema()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  VALUE klass = rb_define_class_under(xml, "Schema", rb_cObject);
+  cNokogiriXmlSchema = rb_define_class_under(mNokogiriXml, "Schema", rb_cObject);
 
-  cNokogiriXmlSchema = klass;
+  rb_undef_alloc_func(cNokogiriXmlSchema);
 
-  rb_define_singleton_method(klass, "read_memory", read_memory, 1);
-  rb_define_singleton_method(klass, "from_document", from_document, 1);
+  rb_define_singleton_method(cNokogiriXmlSchema, "read_memory", read_memory, -1);
+  rb_define_singleton_method(cNokogiriXmlSchema, "from_document", from_document, -1);
 
-  rb_define_private_method(klass, "validate_document", validate_document, 1);
-  rb_define_private_method(klass, "validate_file",     validate_file, 1);
+  rb_define_private_method(cNokogiriXmlSchema, "validate_document", validate_document, 1);
+  rb_define_private_method(cNokogiriXmlSchema, "validate_file",     validate_file, 1);
 }

data/ext/nokogiri/xml_syntax_error.c

@@ -1,38 +1,64 @@
-#include <xml_syntax_error.h>
+#include <nokogiri.h>
 
-void Nokogiri_error_array_pusher(void * ctx, xmlErrorPtr error)
+VALUE cNokogiriXmlSyntaxError;
+
+void
+Nokogiri_structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state)
+{
+  /* this method is tightly coupled to the implementation of xmlSetStructuredErrorFunc */
+  handler_state->user_data = xmlStructuredErrorContext;
+  handler_state->handler = xmlStructuredError;
+}
+
+void
+Nokogiri_structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state,
+    void *user_data,
+    xmlStructuredErrorFunc handler)
+{
+  Nokogiri_structured_error_func_save(handler_state);
+  xmlSetStructuredErrorFunc(user_data, handler);
+}
+
+void
+Nokogiri_structured_error_func_restore(libxmlStructuredErrorHandlerState *handler_state)
+{
+  xmlSetStructuredErrorFunc(handler_state->user_data, handler_state->handler);
+}
+
+void
+Nokogiri_error_array_pusher(void *ctx, xmlErrorPtr error)
 {
   VALUE list = (VALUE)ctx;
   Check_Type(list, T_ARRAY);
   rb_ary_push(list,  Nokogiri_wrap_xml_syntax_error(error));
 }
 
-void Nokogiri_error_raise(void * ctx, xmlErrorPtr error)
+void
+Nokogiri_error_raise(void *ctx, xmlErrorPtr error)
 {
   rb_exc_raise(Nokogiri_wrap_xml_syntax_error(error));
 }
 
-VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error)
+VALUE
+Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error)
 {
   VALUE msg, e, klass;
 
   klass = cNokogiriXmlSyntaxError;
 
   if (error && error->domain == XML_FROM_XPATH) {
-    VALUE xpath = rb_const_get(mNokogiriXml, rb_intern("XPath"));
-    klass = rb_const_get(xpath, rb_intern("SyntaxError"));
+    klass = cNokogiriXmlXpathSyntaxError;
   }
 
   msg = (error && error->message) ? NOKOGIRI_STR_NEW2(error->message) : Qnil;
 
   e = rb_class_new_instance(
-      1,
-      &msg,
-      klass
-  );
+        1,
+        &msg,
+        klass
+      );
 
-  if (error)
-  {
+  if (error) {
     rb_iv_set(e, "@domain", INT2NUM(error->domain));
     rb_iv_set(e, "@code", INT2NUM(error->code));
     rb_iv_set(e, "@level", INT2NUM((short)error->level));
@@ -48,17 +74,12 @@ VALUE Nokogiri_wrap_xml_syntax_error(xmlErrorPtr error)
   return e;
 }
 
-VALUE cNokogiriXmlSyntaxError;
-void init_xml_syntax_error()
+void
+noko_init_xml_syntax_error()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-
+  assert(cNokogiriSyntaxError);
   /*
    * The XML::SyntaxError is raised on parse errors
    */
-  VALUE syntax_error_mommy = rb_define_class_under(nokogiri, "SyntaxError", rb_eStandardError);
-  VALUE klass = rb_define_class_under(xml, "SyntaxError", syntax_error_mommy);
-  cNokogiriXmlSyntaxError = klass;
-
+  cNokogiriXmlSyntaxError = rb_define_class_under(mNokogiriXml, "SyntaxError", cNokogiriSyntaxError);
 }

data/ext/nokogiri/xml_text.c

@@ -1,4 +1,6 @@
-#include <xml_text.h>
+#include <nokogiri.h>
+
+VALUE cNokogiriXmlText ;
 
 /*
  * call-seq:
@@ -6,7 +8,8 @@
  *
  * Create a new Text element on the +document+ with +content+
  */
-static VALUE new(int argc, VALUE *argv, VALUE klass)
+static VALUE
+new (int argc, VALUE *argv, VALUE klass)
 {
   xmlDocPtr doc;
   xmlNodePtr node;
@@ -22,31 +25,24 @@ static VALUE new(int argc, VALUE *argv, VALUE klass)
   node = xmlNewText((xmlChar *)StringValueCStr(string));
   node->doc = doc->doc;
 
-  nokogiri_root_node(node);
+  noko_xml_document_pin_node(node);
 
-  rb_node = Nokogiri_wrap_xml_node(klass, node) ;
+  rb_node = noko_xml_node_wrap(klass, node) ;
   rb_obj_call_init(rb_node, argc, argv);
 
-  if(rb_block_given_p()) rb_yield(rb_node);
+  if (rb_block_given_p()) { rb_yield(rb_node); }
 
   return rb_node;
 }
 
-VALUE cNokogiriXmlText ;
-void init_xml_text()
+void
+noko_init_xml_text()
 {
-  VALUE nokogiri = rb_define_module("Nokogiri");
-  VALUE xml = rb_define_module_under(nokogiri, "XML");
-  /* */
-  VALUE node = rb_define_class_under(xml, "Node", rb_cObject);
-  VALUE char_data = rb_define_class_under(xml, "CharacterData", node);
-
+  assert(cNokogiriXmlCharacterData);
   /*
    * Wraps Text nodes.
    */
-  VALUE klass = rb_define_class_under(xml, "Text", char_data);
-
-  cNokogiriXmlText = klass;
+  cNokogiriXmlText = rb_define_class_under(mNokogiriXml, "Text", cNokogiriXmlCharacterData);
 
-  rb_define_singleton_method(klass, "new", new, -1);
+  rb_define_singleton_method(cNokogiriXmlText, "new", new, -1);
 }