nokogiri 1.19.4 → 1.19.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b195d6ddd64bd4812056a21283c42ac51a161c99a0763d2cbb0a174e1d03fd12
-  data.tar.gz: 375787a6a2a62d3d3d394e5bef11e2d1dbb3a1d238af31ffee7e46575d6fe877
+  metadata.gz: 9b6ae8d128fac90392dfbe122d0c1e1e8c056fd6dc1c49cfecdef2ac1d09788f
+  data.tar.gz: 315ef5552e29320fe8008f9fceff8316718ce263668bf13d1e2f015715203540
 SHA512:
-  metadata.gz: 58a9b6de3ff04d37308d889127f0be4e5c08c6780a20084324684be26e9e8544d81b6a4406d3c78d6980dd645c12c9093583d7c7aacb133a9a96ecda6cabe2c0
-  data.tar.gz: 7f3f742d0510193f0a612ecade4e0115264c6229f09e53a8c750aa7032a5a7d810924ddf5d7c4cd048be14b0c0800e52032ad937536c1f5e8efff4caa0357d15
+  metadata.gz: 18e131261027295c823d6e4b4d4d0c739ac8dcfc2a5d570409f3081917f39b4c69f6719f55eb4a9e78c34e390c442abb50267bd9e0cfe8a25bfd3076a4de0bdd
+  data.tar.gz: 9ac2042bf9ce20532e61b2b0e29b9582127c034914ddf370bde9a6b0b8abad067c1e4030551451c2f171bb3b48981f83b69aa2c8b45ddb939ffd3fe88d1453ba

data/LICENSE-DEPENDENCIES.md

@@ -15,6 +15,7 @@ Note that this document is broken into multiple sections, each of which describe
   * [Native WindowsⓇ platform releases ("x64-mingw-ucrt")](#native-windows%E2%93%A1-platform-releases-x64-mingw-ucrt)
   * [JavaⓇ (JRuby) platform release ("java")](#java%E2%93%A1-jruby-platform-release-java)
 - [Appendix: Dependencies' License Texts](#appendix-dependencies-license-texts)
+  * [hashmap.c](#hashmapc)
   * [libgumbo](#libgumbo)
   * [libxml2](#libxml2)
   * [libxslt](#libxslt)
@@ -114,6 +115,34 @@ This section contains a subsection for each potentially-distributed dependency,
 Please see previous sections to understand which of these potential dependencies is actually distributed in the gem file you're downloading and using.
 
 
+### hashmap.c
+
+MIT
+
+https://github.com/tidwall/hashmap.c/blob/master/LICENSE
+
+    The MIT License (MIT)
+
+    Copyright (c) 2020 Joshua J Baker
+
+    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 furnished 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, FITNESS
+    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.
+
+
 ### libgumbo
 
 Apache 2.0

data/ext/nokogiri/extconf.rb

@@ -1125,6 +1125,7 @@ end
 have_func("xmlCtxtSetOptions") # introduced in libxml2 2.13.0
 have_func("xmlCtxtGetOptions") # introduced in libxml2 2.14.0
 have_func("xmlSwitchEncodingName") # introduced in libxml2 2.13.0
+have_func("xmlAddIDSafe") # introduced in libxml2 2.13.0
 have_func("rb_category_warning") # introduced in Ruby 3.0 but had trouble resolving this symbol in truffleruby
 
 other_library_versions_string = OTHER_LIBRARY_VERSIONS.map { |k, v| [k, v].join(":") }.join(",")

data/ext/nokogiri/gumbo.c

@@ -113,6 +113,71 @@ set_line(xmlNodePtr node, size_t line)
   }
 }
 
+// This function is essentially xmlNewNsProp, but we skip the full list traversal to append by
+// providing the last property in the linked list as a parameter.
+static xmlAttrPtr
+append_property(xmlNodePtr node, xmlNsPtr ns, const xmlChar *name, const xmlChar *value, xmlAttrPtr last_prop)
+{
+  xmlAttrPtr cur = (xmlAttrPtr) xmlMalloc(sizeof(xmlAttr));
+  if (cur == NULL) {
+    return NULL;
+  }
+  memset(cur, 0, sizeof(xmlAttr));
+  cur->type = XML_ATTRIBUTE_NODE;
+  cur->parent = node;
+  xmlDocPtr doc = node->doc;
+  cur->doc = doc;
+  cur->ns = ns;
+
+  if ((doc != NULL) && (doc->dict != NULL)) {
+    cur->name = (xmlChar *) xmlDictLookup(doc->dict, name, -1);
+  } else {
+    cur->name = xmlStrdup(name);
+  }
+  if (cur->name == NULL) {
+    goto error;
+  }
+
+  if (value != NULL) {
+    cur->children = xmlNewDocText(doc, value);
+    if (cur->children == NULL) {
+      goto error;
+    }
+    cur->last = NULL;
+    xmlNodePtr tmp = cur->children;
+    while (tmp != NULL) {
+      tmp->parent = (xmlNodePtr) cur;
+      if (tmp->next == NULL) {
+        cur->last = tmp;
+      }
+      tmp = tmp->next;
+    }
+
+    if (doc != NULL) {
+      int res = xmlIsID(doc, node, cur);
+      if (res < 0) {
+        goto error;
+      }
+      if ((res == 1) && (xmlAddIDSafe(cur, value) < 0)) {
+        goto error;
+      }
+    }
+  }
+
+  if (node->properties == NULL) {
+    node->properties = cur;
+  } else {
+    last_prop->next = cur;
+    cur->prev = last_prop;
+  }
+
+  return cur;
+
+error:
+  xmlFreeProp(cur);
+  return (NULL);
+}
+
 // Construct an XML tree rooted at xml_output_node from the Gumbo tree rooted
 // at gumbo_node.
 static void
@@ -200,6 +265,7 @@ build_tree(
         xmlAddChild(xml_node, xml_child);
 
         // Add the attributes.
+        xmlAttrPtr last_prop = NULL;
         const GumboVector *attrs = &gumbo_child->v.element.attributes;
         for (size_t i = 0; i < attrs->length; i++) {
           const GumboAttribute *attr = attrs->data[i];
@@ -220,7 +286,9 @@ build_tree(
             default:
               ns = NULL;
           }
-          xmlNewNsProp(xml_child, ns, (const xmlChar *)attr->name, (const xmlChar *)attr->value);
+
+          // We micromanage the attribute list for performance reasons.
+          last_prop = append_property(xml_child, ns, (const xmlChar *)attr->name, (const xmlChar *)attr->value, last_prop);
         }
 
         // Add children for this element.
@@ -373,12 +441,20 @@ parse_continue(VALUE parse_args)
   } else {
     doc = new_html_doc(NULL, NULL, NULL);
   }
-  args->doc = doc; // Make sure doc gets cleaned up if an error is thrown.
+
+  // We're about to build the libxml2 tree structure from the Gumbo tree
+  // structure. If an exception is raised during tree building, control passes
+  // to `parse_cleanup()` which needs to free the newly allocated `xmlDoc`,
+  // `doc`. If the tree is successfully constructed, then
+  // `noko_xml_document_wrap()` will create a new Ruby object which will own
+  // `doc`. In that case, `parse_cleanup()` should not free `doc`.
+  args->doc = doc;
   build_tree(doc, (xmlNodePtr)doc, output->document);
+  args->doc = NULL;
   VALUE rdoc = noko_xml_document_wrap(args->klass, doc);
+
   rb_iv_set(rdoc, "@url", args->url_or_frag);
   rb_iv_set(rdoc, "@quirks_mode", INT2NUM(output->document->v.document.doc_type_quirks_mode));
-  args->doc = NULL; // The Ruby runtime now owns doc so don't delete it.
   add_errors(output, rdoc, args->input, args->url_or_frag);
   return rdoc;
 }
@@ -512,6 +588,7 @@ error:
         continue;
       }
       VALUE element_name = rb_funcall(node, name, 0);
+      Check_Type(element_name, T_STRING);
       if (RSTRING_LEN(element_name) == 4
           && !st_strcasecmp(RSTRING_PTR(element_name), "form")
           && lookup_namespace(node, false) == GUMBO_NAMESPACE_HTML) {
@@ -568,7 +645,7 @@ error:
     .output = output,
     .input = tags,
     .url_or_frag = doc_fragment,
-    .doc = (xmlDocPtr)extract_xml_node(doc),
+    .doc = NULL,
   };
   rb_ensure(fragment_continue, (VALUE)(&args), parse_cleanup, (VALUE)(&args));
   return Qnil;
@@ -580,9 +657,9 @@ fragment_continue(VALUE parse_args)
   ParseArgs *args = (ParseArgs *)parse_args;
   GumboOutput *output = args->output;
   VALUE doc_fragment = args->url_or_frag;
-  xmlDocPtr xml_doc = args->doc;
+  VALUE doc = rb_funcall(doc_fragment, rb_intern_const("document"), 0);
+  xmlDocPtr xml_doc = (xmlDocPtr)extract_xml_node(doc);
 
-  args->doc = NULL; // The Ruby runtime owns doc so make sure we don't delete it.
   xmlNodePtr xml_frag = extract_xml_node(doc_fragment);
   build_tree(xml_doc, xml_frag, output->root);
   rb_iv_set(doc_fragment, "@quirks_mode", INT2NUM(output->document->v.document.doc_type_quirks_mode));

data/ext/nokogiri/html4_document.c

@@ -18,8 +18,8 @@ rb_html_document_s_new(int argc, VALUE *argv, VALUE klass)
   htmlDocPtr doc;
 
   rb_scan_args(argc, argv, "0*", &rest);
-  uri = rb_ary_entry(rest, (long)0);
-  external_id = rb_ary_entry(rest, (long)1);
+  uri = rb_ary_entry(rest, (rb_len_t)0);
+  external_id = rb_ary_entry(rest, (rb_len_t)1);
 
   doc = htmlNewDoc(
           RTEST(uri) ? (const xmlChar *)StringValueCStr(uri) : NULL,
@@ -48,10 +48,17 @@ rb_html_document_s_read_io(VALUE klass, VALUE rb_io, VALUE rb_url, VALUE rb_enco
 
   xmlSetStructuredErrorFunc((void *)rb_error_list, noko__error_array_pusher);
 
-  c_doc = htmlReadIO(noko_io_read, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
+  noko_io_read_reset_exception();
+  c_doc = htmlReadIO(noko_io_read_protected, noko_io_close, (void *)rb_io, c_url, c_encoding, options);
+  VALUE rb_io_read_exception = noko_io_read_take_exception();
 
   xmlSetStructuredErrorFunc(NULL, NULL);
 
+  if (!NIL_P(rb_io_read_exception)) {
+    xmlFreeDoc(c_doc);
+    noko_io_read_raise_exception(rb_io_read_exception);
+  }
+
   /*
    * If EncodingFound has occurred in EncodingReader, make sure to do
    * a cleanup and propagate the error.

data/ext/nokogiri/libxml2_polyfill.c

@@ -112,3 +112,15 @@ xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding)
   return (xmlSwitchToEncoding(ctxt, handler));
 }
 #endif
+
+#ifndef HAVE_XMLADDIDSAFE
+int
+xmlAddIDSafe(xmlAttrPtr attr, const xmlChar *value)
+{
+  xmlIDPtr id = xmlAddID(NULL, attr->doc, value, attr);
+  if (id) {
+    return 1;
+  }
+  return 0;
+}
+#endif

data/ext/nokogiri/nokogiri.c

@@ -50,7 +50,7 @@ void noko_init_html4_sax_parser(void);
 void noko_init_gumbo(void);
 void noko_init_test_global_handlers(void);
 
-static ID id_read, id_write, id_external_encoding;
+static ID id_read, id_write, id_external_encoding, id_io_read_exception;
 
 
 static VALUE
@@ -92,6 +92,87 @@ noko_io_read(void *io, char *c_buffer, int c_buffer_len)
 }
 
 
+typedef struct {
+  void *io;
+  char *c_buffer;
+  int c_buffer_len;
+  int n_bytes_read;
+} noko_io_read_args_t;
+
+static VALUE
+noko_io_read_call(VALUE data)
+{
+  noko_io_read_args_t *args = (noko_io_read_args_t *)data;
+  args->n_bytes_read = noko_io_read(args->io, args->c_buffer, args->c_buffer_len);
+  return Qnil;
+}
+
+
+/*
+ * Like noko_io_read, a StandardError raised by IO#read is swallowed, and libxml2 sees a read
+ * error. Any other exception (e.g., Interrupt or Timeout::ExitException) must not unwind through
+ * libxml2's stack frames, because that skips libxml2's cleanup and leaks memory, and skips the
+ * reset of the error handlers. So it is saved in a fiber-local variable, and $! is cleared until
+ * it is re-raised.
+ *
+ * A caller of libxml2 that passes this callback must call noko_io_read_reset_exception before
+ * calling libxml2, and noko_io_read_take_exception after libxml2 returns, and must re-raise a
+ * non-nil result with noko_io_read_raise_exception.
+ */
+int
+noko_io_read_protected(void *io, char *c_buffer, int c_buffer_len)
+{
+  noko_io_read_args_t args = { io, c_buffer, c_buffer_len, -1 };
+  int state = 0;
+
+  rb_protect(noko_io_read_call, (VALUE)&args, &state);
+
+  if (state) {
+    VALUE rb_errinfo_value = rb_errinfo();
+    if (RB_TYPE_P(rb_errinfo_value, T_OBJECT) && rb_obj_is_kind_of(rb_errinfo_value, rb_eException)) {
+      rb_set_errinfo(Qnil);
+    } else {
+      rb_errinfo_value = Qnil;
+    }
+    rb_thread_local_aset(rb_thread_current(), id_io_read_exception,
+                         rb_assoc_new(INT2FIX(state), rb_errinfo_value));
+    return -1;
+  }
+
+  return args.n_bytes_read;
+}
+
+
+void
+noko_io_read_reset_exception(void)
+{
+  rb_thread_local_aset(rb_thread_current(), id_io_read_exception, Qnil);
+}
+
+
+VALUE
+noko_io_read_take_exception(void)
+{
+  VALUE rb_thread = rb_thread_current();
+  VALUE rb_exception = rb_thread_local_aref(rb_thread, id_io_read_exception);
+
+  rb_thread_local_aset(rb_thread, id_io_read_exception, Qnil);
+  return rb_exception;
+}
+
+
+void
+noko_io_read_raise_exception(VALUE rb_exception)
+{
+  VALUE rb_errinfo_value = rb_ary_entry(rb_exception, 1);
+
+  if (!NIL_P(rb_errinfo_value)) {
+    rb_set_errinfo(rb_errinfo_value);
+  }
+  rb_jump_tag(FIX2INT(rb_ary_entry(rb_exception, 0)));
+}
+
+
 static VALUE
 noko_io_write_check(VALUE rb_args)
 {
@@ -122,7 +203,7 @@ noko_io_write(void *io, char *c_buffer, int c_buffer_len)
   io_encoding = RB_NIL_P(rb_enc) ? rb_ascii8bit_encoding() : rb_to_encoding(rb_enc);
 
   rb_args[0] = rb_io;
-  rb_args[1] = rb_enc_str_new(c_buffer, (long)c_buffer_len, io_encoding);
+  rb_args[1] = rb_enc_str_new(c_buffer, (rb_len_t)c_buffer_len, io_encoding);
 
   rb_n_bytes_written = rb_rescue(noko_io_write_check, (VALUE)rb_args, noko_io_write_failed, 0);
   if (rb_n_bytes_written == Qundef) { return -1; }
@@ -292,6 +373,7 @@ Init_nokogiri(void)
   noko_init_test_global_handlers();
 
   id_read = rb_intern("read");
+  id_io_read_exception = rb_intern("__nokogiri_io_read_exception");
   id_write = rb_intern("write");
   id_external_encoding = rb_intern("external_encoding");
 }

data/ext/nokogiri/nokogiri.h

@@ -66,6 +66,9 @@ int xmlCtxtGetOptions(xmlParserCtxtPtr ctxt);
 #ifndef HAVE_XMLSWITCHENCODINGNAME
 int xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding);
 #endif
+#ifndef HAVE_XMLADDIDSAFE
+int xmlAddIDSafe(xmlAttrPtr attr, const xmlChar *value);
+#endif
 
 #define XMLNS_PREFIX "xmlns"
 #define XMLNS_PREFIX_LEN 6 /* including either colon or \0 */
@@ -85,7 +88,7 @@ int xmlSwitchEncodingName(xmlParserCtxtPtr ctxt, const char *encoding);
 #include <ruby/version.h>
 
 #define NOKOGIRI_STR_NEW2(str) NOKOGIRI_STR_NEW(str, strlen((const char *)(str)))
-#define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (long)(len), rb_utf8_encoding())
+#define NOKOGIRI_STR_NEW(str, len) rb_external_str_new_with_enc((const char *)(str), (rb_len_t)(len), rb_utf8_encoding())
 #define RBSTR_OR_QNIL(_str) (_str ? NOKOGIRI_STR_NEW2(_str) : Qnil)
 
 #ifndef NORETURN_DECL
@@ -178,6 +181,10 @@ void noko_xml_document_pin_namespace(xmlNsPtr, xmlDocPtr);
 int noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document);
 
 int noko_io_read(void *ctx, char *buffer, int len);
+int noko_io_read_protected(void *ctx, char *buffer, int len);
+void noko_io_read_reset_exception(void);
+VALUE noko_io_read_take_exception(void);
+NORETURN_DECL void noko_io_read_raise_exception(VALUE rb_exception);
 int noko_io_write(void *ctx, char *buffer, int len);
 int noko_io_close(void *ctx);
 
@@ -234,6 +241,17 @@ void noko_xml_sax_parser_context_set_encoding(xmlParserCtxtPtr c_context, VALUE
 #  define NOKO_WARN_DEPRECATION(message...) rb_warning(message)
 #endif
 
+#ifndef HAVE_RB_LEN_T
+typedef long rb_len_t;
+#endif
+#ifndef RB_NUM2LEN
+#define RB_NUM2LEN RB_NUM2LONG
+#endif
+/* Ruby 4.1.0-preview1 defines HAVE_RB_LEN_T but not RB_FIX2LEN, which came later. */
+#ifndef RB_FIX2LEN
+#define RB_FIX2LEN RB_FIX2LONG
+#endif
+
 void noko__structured_error_func_save(libxmlStructuredErrorHandlerState *handler_state);
 void noko__structured_error_func_save_and_set(libxmlStructuredErrorHandlerState *handler_state, void *user_data,
     xmlStructuredErrorFunc handler);

data/ext/nokogiri/xml_document.c

@@ -384,17 +384,24 @@ noko_xml_document_s_read_io(VALUE rb_class,
 
   const char *c_url    = NIL_P(rb_url)      ? NULL : StringValueCStr(rb_url);
   const char *c_enc    = NIL_P(rb_encoding) ? NULL : StringValueCStr(rb_encoding);
+  noko_io_read_reset_exception();
   xmlDocPtr c_document = xmlReadIO(
-                           (xmlInputReadCallback)noko_io_read,
+                           (xmlInputReadCallback)noko_io_read_protected,
                            (xmlInputCloseCallback)noko_io_close,
                            (void *)rb_io,
                            c_url,
                            c_enc,
                            (int)NUM2INT(rb_options)
                          );
+  VALUE rb_io_read_exception = noko_io_read_take_exception();
 
   noko__structured_error_func_restore(&handler_state);
 
+  if (!NIL_P(rb_io_read_exception)) {
+    xmlFreeDoc(c_document);
+    noko_io_read_raise_exception(rb_io_read_exception);
+  }
+
   if (c_document == NULL) {
     xmlFreeDoc(c_document);
 
@@ -464,7 +471,7 @@ new (int argc, VALUE *argv, VALUE klass)
   VALUE version, rest, rb_doc ;
 
   rb_scan_args(argc, argv, "0*", &rest);
-  version = rb_ary_entry(rest, (long)0);
+  version = rb_ary_entry(rest, (rb_len_t)0);
   if (NIL_P(version)) { version = rb_str_new2("1.0"); }
 
   doc = xmlNewDoc((xmlChar *)StringValueCStr(version));
@@ -609,7 +616,8 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
   VALUE rb_namespaces;
   VALUE rb_comments_p;
   int c_mode = 0;
-  xmlChar **c_namespaces;
+  xmlChar **c_namespaces = NULL;
+  VALUE rb_namespaces_buffer = 0;
 
   xmlDocPtr c_doc;
   xmlOutputBufferPtr c_obuf;
@@ -629,6 +637,35 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     if (c_mode == XML_C14N_1_0 || c_mode == XML_C14N_1_1) {
       rb_raise(rb_eRuntimeError, "This canonicalizer does not support this operation");
     }
+
+    // Copy every prefix into one temporary buffer before libxml2 sees it. Converting first means a
+    // raise from #to_str or a null byte leaks nothing. Copying means GC compaction, which moves the
+    // bytes of embedded strings, cannot move a prefix while libxml2 reads it. No allocation may
+    // happen between reading a prefix's pointer and copying its bytes.
+    rb_len_t ns_len = RARRAY_LEN(rb_namespaces);
+    VALUE rb_prefixes = rb_ary_new_capa(ns_len);
+    for (rb_len_t j = 0; j < ns_len; j++) {
+      VALUE entry = rb_ary_entry(rb_namespaces, j);
+      StringValueCStr(entry);
+      rb_ary_push(rb_prefixes, entry);
+    }
+
+    size_t size = ((size_t)ns_len + 1) * sizeof(xmlChar *);
+    for (rb_len_t j = 0; j < ns_len; j++) {
+      size += (size_t)RSTRING_LEN(RARRAY_AREF(rb_prefixes, j)) + 1;
+    }
+    c_namespaces = ALLOCV(rb_namespaces_buffer, size);
+
+    xmlChar *c_prefix = (xmlChar *)(c_namespaces + ns_len + 1);
+    for (rb_len_t j = 0; j < ns_len; j++) {
+      VALUE prefix = RARRAY_AREF(rb_prefixes, j);
+      size_t prefix_len = (size_t)RSTRING_LEN(prefix);
+      memcpy(c_prefix, RSTRING_PTR(prefix), prefix_len);
+      c_prefix[prefix_len] = '\0';
+      c_namespaces[j] = c_prefix;
+      c_prefix += prefix_len + 1;
+    }
+    c_namespaces[ns_len] = NULL;
   }
 
   c_doc = noko_xml_document_unwrap(self);
@@ -646,24 +683,13 @@ rb_xml_document_canonicalize(int argc, VALUE *argv, VALUE self)
     rb_callback = (void *)rb_block_proc();
   }
 
-  if (NIL_P(rb_namespaces)) {
-    c_namespaces = NULL;
-  } else {
-    long ns_len = RARRAY_LEN(rb_namespaces);
-    c_namespaces = ruby_xcalloc((size_t)ns_len + 1, sizeof(xmlChar *));
-    for (int j = 0 ; j < ns_len ; j++) {
-      VALUE entry = rb_ary_entry(rb_namespaces, j);
-      c_namespaces[j] = (xmlChar *)StringValueCStr(entry);
-    }
-  }
-
   int ret = xmlC14NExecute(c_doc, c_callback_wrapper, rb_callback,
                            c_mode,
                            c_namespaces,
                            (int)RTEST(rb_comments_p),
                            c_obuf);
 
-  ruby_xfree(c_namespaces);
+  ALLOCV_END(rb_namespaces_buffer);
   xmlOutputBufferClose(c_obuf);
 
   if (ret < 0) {
@@ -733,7 +759,7 @@ noko_xml_document_has_wrapped_blank_nodes_p(xmlDocPtr c_document)
     return 0;
   }
 
-  for (long jnode = 0; jnode < RARRAY_LEN(cache); jnode++) {
+  for (rb_len_t jnode = 0; jnode < RARRAY_LEN(cache); jnode++) {
     xmlNodePtr node;
     VALUE element = rb_ary_entry(cache, jnode);