zstd-ruby 2.0.8 → 2.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2747a2ccb21d362d5523b5c986fd5f45e7bc2007a40710c303e14e69b66dd626
-  data.tar.gz: 9b396596f0877e8da07fedf4a90e5d54af41414262dd12754faff6b71e56b771
+  metadata.gz: 02555a47928cf342248cbe5335c2a6b4aad14e3c7f9d78bbb65bf83fa3791c16
+  data.tar.gz: b58b8db365ce2490998468d785f77b5500023d9f4840aa49ade89413308c9672
 SHA512:
-  metadata.gz: 5cdeca9f57890066be8ad60fa7768b0920faac9bae169f6ca5069302a38e48a8c1e22d6b93a13abda415447dc7d750f38aef923527d055d04075d0d81d9a6556
-  data.tar.gz: a625f95323296768a68ccbc98fa4a24175d8a6d2643b3ef7ee4bf3b7cb1ceef2afc4ba4ba263b7bf2b7dbbc279ae89231f92d0d043aa4a1c6d96e8b8e03aa776
+  metadata.gz: c2a700c515e5073d5a20b7383a8c890007aa2792db0fc27e5187bbfd2a3ff806929349d988e8809a29ac0d6616a12f3fab41583c8ab10afe4fd220a35da35e8b
+  data.tar.gz: e560ce637e53be29601f6cb610461a8c137808019902c1c2e461390400845a021e22a5749020ec3e6f842a94d02ecfae9fe155ef39485db6dcc7503b23d53967

data/.gitignore

@@ -22,3 +22,4 @@ vendor/
 .ruby-version
 
 .vscode
+mise.toml

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in zstd_ruby.gemspec
 gemspec
+
+if RUBY_PLATFORM.include?('linux') && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0')
+  gem 'ruby_memcheck', '~> 3.0'
+end

data/Rakefile

@@ -15,6 +15,32 @@ end
 
 task :default => [:clobber, :compile, :spec]
 
+begin
+  require 'ruby_memcheck'
+  require 'ruby_memcheck/rspec/rake_task'
+
+  RubyMemcheck.config(
+    binary_name: 'zstdruby',
+    # Valgrind and YJIT interfere with each other, adding noise and slowdown,
+    # so keep YJIT disabled while running under Valgrind.
+    ruby: "#{FileUtils::RUBY} --disable-yjit"
+  )
+
+  namespace :spec do
+    task :check_valgrind do
+      unless system('command -v valgrind > /dev/null 2>&1')
+        abort("\nValgrind is required for `rake spec:valgrind` but was not found.\n" \
+              "Install it first (Linux only), e.g. `sudo apt-get install valgrind`.\n")
+      end
+    end
+
+    RubyMemcheck::RSpec::RakeTask.new(valgrind: [:check_valgrind, :compile])
+  end
+rescue LoadError
+  # ruby_memcheck is an optional development dependency, absent on the platforms
+  # and Ruby versions the Gemfile excludes. Skip the task instead of breaking.
+end
+
 desc 'Sync zstd libs dirs to ext/zstdruby/libzstd'
 task :zstd_update do
   FileUtils.rm_r("ext/zstdruby/libzstd")

data/ext/zstdruby/common.h

@@ -24,7 +24,11 @@ static int convert_compression_level(ZSTD_CCtx* ctx, VALUE compression_level_val
   return NUM2INT(compression_level_value);
 }
 
-static void set_compress_params(ZSTD_CCtx* const ctx, VALUE kwargs)
+/* Returns the Zstd::CDict given as `dict:`, or Qnil. ZSTD_CCtx_refCDict only
+   borrows the pointer, so a caller that keeps the ZSTD_CCtx alive beyond this
+   call has to keep the returned object reachable for just as long. A String
+   dictionary needs no such handling: ZSTD_CCtx_loadDictionary copies it. */
+static VALUE set_compress_params(ZSTD_CCtx* const ctx, VALUE kwargs)
 {
   ID kwargs_keys[2];
   kwargs_keys[0] = rb_intern("level");
@@ -46,6 +50,7 @@ static void set_compress_params(ZSTD_CCtx* const ctx, VALUE kwargs)
         ZSTD_freeCCtx(ctx);
         rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_refCDict failed");
       }
+      return kwargs_values[1];
     } else if (TYPE(kwargs_values[1]) == T_STRING) {
       char* dict_buffer = RSTRING_PTR(kwargs_values[1]);
       size_t dict_size = RSTRING_LEN(kwargs_values[1]);
@@ -59,6 +64,7 @@ static void set_compress_params(ZSTD_CCtx* const ctx, VALUE kwargs)
       rb_raise(rb_eArgError, "`dict:` must be a Zstd::CDict or a String");
     }
   }
+  return Qnil;
 }
 
 struct stream_compress_params {
@@ -122,7 +128,9 @@ static size_t zstd_compress(ZSTD_CCtx* const ctx, char* output_data, size_t outp
 #endif
 }
 
-static void set_decompress_params(ZSTD_DCtx* const dctx, VALUE kwargs)
+/* Returns the Zstd::DDict given as `dict:`, or Qnil. See set_compress_params:
+   ZSTD_DCtx_refDDict borrows, ZSTD_DCtx_loadDictionary copies. */
+static VALUE set_decompress_params(ZSTD_DCtx* const dctx, VALUE kwargs)
 {
   ID kwargs_keys[1];
   kwargs_keys[0] = rb_intern("dict");
@@ -137,19 +145,21 @@ static void set_decompress_params(ZSTD_DCtx* const dctx, VALUE kwargs)
         ZSTD_freeDCtx(dctx);
         rb_raise(rb_eRuntimeError, "%s", "ZSTD_DCtx_refDDict failed");
       }
+      return kwargs_values[0];
     } else if (TYPE(kwargs_values[0]) == T_STRING) {
       char* dict_buffer = RSTRING_PTR(kwargs_values[0]);
       size_t dict_size = RSTRING_LEN(kwargs_values[0]);
       size_t load_dict_ret = ZSTD_DCtx_loadDictionary(dctx, dict_buffer, dict_size);
       if (ZSTD_isError(load_dict_ret)) {
         ZSTD_freeDCtx(dctx);
-        rb_raise(rb_eRuntimeError, "%s", "ZSTD_CCtx_loadDictionary failed");
+        rb_raise(rb_eRuntimeError, "%s", "ZSTD_DCtx_loadDictionary failed");
       }
     } else {
       ZSTD_freeDCtx(dctx);
       rb_raise(rb_eArgError, "`dict:` must be a Zstd::DDict or a String");
     }
   }
+  return Qnil;
 }
 
 struct stream_decompress_params {
@@ -181,35 +191,4 @@ static size_t zstd_stream_decompress(ZSTD_DCtx* const dctx, ZSTD_outBuffer* outp
 #endif
 }
 
-struct decompress_params {
-  ZSTD_DCtx* dctx;
-  char* output_data;
-  size_t output_size;
-  char* input_data;
-  size_t input_size;
-  size_t ret;
-};
-
-static void* decompress_wrapper(void* args)
-{
-    struct decompress_params* params = args;
-    params->ret = ZSTD_decompressDCtx(params->dctx, params->output_data, params->output_size, params->input_data, params->input_size);
-    return NULL;
-}
-
-static size_t zstd_decompress(ZSTD_DCtx* const dctx, char* output_data, size_t output_size, char* input_data, size_t input_size, bool gvl)
-{
-#ifdef HAVE_RUBY_THREAD_H
-    if (gvl) {
-      return ZSTD_decompressDCtx(dctx, output_data, output_size, input_data, input_size);
-    } else {
-      struct decompress_params params = { dctx, output_data, output_size, input_data, input_size };
-      rb_thread_call_without_gvl(decompress_wrapper, &params, NULL, NULL);
-      return params.ret;
-    }
-#else
-    return ZSTD_decompressDCtx(dctx, output_data, output_size, input_data, input_size);
-#endif
-}
-
 #endif /* ZSTD_RUBY_H */

data/ext/zstdruby/extconf.rb

@@ -26,7 +26,7 @@ def ext_export_filename
   name
 end
 
-$CFLAGS = '-I. -O3 -std=c99 -DZSTD_STATIC_LINKING_ONLY -DZSTD_MULTITHREAD -pthread -DDEBUGLEVEL=0 -fvisibility=hidden -DZSTDLIB_VISIBLE=\'__attribute__((visibility("hidden")))\' -DZSTDLIB_HIDDEN=\'__attribute__((visibility("hidden")))\''
+$CFLAGS += ' -I. -O3 -std=c99 -DZSTD_STATIC_LINKING_ONLY -DZSTD_MULTITHREAD -pthread -DDEBUGLEVEL=0 -fvisibility=hidden -DZSTDLIB_VISIBLE=\'__attribute__((visibility("hidden")))\' -DZSTDLIB_HIDDEN=\'__attribute__((visibility("hidden")))\''
 $CPPFLAGS += " -fdeclspec" if CONFIG['CXX'] =~ /clang/
 
 # macOS specific: Use exported_symbols_list to control symbol visibility

data/ext/zstdruby/streaming_compress.c

@@ -5,6 +5,7 @@ struct streaming_compress_t {
   VALUE buf;
   size_t buf_size;
   VALUE pending;   /* accumulate compressed bytes produced by write() */
+  VALUE dict;      /* Zstd::CDict the ctx borrows a pointer into, or Qnil */
 };
 
 static void
@@ -14,9 +15,11 @@ streaming_compress_mark(void *p)
 #ifdef HAVE_RB_GC_MARK_MOVABLE
   rb_gc_mark_movable(sc->buf);
   rb_gc_mark_movable(sc->pending);
+  rb_gc_mark_movable(sc->dict);
 #else
   rb_gc_mark(sc->buf);
   rb_gc_mark(sc->pending);
+  rb_gc_mark(sc->dict);
 #endif
 }
 
@@ -44,6 +47,7 @@ streaming_compress_compact(void *p)
   struct streaming_compress_t *sc = p;
   sc->buf = rb_gc_location(sc->buf);
   sc->pending = rb_gc_location(sc->pending);
+  sc->dict = rb_gc_location(sc->dict);
 }
 #endif
 
@@ -69,6 +73,7 @@ rb_streaming_compress_allocate(VALUE klass)
   RB_OBJ_WRITE(obj, &sc->buf, Qnil);
   sc->buf_size = 0;
   RB_OBJ_WRITE(obj, &sc->pending, Qnil);
+  RB_OBJ_WRITE(obj, &sc->dict, Qnil);
   return obj;
 }
 
@@ -86,9 +91,10 @@ rb_streaming_compress_initialize(int argc, VALUE *argv, VALUE obj)
   if (ctx == NULL) {
     rb_raise(rb_eRuntimeError, "%s", "ZSTD_createCCtx error");
   }
-  set_compress_params(ctx, kwargs);
+  VALUE dict = set_compress_params(ctx, kwargs);
 
   sc->ctx = ctx;
+  RB_OBJ_WRITE(obj, &sc->dict, dict);
   RB_OBJ_WRITE(obj, &sc->buf, rb_str_new(NULL, buffOutSize));
   sc->buf_size = buffOutSize;
   RB_OBJ_WRITE(obj, &sc->pending, rb_str_new(0, 0));
@@ -205,6 +211,8 @@ rb_streaming_compress_flush(VALUE obj)
   VALUE drained = no_compress(sc, ZSTD_e_flush);
   VALUE out = rb_str_dup(sc->pending);
   rb_str_cat(out, RSTRING_PTR(drained), RSTRING_LEN(drained));
+  /* prevent `drained` from being freed by GC inside rb_str_cat */
+  RB_GC_GUARD(drained);
   rb_str_resize(sc->pending, 0);
   return out;
 }
@@ -217,6 +225,8 @@ rb_streaming_compress_finish(VALUE obj)
   VALUE drained = no_compress(sc, ZSTD_e_end);
   VALUE out = rb_str_dup(sc->pending);
   rb_str_cat(out, RSTRING_PTR(drained), RSTRING_LEN(drained));
+  /* prevent `drained` from being freed by GC inside rb_str_cat */
+  RB_GC_GUARD(drained);
   rb_str_resize(sc->pending, 0);
   return out;
 }

data/ext/zstdruby/streaming_decompress.c

@@ -4,6 +4,7 @@ struct streaming_decompress_t {
   ZSTD_DCtx* dctx;
   VALUE buf;
   size_t buf_size;
+  VALUE dict;      /* Zstd::DDict the dctx borrows a pointer into, or Qnil */
 };
 
 static void
@@ -12,8 +13,10 @@ streaming_decompress_mark(void *p)
   struct streaming_decompress_t *sd = p;
 #ifdef HAVE_RB_GC_MARK_MOVABLE
   rb_gc_mark_movable(sd->buf);
+  rb_gc_mark_movable(sd->dict);
 #else
   rb_gc_mark(sd->buf);
+  rb_gc_mark(sd->dict);
 #endif
 }
 
@@ -40,6 +43,7 @@ streaming_decompress_compact(void *p)
 {
   struct streaming_decompress_t *sd = p;
   sd->buf = rb_gc_location(sd->buf);
+  sd->dict = rb_gc_location(sd->dict);
 }
 #endif
 
@@ -64,6 +68,7 @@ rb_streaming_decompress_allocate(VALUE klass)
   sd->dctx = NULL;
   RB_OBJ_WRITE(obj, &sd->buf, Qnil);
   sd->buf_size = 0;
+  RB_OBJ_WRITE(obj, &sd->dict, Qnil);
   return obj;
 }
 
@@ -81,9 +86,10 @@ rb_streaming_decompress_initialize(int argc, VALUE *argv, VALUE obj)
   if (dctx == NULL) {
     rb_raise(rb_eRuntimeError, "%s", "ZSTD_createDCtx error");
   }
-  set_decompress_params(dctx, kwargs);
+  VALUE dict = set_decompress_params(dctx, kwargs);
 
   sd->dctx = dctx;
+  RB_OBJ_WRITE(obj, &sd->dict, dict);
   RB_OBJ_WRITE(obj, &sd->buf, rb_str_new(NULL, buffOutSize));
   sd->buf_size = buffOutSize;
 

data/ext/zstdruby/zstdruby.c

@@ -51,7 +51,8 @@ static VALUE decode_one_frame(ZSTD_DCtx* dctx, const unsigned char* src, size_t
 
   for (;;) {
     ZSTD_outBuffer o = (ZSTD_outBuffer){ buf, cap, 0 };
-    size_t ret = ZSTD_decompressStream(dctx, &o, &in);
+    size_t const in_pos_before = in.pos;
+    size_t ret = zstd_stream_decompress(dctx, &o, &in, false);
     if (ZSTD_isError(ret)) {
       xfree(buf);
       rb_raise(rb_eRuntimeError, "ZSTD_decompressStream failed: %s", ZSTD_getErrorName(ret));
@@ -62,6 +63,13 @@ static VALUE decode_one_frame(ZSTD_DCtx* dctx, const unsigned char* src, size_t
     if (ret == 0) {
       break;
     }
+    /* A non-zero return is a "need more input" hint, not an error, and libzstd's
+       own noForwardProgress guard is bypassed by the early return it takes on a
+       truncated frame header -- so the stall has to be detected here. */
+    if (o.pos == 0 && in.pos == in_pos_before) {
+      xfree(buf);
+      rb_raise(rb_eRuntimeError, "ZSTD_decompressStream failed: truncated or incomplete frame");
+    }
   }
   xfree(buf);
   if (consumed) {
@@ -70,10 +78,6 @@ static VALUE decode_one_frame(ZSTD_DCtx* dctx, const unsigned char* src, size_t
   return out;
 }
 
-static VALUE decompress_buffered(ZSTD_DCtx* dctx, const char* data, size_t len) {
-  return decode_one_frame(dctx, (const unsigned char*)data, len, Qnil, NULL);
-}
-
 static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
 {
   VALUE input_value, kwargs;
@@ -124,6 +128,7 @@ static VALUE rb_decompress(int argc, VALUE *argv, VALUE self)
         result = out;
       } else {
         rb_str_cat(result, RSTRING_PTR(out), RSTRING_LEN(out));
+        RB_GC_GUARD(out);
       }
 
       if (consumed == 0) {
@@ -208,7 +213,7 @@ static VALUE rb_cdict_initialize(int argc, VALUE *argv, VALUE self)
 
 static VALUE rb_ddict_alloc(VALUE self)
 {
-  ZSTD_CDict* ddict = NULL;
+  ZSTD_DDict* ddict = NULL;
   return TypedData_Wrap_Struct(self, &ddict_type, ddict);
 }
 

data/lib/zstd-ruby/version.rb

@@ -1,3 +1,3 @@
 module Zstd
-  VERSION = "2.0.8"
+  VERSION = "2.0.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zstd-ruby
 version: !ruby/object:Gem::Version
-  version: 2.0.8
+  version: 2.0.10
 platform: ruby
 authors:
 - SpringMT
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-09 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler