mini_racer 0.17.0.pre4 → 0.17.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 877bcc1b7a601bcd6ef672cc17caeb7e21df723a440b1d07a2a4931e2a4d118a
-  data.tar.gz: e8ea952ea537c94d1c05998d521555d78349755ab1172925b24a4135d6691d99
+  metadata.gz: bd92c74de497ca8b317cb32e02345d204081c50ef44c11a61b0cfef3e32e2cff
+  data.tar.gz: b2074ffd330b91006c28e0d6b9a4b346a9a0e6d9de30cffd83bb426189262c4d
 SHA512:
-  metadata.gz: d1f45fb9e917632eff3131c9399710fad8f7ef47228e02f72a139122efd13565055b2851dc9348e6852cf009e1c5c93f0adf970544983f7713457f482a976a8d
-  data.tar.gz: 8ede15ef0dbe8a2b16ad9567d584ef57fcd2e0a2e801931476d7b4107d3c05154f70a5d1d96d7960919b939a4ea496d6d101a994b625d9a8000b79c7ee49bcc9
+  metadata.gz: 36dd26be30d9e22f5c227f8864a03e6f55224b9265799d604bf933b7458ead17960fef48de19a8d33f6c3c1578f83740c9c8c704541beb7964f6de23f4ec1fb9
+  data.tar.gz: 89067b89d2dbd6cf7b2af79991f30e53c6df8cc7d08e35623f730eb7010c287ccb98a29444375a7593f4494e11ad25b2c74a3d0b73ce104f7fc64edf22fb9e7e

data/CHANGELOG

@@ -1,3 +1,10 @@
+- 0.17.0.pre5 - 30-09-2024
+
+  - Handle segfault from JSON.stringify
+  - Fix segfaults around symbol conversion
+  - Fix crash on invalid date object
+
+
 - 0.17.0.pre4 - 18-09-2024
 
   - Attempt to change compilation flags to disable strict aliasing to see if it resolves stability issues

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -429,14 +429,17 @@ static void prepare_result(MaybeLocal<Value> v8res,
                 Local<Object> object = local_value->ToObject(context).ToLocalChecked();
                 const unsigned argc = 1;
                 Local<Value> argv[argc] = { object };
-                MaybeLocal<Value> json = stringify->Call(context, JSON, argc, argv);
+                MaybeLocal<Value> maybe_json = stringify->Call(context, JSON, argc, argv);
+                Local<Value> json;
 
-                if (json.IsEmpty()) {
+                if (!maybe_json.ToLocal(&json)) {
                     evalRes.executed = false;
                 } else {
-                    evalRes.json = true;
+                    // JSON.stringify() returns undefined for inputs that
+                    // are exotic objects, like WASM function or string refs
+                    evalRes.json = !json->IsUndefined();
                     Persistent<Value>* persistent = new Persistent<Value>();
-                    persistent->Reset(isolate, json.ToLocalChecked());
+                    persistent->Reset(isolate, json);
                     evalRes.value = persistent;
                 }
             }
@@ -565,6 +568,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 
     Isolate::Scope isolate_scope(isolate);
     HandleScope scope(isolate);
+    Context::Scope context_scope(context);
 
     StackCounter stackCounter(isolate);
 
@@ -586,10 +590,6 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
         return INT2FIX(value->Int32Value(context).ToChecked());
     }
 
-    if (value->IsNumber()) {
-        return rb_float_new(value->NumberValue(context).ToChecked());
-    }
-
     if (value->IsTrue()) {
         return Qtrue;
     }
@@ -598,81 +598,108 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
         return Qfalse;
     }
 
-    if (value->IsArray()) {
-      VALUE rb_array = rb_ary_new();
-      Local<Array> arr = Local<Array>::Cast(value);
-      for(uint32_t i=0; i < arr->Length(); i++) {
-          MaybeLocal<Value> element = arr->Get(context, i);
-          if (element.IsEmpty()) {
-              continue;
-          }
-          VALUE rb_elem = convert_v8_to_ruby(isolate, context, element.ToLocalChecked());
-          if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
-            return rb_elem;
-          }
-          rb_ary_push(rb_array, rb_elem);
-      }
-      return rb_array;
-    }
-
-    if (value->IsFunction()){
-        return rb_funcall(rb_cJavaScriptFunction, rb_intern("new"), 0);
-    }
-
-    if (value->IsDate()){
-        double ts = Local<Date>::Cast(value)->ValueOf();
-        double secs = ts/1000;
-        long nanos = round((secs - floor(secs)) * 1000000);
-
-        return rb_time_new(secs, nanos);
-    }
-
-    if (value->IsObject()) {
-        VALUE rb_hash = rb_hash_new();
-        TryCatch trycatch(isolate);
-
-        Local<Object> object = value->ToObject(context).ToLocalChecked();
-        auto maybe_props = object->GetOwnPropertyNames(context);
-        if (!maybe_props.IsEmpty()) {
-            Local<Array> props = maybe_props.ToLocalChecked();
-            for(uint32_t i=0; i < props->Length(); i++) {
-             MaybeLocal<Value> key = props->Get(context, i);
-             if (key.IsEmpty()) {
-                return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
-             }
-             VALUE rb_key = convert_v8_to_ruby(isolate, context, key.ToLocalChecked());
-
-             MaybeLocal<Value> prop_value = object->Get(context, key.ToLocalChecked());
-             // this may have failed due to Get raising
-             if (prop_value.IsEmpty() || trycatch.HasCaught()) {
-                 return new_empty_failed_conv_obj();
-             }
-
-             VALUE rb_value = convert_v8_to_ruby(
-                         isolate, context, prop_value.ToLocalChecked());
-             rb_hash_aset(rb_hash, rb_key, rb_value);
+    struct State {
+        Isolate* isolate;
+        Local<Value> value;
+        Local<Context> context;
+    } state = {isolate, value, context};
+
+    // calls to rb_*() functions can raise exceptions and longjmp,
+    // and therefore must be inside this protected block
+    auto can_raise = [](VALUE arg) -> VALUE {
+        State* state =
+            reinterpret_cast<State*>(static_cast<uintptr_t>(RB_NUM2ULL(arg)));
+        Isolate* isolate = state->isolate;
+        Local<Value> value = state->value;
+        Local<Context> context = state->context;
+
+        if (value->IsNumber()) {
+            return rb_float_new(value->NumberValue(context).ToChecked());
+        }
+
+        if (value->IsArray()) {
+            VALUE rb_array = rb_ary_new();
+            Local<Array> arr = Local<Array>::Cast(value);
+            for(uint32_t i = 0; i < arr->Length(); i++) {
+                MaybeLocal<Value> element = arr->Get(context, i);
+                if (element.IsEmpty()) {
+                    continue;
+                }
+                VALUE rb_elem = convert_v8_to_ruby(isolate, context, element.ToLocalChecked());
+                if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
+                    return rb_elem;
+                }
+                rb_ary_push(rb_array, rb_elem);
             }
+            return rb_array;
         }
-        return rb_hash;
-    }
 
-    if (value->IsSymbol()) {
-	v8::String::Utf8Value symbol_name(isolate,
-	    Local<Symbol>::Cast(value)->Description(isolate));
+        if (value->IsFunction()){
+            return rb_funcall(rb_cJavaScriptFunction, rb_intern("new"), 0);
+        }
 
-	VALUE str_symbol = rb_utf8_str_new(*symbol_name, symbol_name.length());
+        if (value->IsDate()){
+            double ts = Local<Date>::Cast(value)->ValueOf();
+            double secs = ts/1000;
+            long nanos = round((secs - floor(secs)) * 1000000);
 
-	return rb_str_intern(str_symbol);
-    }
+            return rb_time_new(secs, nanos);
+        }
 
-    MaybeLocal<String> rstr_maybe = value->ToString(context);
+        if (value->IsObject()) {
+            VALUE rb_hash = rb_hash_new();
+            TryCatch trycatch(isolate);
+
+            Local<Object> object = value->ToObject(context).ToLocalChecked();
+            auto maybe_props = object->GetOwnPropertyNames(context);
+            if (!maybe_props.IsEmpty()) {
+                Local<Array> props = maybe_props.ToLocalChecked();
+                for (uint32_t i = 0; i < props->Length(); i++) {
+                    MaybeLocal<Value> key = props->Get(context, i);
+                    if (key.IsEmpty()) {
+                        return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
+                    }
+                    VALUE rb_key = convert_v8_to_ruby(isolate, context, key.ToLocalChecked());
 
-    if (rstr_maybe.IsEmpty()) {
-	return Qnil;
-    } else {
-	Local<String> rstr = rstr_maybe.ToLocalChecked();
-	return rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
-    }
+                    MaybeLocal<Value> prop_value = object->Get(context, key.ToLocalChecked());
+                    // this may have failed due to Get raising
+                    if (prop_value.IsEmpty() || trycatch.HasCaught()) {
+                        return new_empty_failed_conv_obj();
+                    }
+
+                    VALUE rb_value = convert_v8_to_ruby(
+                             isolate, context, prop_value.ToLocalChecked());
+                    rb_hash_aset(rb_hash, rb_key, rb_value);
+                }
+            }
+            return rb_hash;
+        }
+
+        if (value->IsSymbol()) {
+            Local<Symbol> symbol = Local<Symbol>::Cast(value);
+            Local<Value> description = symbol->Description(isolate);
+            v8::String::Utf8Value symbol_name(isolate, description);
+
+            VALUE str_symbol = rb_utf8_str_new(*symbol_name, symbol_name.length());
+
+            return rb_str_intern(str_symbol);
+        }
+
+        MaybeLocal<String> rstr_maybe = value->ToString(context);
+
+        if (rstr_maybe.IsEmpty()) {
+            return Qnil;
+        } else {
+            Local<String> rstr = rstr_maybe.ToLocalChecked();
+            return rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
+        }
+    };
+
+    // this is kind of slow because RB_ULL2NUM allocs when the pointer
+    // doesn't fit in a fixnum but yolo'ing and reinterpret_casting the
+    // pointer to a VALUE is probably not very sound
+    VALUE arg = RB_ULL2NUM(reinterpret_cast<uintptr_t>(&state));
+    return rb_protect(can_raise, arg, nullptr);
 }
 
 static VALUE convert_v8_to_ruby(Isolate* isolate,

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.17.0.pre4"
+  VERSION = "0.17.0.pre5"
   LIBV8_NODE_VERSION = "~> 22.7.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.17.0.pre4
+  version: 0.17.0.pre5
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-17 00:00:00.000000000 Z
+date: 2024-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -119,9 +119,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.17.0.pre4/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.17.0.pre4
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.17.0.pre4
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.17.0.pre5/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.17.0.pre5
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.17.0.pre5
 post_install_message:
 rdoc_options: []
 require_paths: