mini_racer 0.17.0.pre7 → 0.17.0.pre9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d058a397309a0e5354576fa25b299f26e9ca9576b23333063dbcd46fcf9f775
-  data.tar.gz: 3dde7c0c2e713ebb419593eb6fb0d7634f07ee4d91e35549aa9fb57987a255e5
+  metadata.gz: b3be215eb4d4e72b01480ffa28863ea7ff1947b3f8cf0b6dcd860ffde2e48799
+  data.tar.gz: adcae327e54c2c372871c255e4bfd19a07b28964cd4c7c51cbc1cc251d1f71db
 SHA512:
-  metadata.gz: 8cf3e4c85acafb8161ff8a88d193b7bfde7e2b1ab241366364306a72416f462cbd31b4886a3b1f01402557a6045fd6ad40b1837849f307df9d3ac3fafdd7c6d0
-  data.tar.gz: a08db269e750b147daa7501cdf38dccdee8de7d07530b0112aecd1da3949b8daab704c778f1b3657d0dea328b087db9173f30e9aeb43f9d755d4a95dd1e51bac
+  metadata.gz: 98bdc234f17c0e16ae995c8fe3566f6ec80cbd92c569e4aa31ac1999d309ae2a197b0c7cb1c5de62f542f25b4f73287d0a34ab7967e1e24c32d02fc73ade33f2
+  data.tar.gz: 7ade32c683f240c3e19eaa58b6a044192f57b1e651966c042654d401f1f5dae1aff20d1c545dd7fd05afb2b0f70659080825b5a788ab82379b119c497ac31e47

data/CHANGELOG

@@ -1,3 +1,10 @@
+- 0.17.0.pre9 - 13-01-2025
+  - For backwards compatibility convert v8 return values to UTF-8 (invalidly encoded string still get returned using V8 encoding)
+
+- 0.17.0.pre8 - 11-01-2025
+  - Fix handling of UTF 32 LE and Ascii encoding strings - Ben Noordhuis
+  - Handle rare edge case in V8 serialization - Ben Noordhuis
+
 - 0.17.0.pre7 - 10-01-2025
 
   - Objects containing non serializable properties will return an Error object vs raising an exception. Ben Noordhuis

data/ext/mini_racer_extension/mini_racer_extension.c

@@ -164,12 +164,6 @@ static VALUE js_function_class;
 static pthread_mutex_t flags_mtx = PTHREAD_MUTEX_INITIALIZER;
 static Buf flags; // protected by |flags_mtx|
 
-struct rendezvous_nogvl
-{
-    Context *context;
-    Buf *req, *res;
-};
-
 // arg == &(struct rendezvous_nogvl){...}
 static void *rendezvous_callback(void *arg);
 
@@ -184,16 +178,30 @@ typedef struct DesCtx
 {
     State   *tos;
     VALUE   refs; // array
+    uint8_t transcode_latin1:1;
     char    err[64];
     State   stack[512];
 } DesCtx;
 
+struct rendezvous_nogvl
+{
+    Context *context;
+    Buf *req, *res;
+};
+
+struct rendezvous_des
+{
+    DesCtx *d;
+    Buf *res;
+};
+
 static void DesCtx_init(DesCtx *c)
 {
     c->tos  = c->stack;
     c->refs = rb_ary_new();
     *c->tos = (State){Qundef, Qundef};
     *c->err = '\0';
+    c->transcode_latin1 = 1; // convert to utf8
 }
 
 static void put(DesCtx *c, VALUE v)
@@ -321,9 +329,22 @@ static void des_string(void *arg, const char *s, size_t n)
     put(arg, rb_utf8_str_new(s, n));
 }
 
+static VALUE str_encode_bang(VALUE v)
+{
+    // TODO cache these? this function can get called often
+    return rb_funcall(v, rb_intern("encode!"), 1, rb_str_new_cstr("UTF-8"));
+}
+
 static void des_string8(void *arg, const uint8_t *s, size_t n)
 {
-    put(arg, rb_enc_str_new((char *)s, n, rb_ascii8bit_encoding()));
+    DesCtx *c;
+    VALUE v;
+
+    c = arg;
+    v = rb_enc_str_new((char *)s, n, rb_ascii8bit_encoding());
+    if (c->transcode_latin1)
+        v = str_encode_bang(v); // cannot fail
+    put(c, v);
 }
 
 // des_string16: |s| is not word aligned
@@ -331,7 +352,9 @@ static void des_string8(void *arg, const uint8_t *s, size_t n)
 static void des_string16(void *arg, const void *s, size_t n)
 {
     rb_encoding *e;
+    VALUE v, r;
     DesCtx *c;
+    int exc;
 
     c = arg;
     if (*c->err)
@@ -344,7 +367,15 @@ static void des_string16(void *arg, const void *s, size_t n)
         snprintf(c->err, sizeof(c->err), "no UTF16-LE encoding");
         return;
     }
-    put(c, rb_enc_str_new((char *)s, n, e));
+    v = rb_enc_str_new((char *)s, n, e);
+    // JS strings can contain unmatched or illegal surrogate pairs
+    // that Ruby won't decode; return the string as-is in that case
+    r = rb_protect(str_encode_bang, v, &exc);
+    if (exc) {
+        rb_set_errinfo(Qnil);
+        r = v;
+    }
+    put(c, r);
 }
 
 // ruby doesn't really have a concept of a byte array so store it as
@@ -422,6 +453,25 @@ static int collect(VALUE k, VALUE v, VALUE a)
     return ST_CONTINUE;
 }
 
+static void add_string(Ser *s, VALUE v)
+{
+    rb_encoding *e;
+    const void *p;
+    size_t n;
+
+    Check_Type(v, T_STRING);
+    e = rb_enc_get(v);
+    p = RSTRING_PTR(v);
+    n = RSTRING_LEN(v);
+    if (e) {
+        if (!strcmp(e->name, "ISO-8859-1"))
+            return ser_string8(s, p, n);
+        if (!strcmp(e->name, "UTF-16LE"))
+            return ser_string16(s, p, n);
+    }
+    return ser_string(s, p, n);
+}
+
 static int serialize1(Ser *s, VALUE refs, VALUE v)
 {
     unsigned long limbs[64];
@@ -525,7 +575,7 @@ static int serialize1(Ser *s, VALUE refs, VALUE v)
         v = rb_sym2str(v);
         // fallthru
     case T_STRING:
-        ser_string(s, RSTRING_PTR(v), RSTRING_LENINT(v));
+        add_string(s, v);
         break;
     default:
         snprintf(s->err, sizeof(s->err), "unsupported type %x", TYPE(v));
@@ -721,25 +771,25 @@ static void *v8_thread_start(void *arg)
     return NULL;
 }
 
-static VALUE deserialize1(const uint8_t *p, size_t n)
+static VALUE deserialize1(DesCtx *d, const uint8_t *p, size_t n)
 {
     char err[64];
-    DesCtx d;
 
-    DesCtx_init(&d);
-    if (des(&err, p, n, &d))
+    if (des(&err, p, n, d))
         rb_raise(runtime_error, "%s", err);
-    if (d.tos != d.stack) // should not happen
+    if (d->tos != d->stack) // should not happen
         rb_raise(runtime_error, "parse stack not empty");
-    return d.tos->a;
+    return d->tos->a;
 }
 
 static VALUE deserialize(VALUE arg)
 {
+    struct rendezvous_des *a;
     Buf *b;
 
-    b = (void *)arg;
-    return deserialize1(b->buf, b->len);
+    a = (void *)arg;
+    b = a->res;
+    return deserialize1(a->d, b->buf, b->len);
 }
 
 // called with |rr_mtx| and GVL held; can raise exception
@@ -748,6 +798,7 @@ static VALUE rendezvous_callback_do(VALUE arg)
     struct rendezvous_nogvl *a;
     VALUE func, args;
     Context *c;
+    DesCtx d;
     Buf *b;
 
     a = (void *)arg;
@@ -755,7 +806,8 @@ static VALUE rendezvous_callback_do(VALUE arg)
     c = a->context;
     assert(b->len > 0);
     assert(*b->buf == 'c');
-    args = deserialize1(b->buf+1, b->len-1); // skip 'c' marker
+    DesCtx_init(&d);
+    args = deserialize1(&d, b->buf+1, b->len-1); // skip 'c' marker
     func = rb_ary_pop(args); // callback id
     func = rb_ary_entry(c->procs, FIX2LONG(func));
     return rb_funcall2(func, rb_intern("call"), RARRAY_LENINT(args), RARRAY_PTR(args));
@@ -847,14 +899,14 @@ static void rendezvous_no_des(Context *c, Buf *req, Buf *res)
 
 // send request to & receive reply from v8 thread; takes ownership of |req|
 // can raise exceptions and longjmp away but won't leak |req|
-static VALUE rendezvous(Context *c, Buf *req)
+static VALUE rendezvous1(Context *c, Buf *req, DesCtx *d)
 {
     VALUE r;
     Buf res;
     int exc;
 
     rendezvous_no_des(c, req, &res); // takes ownership of |req|
-    r = rb_protect(deserialize, (VALUE)&res, &exc);
+    r = rb_protect(deserialize, (VALUE)&(struct rendezvous_des){d, &res}, &exc);
     buf_reset(&res);
     if (exc) {
         r = rb_errinfo();
@@ -869,6 +921,14 @@ static VALUE rendezvous(Context *c, Buf *req)
     return r;
 }
 
+static VALUE rendezvous(Context *c, Buf *req)
+{
+    DesCtx d;
+
+    DesCtx_init(&d);
+    return rendezvous1(c, req, &d);
+}
+
 static void handle_exception(VALUE e)
 {
     const char *s;
@@ -1062,7 +1122,7 @@ static VALUE context_attach(VALUE self, VALUE name, VALUE proc)
     // request is (A)ttach, [name, id] array
     ser_init1(&s, 'A');
     ser_array_begin(&s, 2);
-    ser_string(&s, RSTRING_PTR(name), RSTRING_LENINT(name));
+    add_string(&s, name);
     ser_int(&s, RARRAY_LENINT(c->procs));
     ser_array_end(&s, 2);
     rb_ary_push(c->procs, proc);
@@ -1159,8 +1219,8 @@ static VALUE context_eval(int argc, VALUE *argv, VALUE self)
     // request is (E)val, [filename, source] array
     ser_init1(&s, 'E');
     ser_array_begin(&s, 2);
-    ser_string(&s, RSTRING_PTR(filename), RSTRING_LENINT(filename));
-    ser_string(&s, RSTRING_PTR(source), RSTRING_LENINT(source));
+    add_string(&s, filename);
+    add_string(&s, source);
     ser_array_end(&s, 2);
     // response is [result, errname] array
     a = rendezvous(c, &s.b); // takes ownership of |s.b|
@@ -1450,6 +1510,7 @@ static VALUE snapshot_initialize(int argc, VALUE *argv, VALUE self)
     VALUE a, e, code, cv;
     Snapshot *ss;
     Context *c;
+    DesCtx d;
     Ser s;
 
     TypedData_Get_Struct(self, Snapshot, &snapshot_type, ss);
@@ -1462,9 +1523,11 @@ static VALUE snapshot_initialize(int argc, VALUE *argv, VALUE self)
     TypedData_Get_Struct(cv, Context, &context_type, c);
     // request is snapsho(T), "code"
     ser_init1(&s, 'T');
-    ser_string(&s, RSTRING_PTR(code), RSTRING_LENINT(code));
+    add_string(&s, code);
     // response is [arraybuffer, error]
-    a = rendezvous(c, &s.b);
+    DesCtx_init(&d);
+    d.transcode_latin1 = 0; // don't mangle snapshot binary data
+    a = rendezvous1(c, &s.b, &d);
     e = rb_ary_pop(a);
     context_dispose(cv);
     if (*RSTRING_PTR(e))
@@ -1478,6 +1541,7 @@ static VALUE snapshot_warmup(VALUE self, VALUE arg)
     VALUE a, e, cv;
     Snapshot *ss;
     Context *c;
+    DesCtx d;
     Ser s;
 
     TypedData_Get_Struct(self, Snapshot, &snapshot_type, ss);
@@ -1489,10 +1553,12 @@ static VALUE snapshot_warmup(VALUE self, VALUE arg)
     ser_init1(&s, 'W');
     ser_array_begin(&s, 2);
     ser_string8(&s, (const uint8_t *)RSTRING_PTR(ss->blob), RSTRING_LENINT(ss->blob));
-    ser_string(&s, RSTRING_PTR(arg), RSTRING_LENINT(arg));
+    add_string(&s, arg);
     ser_array_end(&s, 2);
     // response is [arraybuffer, error]
-    a = rendezvous(c, &s.b);
+    DesCtx_init(&d);
+    d.transcode_latin1 = 0; // don't mangle snapshot binary data
+    a = rendezvous1(c, &s.b, &d);
     e = rb_ary_pop(a);
     context_dispose(cv);
     if (*RSTRING_PTR(e))

data/ext/mini_racer_extension/serde.c

@@ -303,6 +303,14 @@ static void ser_string8(Ser *s, const uint8_t *p, size_t n)
     w(s, p, n);
 }
 
+// string must be utf16le; |n| is in bytes, not code points
+static void ser_string16(Ser *s, const void *p, size_t n)
+{
+    w_byte(s, 'c');
+    w_varint(s, n);
+    w(s, p, n);
+}
+
 static void ser_object_begin(Ser *s)
 {
     w_byte(s, 'o');
@@ -362,6 +370,7 @@ static int des1(char (*err)[64], const uint8_t **p, const uint8_t *pe,
 
     if (depth < 0)
         return bail(err, "too much recursion");
+again:
     if (*p >= pe)
         goto too_short;
     switch ((c = *(*p)++)) {
@@ -372,7 +381,9 @@ static int des1(char (*err)[64], const uint8_t **p, const uint8_t *pe,
             snprintf(*err, sizeof(*err), "bad tag: %02x", c);
         }
         return -1;
-    case '\0': // padding
+    case '\0': // skip alignment padding for two-byte strings
+        if (*p < pe)
+            goto again;
         break;
     case '^':
         if (r_varint(p, pe, &u))

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.17.0.pre7"
+  VERSION = "0.17.0.pre9"
   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.pre7
+  version: 0.17.0.pre9
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-09 00:00:00.000000000 Z
+date: 2025-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -123,9 +123,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.pre7/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.17.0.pre7
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.17.0.pre7
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.17.0.pre9/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.17.0.pre9
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.17.0.pre9
 post_install_message:
 rdoc_options: []
 require_paths: