zlib 3.1.1 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7624f93a6b0776160dfd770df3287b57fa23e5844c15f036423feef6e3bd63ad
-  data.tar.gz: d7d82956712f9408ad0734246f0e3a16ecdba892fa7228ba4e96ab2288e50602
+  metadata.gz: 336dc64dd83cbbd9a74ca0494fd75bc2324ff0a615baa20b3c45c232ea6ee35a
+  data.tar.gz: f23633ed1053a62b9423628edf0ad19149bf1785371f5c5bc3b08900dabeb56e
 SHA512:
-  metadata.gz: 386968de72d272c978ab1d8be50eb27de3966c3f361d1b974fbec121836b7226eb92ad5c9b46acef8a68aa798232cb151693b29e4ac20decca2968102cfa0db7
-  data.tar.gz: a1562b664638ffc2fd3428d9fb4fda6d5011336d3b3b34afa05d4b8a6ba60f98a46790c682a0fab0992892704ac65ffa308c4d13622c7cbbdca12559a23f59d8
+  metadata.gz: d6b289bcde42b602690993bd4dc087928f1d50542ed9ddeffb148071f3e5eb9e37bd3891cfa9ec435648a62e01b6cffcfdc1dd92995674efe39c88c434843c6f
+  data.tar.gz: 00764a29cf1ecbe3a0db97919a911e98ec21d1690599381c12e34a736469f1be8643997964575b4782aa5a100b0f219e645ca067bd22ad222e34b723f886d2f0

data/README.md

@@ -53,7 +53,7 @@ puts "Uncompressed data is: #{uncompressed_data}"
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake compile test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 

data/ext/zlib/zlib.c

@@ -25,7 +25,7 @@
 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
 #endif
 
-#define RUBY_ZLIB_VERSION "3.1.1"
+#define RUBY_ZLIB_VERSION "3.2.3"
 
 #ifndef RB_PASS_CALLED_KEYWORDS
 # define rb_class_new_instance_kw(argc, argv, klass, kw_splat) rb_class_new_instance(argc, argv, klass)
@@ -90,7 +90,7 @@ static void zstream_expand_buffer_into(struct zstream*, unsigned long);
 static int zstream_expand_buffer_non_stream(struct zstream *z);
 static void zstream_append_buffer(struct zstream*, const Bytef*, long);
 static VALUE zstream_detach_buffer(struct zstream*);
-static VALUE zstream_shift_buffer(struct zstream*, long);
+static VALUE zstream_shift_buffer(struct zstream*, long, VALUE);
 static void zstream_buffer_ungets(struct zstream*, const Bytef*, unsigned long);
 static void zstream_buffer_ungetbyte(struct zstream*, int);
 static void zstream_append_input(struct zstream*, const Bytef*, long);
@@ -170,8 +170,8 @@ static void gzfile_check_footer(struct gzfile*, VALUE outbuf);
 static void gzfile_write(struct gzfile*, Bytef*, long);
 static long gzfile_read_more(struct gzfile*, VALUE outbuf);
 static void gzfile_calc_crc(struct gzfile*, VALUE);
-static VALUE gzfile_read(struct gzfile*, long);
-static VALUE gzfile_read_all(struct gzfile*);
+static VALUE gzfile_read(struct gzfile*, long, VALUE);
+static VALUE gzfile_read_all(struct gzfile*, VALUE);
 static void gzfile_ungets(struct gzfile*, const Bytef*, long);
 static void gzfile_ungetbyte(struct gzfile*, int);
 static VALUE gzfile_writer_end_run(VALUE);
@@ -674,9 +674,7 @@ zstream_expand_buffer(struct zstream *z)
 	        rb_obj_reveal(z->buf, rb_cString);
             }
 
-            rb_mutex_unlock(z->mutex);
-	    rb_protect(rb_yield, z->buf, &state);
-            rb_mutex_lock(z->mutex);
+            rb_protect(rb_yield, z->buf, &state);
 
             if (ZSTREAM_REUSE_BUFFER_P(z)) {
                 rb_str_modify(z->buf);
@@ -720,15 +718,14 @@ zstream_expand_buffer_into(struct zstream *z, unsigned long size)
     }
 }
 
-static void *
-zstream_expand_buffer_protect(void *ptr)
+static int
+zstream_expand_buffer_protect(struct zstream *z)
 {
-    struct zstream *z = (struct zstream *)ptr;
     int state = 0;
 
     rb_protect((VALUE (*)(VALUE))zstream_expand_buffer, (VALUE)z, &state);
 
-    return (void *)(VALUE)state;
+    return state;
 }
 
 static int
@@ -820,19 +817,31 @@ zstream_detach_buffer(struct zstream *z)
 }
 
 static VALUE
-zstream_shift_buffer(struct zstream *z, long len)
+zstream_shift_buffer(struct zstream *z, long len, VALUE dst)
 {
-    VALUE dst;
     char *bufptr;
     long buflen = ZSTREAM_BUF_FILLED(z);
 
     if (buflen <= len) {
-	return zstream_detach_buffer(z);
+        if (NIL_P(dst) || (!ZSTREAM_IS_FINISHED(z) && !ZSTREAM_IS_GZFILE(z) &&
+                rb_block_given_p())) {
+            return zstream_detach_buffer(z);
+        } else {
+            bufptr = RSTRING_PTR(z->buf);
+            rb_str_resize(dst, buflen);
+            memcpy(RSTRING_PTR(dst), bufptr, buflen);
+        }
+        buflen = 0;
+    } else {
+        bufptr = RSTRING_PTR(z->buf);
+        if (NIL_P(dst)) {
+            dst = rb_str_new(bufptr, len);
+        } else {
+            rb_str_resize(dst, len);
+            memcpy(RSTRING_PTR(dst), bufptr, len);
+        }
+        buflen -= len;
     }
-
-    bufptr = RSTRING_PTR(z->buf);
-    dst = rb_str_new(bufptr, len);
-    buflen -= len;
     memmove(bufptr, bufptr + len, buflen);
     rb_str_set_len(z->buf, buflen);
     z->stream.next_out = (Bytef*)RSTRING_END(z->buf);
@@ -851,9 +860,7 @@ zstream_buffer_ungets(struct zstream *z, const Bytef *b, unsigned long len)
     char *bufptr;
     long filled;
 
-    if (NIL_P(z->buf) || (long)rb_str_capacity(z->buf) <= ZSTREAM_BUF_FILLED(z)) {
-	zstream_expand_buffer_into(z, len);
-    }
+    zstream_expand_buffer_into(z, len);
 
     RSTRING_GETMEM(z->buf, bufptr, filled);
     memmove(bufptr + len, bufptr, filled);
@@ -1011,57 +1018,14 @@ zstream_ensure_end(VALUE v)
 }
 
 static void *
-zstream_run_func(void *ptr)
+zstream_run_once(void *_arguments)
 {
-    struct zstream_run_args *args = (struct zstream_run_args *)ptr;
-    int err, state, flush = args->flush;
-    struct zstream *z = args->z;
-    uInt n;
-
-    err = Z_OK;
-    while (!args->interrupt) {
-	n = z->stream.avail_out;
-	err = z->func->run(&z->stream, flush);
-	rb_str_set_len(z->buf, ZSTREAM_BUF_FILLED(z) + (n - z->stream.avail_out));
+    struct zstream_run_args *arguments = (struct zstream_run_args *)_arguments;
+    struct zstream *z = arguments->z;
 
-	if (err == Z_STREAM_END) {
-	    z->flags &= ~ZSTREAM_FLAG_IN_STREAM;
-	    z->flags |= ZSTREAM_FLAG_FINISHED;
-	    break;
-	}
+    uintptr_t error = z->func->run(&z->stream, arguments->flush);
 
-	if (err != Z_OK && err != Z_BUF_ERROR)
-	    break;
-
-	if (z->stream.avail_out > 0) {
-	    z->flags |= ZSTREAM_FLAG_IN_STREAM;
-	    break;
-	}
-
-	if (z->stream.avail_in == 0 && z->func == &inflate_funcs) {
-	    /* break here because inflate() return Z_BUF_ERROR when avail_in == 0. */
-	    /* but deflate() could be called with avail_in == 0 (there's hidden buffer
-	       in zstream->state) */
-	    z->flags |= ZSTREAM_FLAG_IN_STREAM;
-	    break;
-	}
-
-	if (args->stream_output) {
-	    state = (int)(VALUE)rb_thread_call_with_gvl(zstream_expand_buffer_protect,
-							(void *)z);
-	}
-	else {
-	    state = zstream_expand_buffer_non_stream(z);
-	}
-
-	if (state) {
-	    err = Z_OK; /* buffer expanded but stream processing was stopped */
-	    args->jump_state = state;
-	    break;
-	}
-    }
-
-    return (void *)(VALUE)err;
+    return (void*)error;
 }
 
 /*
@@ -1076,6 +1040,91 @@ zstream_unblock_func(void *ptr)
     args->interrupt = 1;
 }
 
+#ifndef RB_NOGVL_OFFLOAD_SAFE
+// Default to no-op if it's not defined:
+#define RB_NOGVL_OFFLOAD_SAFE 0
+#endif
+
+static VALUE
+zstream_run_once_begin(VALUE _arguments)
+{
+    struct zstream_run_args *arguments = (struct zstream_run_args *)_arguments;
+    struct zstream *z = arguments->z;
+
+    rb_str_locktmp(z->buf);
+
+#ifndef RB_NOGVL_UBF_ASYNC_SAFE
+    return (VALUE)rb_thread_call_without_gvl(zstream_run_once, (void *)arguments, zstream_unblock_func, (void *)arguments);
+#else
+    return (VALUE)rb_nogvl(zstream_run_once, (void *)arguments, zstream_unblock_func, (void *)arguments, RB_NOGVL_UBF_ASYNC_SAFE | RB_NOGVL_OFFLOAD_SAFE);
+#endif
+}
+
+static VALUE
+zstream_run_once_ensure(VALUE _arguments)
+{
+    struct zstream_run_args *arguments = (struct zstream_run_args *)_arguments;
+    struct zstream *z = arguments->z;
+
+    rb_str_unlocktmp(z->buf);
+
+    return Qnil;
+}
+
+static int
+zstream_run_func(struct zstream_run_args *args)
+{
+    struct zstream *z = args->z;
+    int state;
+    uInt n;
+
+    int err = Z_OK;
+    while (!args->interrupt) {
+        n = z->stream.avail_out;
+
+        err = (int)(VALUE)rb_ensure(zstream_run_once_begin, (VALUE)args, zstream_run_once_ensure, (VALUE)args);
+
+        rb_str_set_len(z->buf, ZSTREAM_BUF_FILLED(z) + (n - z->stream.avail_out));
+
+        if (err == Z_STREAM_END) {
+            z->flags &= ~ZSTREAM_FLAG_IN_STREAM;
+            z->flags |= ZSTREAM_FLAG_FINISHED;
+            break;
+        }
+
+        if (err != Z_OK && err != Z_BUF_ERROR)
+            break;
+
+        if (z->stream.avail_out > 0) {
+            z->flags |= ZSTREAM_FLAG_IN_STREAM;
+            break;
+        }
+
+        if (z->stream.avail_in == 0 && z->func == &inflate_funcs) {
+            /* break here because inflate() return Z_BUF_ERROR when avail_in == 0. */
+            /* but deflate() could be called with avail_in == 0 (there's hidden buffer
+                in zstream->state) */
+            z->flags |= ZSTREAM_FLAG_IN_STREAM;
+            break;
+        }
+
+        if (args->stream_output) {
+            state = zstream_expand_buffer_protect(z);
+        }
+        else {
+            state = zstream_expand_buffer_non_stream(z);
+        }
+
+        if (state) {
+            err = Z_OK; /* buffer expanded but stream processing was stopped */
+            args->jump_state = state;
+            break;
+        }
+    }
+
+    return err;
+}
+
 static VALUE
 zstream_run_try(VALUE value_arg)
 {
@@ -1088,6 +1137,12 @@ zstream_run_try(VALUE value_arg)
     int err;
     VALUE old_input = Qnil;
 
+    /* Cannot start zstream while it is in progress. */
+    if (z->flags & ZSTREAM_IN_PROGRESS) {
+	rb_raise(cInProgressError, "zlib stream is in progress");
+    }
+    z->flags |= ZSTREAM_IN_PROGRESS;
+
     if (NIL_P(z->input) && len == 0) {
 	z->stream.next_in = (Bytef*)"";
 	z->stream.avail_in = 0;
@@ -1108,14 +1163,7 @@ zstream_run_try(VALUE value_arg)
     }
 
 loop:
-#ifndef RB_NOGVL_UBF_ASYNC_SAFE
-    err = (int)(VALUE)rb_thread_call_without_gvl(zstream_run_func, (void *)args,
-						 zstream_unblock_func, (void *)args);
-#else
-    err = (int)(VALUE)rb_nogvl(zstream_run_func, (void *)args,
-                               zstream_unblock_func, (void *)args,
-                               RB_NOGVL_UBF_ASYNC_SAFE);
-#endif
+    err = zstream_run_func(args);
 
     /* retry if no exception is thrown */
     if (err == Z_OK && args->interrupt) {
@@ -1155,9 +1203,6 @@ loop:
 	rb_str_resize(old_input, 0);
     }
 
-    if (args->jump_state)
-	rb_jump_tag(args->jump_state);
-
     return Qnil;
 }
 
@@ -1165,25 +1210,10 @@ static VALUE
 zstream_run_ensure(VALUE value_arg)
 {
     struct zstream_run_args *args = (struct zstream_run_args *)value_arg;
+    struct zstream *z = args->z;
 
     /* Remove ZSTREAM_IN_PROGRESS flag to signal that this zstream is not in use. */
-    args->z->flags &= ~ZSTREAM_IN_PROGRESS;
-
-    return Qnil;
-}
-
-static VALUE
-zstream_run_synchronized(VALUE value_arg)
-{
-    struct zstream_run_args *args = (struct zstream_run_args *)value_arg;
-
-    /* Cannot start zstream while it is in progress. */
-    if (args->z->flags & ZSTREAM_IN_PROGRESS) {
-        rb_raise(cInProgressError, "zlib stream is in progress");
-    }
-    args->z->flags |= ZSTREAM_IN_PROGRESS;
-
-    rb_ensure(zstream_run_try, value_arg, zstream_run_ensure, value_arg);
+    z->flags &= ~ZSTREAM_IN_PROGRESS;
 
     return Qnil;
 }
@@ -1200,7 +1230,10 @@ zstream_run(struct zstream *z, Bytef *src, long len, int flush)
         .jump_state = 0,
         .stream_output = !ZSTREAM_IS_GZFILE(z) && rb_block_given_p(),
     };
-    rb_mutex_synchronize(z->mutex, zstream_run_synchronized, (VALUE)&args);
+
+    rb_ensure(zstream_run_try, (VALUE)&args, zstream_run_ensure, (VALUE)&args);
+    if (args.jump_state)
+	rb_jump_tag(args.jump_state);
 }
 
 static VALUE
@@ -1509,7 +1542,7 @@ rb_zstream_total_out(VALUE obj)
 }
 
 /*
- * Guesses the type of the data which have been inputed into the stream. The
+ * Guesses the type of the data which have been inputted into the stream. The
  * returned value is either <tt>BINARY</tt>, <tt>ASCII</tt>, or
  * <tt>UNKNOWN</tt>.
  */
@@ -1766,6 +1799,22 @@ do_deflate(struct zstream *z, VALUE src, int flush)
     }
 }
 
+struct rb_zlib_deflate_arguments {
+    struct zstream *z;
+    VALUE src;
+    int flush;
+};
+
+static VALUE
+rb_deflate_deflate_body(VALUE args)
+{
+    struct rb_zlib_deflate_arguments *arguments = (struct rb_zlib_deflate_arguments *)args;
+
+    do_deflate(arguments->z, arguments->src, arguments->flush);
+
+    return zstream_detach_buffer(arguments->z);
+}
+
 /*
  * Document-method: Zlib::Deflate#deflate
  *
@@ -1797,11 +1846,10 @@ rb_deflate_deflate(int argc, VALUE *argv, VALUE obj)
 {
     struct zstream *z = get_zstream(obj);
     VALUE src, flush;
-
     rb_scan_args(argc, argv, "11", &src, &flush);
-    do_deflate(z, src, ARG_FLUSH(flush));
+    struct rb_zlib_deflate_arguments arguments = {z, src, ARG_FLUSH(flush)};
 
-    return zstream_detach_buffer(z);
+    return rb_mutex_synchronize(z->mutex, rb_deflate_deflate_body, (VALUE)&arguments);
 }
 
 /*
@@ -2097,56 +2145,19 @@ rb_inflate_add_dictionary(VALUE obj, VALUE dictionary)
     return obj;
 }
 
-/*
- * Document-method: Zlib::Inflate#inflate
- *
- * call-seq:
- *   inflate(deflate_string, buffer: nil)                 -> String
- *   inflate(deflate_string, buffer: nil) { |chunk| ... } -> nil
- *
- * Inputs +deflate_string+ into the inflate stream and returns the output from
- * the stream.  Calling this method, both the input and the output buffer of
- * the stream are flushed.  If string is +nil+, this method finishes the
- * stream, just like Zlib::ZStream#finish.
- *
- * If a block is given consecutive inflated chunks from the +deflate_string+
- * are yielded to the block and +nil+ is returned.
- *
- * If a :buffer keyword argument is given and not nil:
- *
- * * The :buffer keyword should be a String, and will used as the output buffer.
- *   Using this option can reuse the memory required during inflation.
- * * When not passing a block, the return value will be the same object as the
- *   :buffer keyword argument.
- * * When passing a block, the yielded chunks will be the same value as the
- *   :buffer keyword argument.
- *
- * Raises a Zlib::NeedDict exception if a preset dictionary is needed to
- * decompress.  Set the dictionary by Zlib::Inflate#set_dictionary and then
- * call this method again with an empty string to flush the stream:
- *
- *   inflater = Zlib::Inflate.new
- *
- *   begin
- *     out = inflater.inflate compressed
- *   rescue Zlib::NeedDict
- *     # ensure the dictionary matches the stream's required dictionary
- *     raise unless inflater.adler == Zlib.adler32(dictionary)
- *
- *     inflater.set_dictionary dictionary
- *     inflater.inflate ''
- *   end
- *
- *   # ...
- *
- *   inflater.close
- *
- * See also Zlib::Inflate.new
- */
+struct rb_zlib_inflate_arguments {
+    struct zstream *z;
+    int argc;
+    VALUE *argv;
+};
+
 static VALUE
-rb_inflate_inflate(int argc, VALUE* argv, VALUE obj)
+rb_inflate_inflate_body(VALUE _arguments)
 {
-    struct zstream *z = get_zstream(obj);
+    struct rb_zlib_inflate_arguments *arguments = (struct rb_zlib_inflate_arguments*)_arguments;
+    struct zstream *z = arguments->z;
+    int argc = arguments->argc;
+    VALUE *argv = arguments->argv;
     VALUE dst, src, opts, buffer = Qnil;
 
     if (OPTHASH_GIVEN_P(opts)) {
@@ -2201,6 +2212,60 @@ rb_inflate_inflate(int argc, VALUE* argv, VALUE obj)
     return dst;
 }
 
+/*
+ * Document-method: Zlib::Inflate#inflate
+ *
+ * call-seq:
+ *   inflate(deflate_string, buffer: nil)                 -> String
+ *   inflate(deflate_string, buffer: nil) { |chunk| ... } -> nil
+ *
+ * Inputs +deflate_string+ into the inflate stream and returns the output from
+ * the stream.  Calling this method, both the input and the output buffer of
+ * the stream are flushed.  If string is +nil+, this method finishes the
+ * stream, just like Zlib::ZStream#finish.
+ *
+ * If a block is given consecutive inflated chunks from the +deflate_string+
+ * are yielded to the block and +nil+ is returned.
+ *
+ * If a :buffer keyword argument is given and not nil:
+ *
+ * * The :buffer keyword should be a String, and will used as the output buffer.
+ *   Using this option can reuse the memory required during inflation.
+ * * When not passing a block, the return value will be the same object as the
+ *   :buffer keyword argument.
+ * * When passing a block, the yielded chunks will be the same value as the
+ *   :buffer keyword argument.
+ *
+ * Raises a Zlib::NeedDict exception if a preset dictionary is needed to
+ * decompress.  Set the dictionary by Zlib::Inflate#set_dictionary and then
+ * call this method again with an empty string to flush the stream:
+ *
+ *   inflater = Zlib::Inflate.new
+ *
+ *   begin
+ *     out = inflater.inflate compressed
+ *   rescue Zlib::NeedDict
+ *     # ensure the dictionary matches the stream's required dictionary
+ *     raise unless inflater.adler == Zlib.adler32(dictionary)
+ *
+ *     inflater.set_dictionary dictionary
+ *     inflater.inflate ''
+ *   end
+ *
+ *   # ...
+ *
+ *   inflater.close
+ *
+ * See also Zlib::Inflate.new
+ */
+static VALUE
+rb_inflate_inflate(int argc, VALUE* argv, VALUE obj)
+{
+    struct zstream *z = get_zstream(obj);
+    struct rb_zlib_inflate_arguments arguments = {z, argc, argv};
+    return rb_mutex_synchronize(z->mutex, rb_inflate_inflate_body, (VALUE)&arguments);
+}
+
 /*
  * call-seq: << string
  *
@@ -2377,17 +2442,16 @@ struct gzfile {
 
 #define GZFILE_READ_SIZE  2048
 
+enum { read_raw_arg_len, read_raw_arg_buf, read_raw_arg__count};
 struct read_raw_arg {
     VALUE io;
-    union {
-	const VALUE argv[2]; /* for rb_funcallv */
-	struct {
-	    VALUE len;
-	    VALUE buf;
-	} in;
-    } as;
+    const VALUE argv[read_raw_arg__count]; /* for rb_funcallv */
 };
 
+#define read_raw_arg_argc(ra) \
+    ((int)read_raw_arg__count - NIL_P((ra)->argv[read_raw_arg__count - 1]))
+#define read_raw_arg_init(io, len, buf) { io, { len, buf } }
+
 static void
 gzfile_mark(void *p)
 {
@@ -2513,9 +2577,9 @@ gzfile_read_raw_partial(VALUE arg)
 {
     struct read_raw_arg *ra = (struct read_raw_arg *)arg;
     VALUE str;
-    int argc = NIL_P(ra->as.argv[1]) ? 1 : 2;
+    int argc = read_raw_arg_argc(ra);
 
-    str = rb_funcallv(ra->io, id_readpartial, argc, ra->as.argv);
+    str = rb_funcallv(ra->io, id_readpartial, argc, ra->argv);
     Check_Type(str, T_STRING);
     return str;
 }
@@ -2526,8 +2590,8 @@ gzfile_read_raw_rescue(VALUE arg, VALUE _)
     struct read_raw_arg *ra = (struct read_raw_arg *)arg;
     VALUE str = Qnil;
     if (rb_obj_is_kind_of(rb_errinfo(), rb_eNoMethodError)) {
-	int argc = NIL_P(ra->as.argv[1]) ? 1 : 2;
-	str = rb_funcallv(ra->io, id_read, argc, ra->as.argv);
+	int argc = read_raw_arg_argc(ra);
+	str = rb_funcallv(ra->io, id_read, argc, ra->argv);
         if (!NIL_P(str)) {
             Check_Type(str, T_STRING);
         }
@@ -2538,11 +2602,8 @@ gzfile_read_raw_rescue(VALUE arg, VALUE _)
 static VALUE
 gzfile_read_raw(struct gzfile *gz, VALUE outbuf)
 {
-    struct read_raw_arg ra;
-
-    ra.io = gz->io;
-    ra.as.in.len = INT2FIX(GZFILE_READ_SIZE);
-    ra.as.in.buf = outbuf;
+    struct read_raw_arg ra =
+	read_raw_arg_init(gz->io, INT2FIX(GZFILE_READ_SIZE), outbuf);
 
     return rb_rescue2(gzfile_read_raw_partial, (VALUE)&ra,
                       gzfile_read_raw_rescue, (VALUE)&ra,
@@ -2874,18 +2935,18 @@ gzfile_newstr(struct gzfile *gz, VALUE str)
 }
 
 static long
-gzfile_fill(struct gzfile *gz, long len)
+gzfile_fill(struct gzfile *gz, long len, VALUE outbuf)
 {
     if (len < 0)
         rb_raise(rb_eArgError, "negative length %ld given", len);
     if (len == 0)
 	return 0;
     while (!ZSTREAM_IS_FINISHED(&gz->z) && ZSTREAM_BUF_FILLED(&gz->z) < len) {
-	gzfile_read_more(gz, Qnil);
+	gzfile_read_more(gz, outbuf);
     }
     if (GZFILE_IS_FINISHED(gz)) {
 	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-	    gzfile_check_footer(gz, Qnil);
+	    gzfile_check_footer(gz, outbuf);
 	}
 	return -1;
     }
@@ -2893,14 +2954,27 @@ gzfile_fill(struct gzfile *gz, long len)
 }
 
 static VALUE
-gzfile_read(struct gzfile *gz, long len)
+gzfile_read(struct gzfile *gz, long len, VALUE outbuf)
 {
     VALUE dst;
 
-    len = gzfile_fill(gz, len);
-    if (len == 0) return rb_str_new(0, 0);
-    if (len < 0) return Qnil;
-    dst = zstream_shift_buffer(&gz->z, len);
+    len = gzfile_fill(gz, len, outbuf);
+
+    if (len < 0) {
+        if (!NIL_P(outbuf))
+            rb_str_resize(outbuf, 0);
+        return Qnil;
+    }
+    if (len == 0) {
+        if (NIL_P(outbuf))
+            return rb_str_new(0, 0);
+        else {
+            rb_str_resize(outbuf, 0);
+            return outbuf;
+        }
+    }
+
+    dst = zstream_shift_buffer(&gz->z, len, outbuf);
     if (!NIL_P(dst)) gzfile_calc_crc(gz, dst);
     return dst;
 }
@@ -2933,29 +3007,26 @@ gzfile_readpartial(struct gzfile *gz, long len, VALUE outbuf)
 	rb_raise(rb_eEOFError, "end of file reached");
     }
 
-    dst = zstream_shift_buffer(&gz->z, len);
+    dst = zstream_shift_buffer(&gz->z, len, outbuf);
     gzfile_calc_crc(gz, dst);
 
-    if (!NIL_P(outbuf)) {
-        rb_str_resize(outbuf, RSTRING_LEN(dst));
-        memcpy(RSTRING_PTR(outbuf), RSTRING_PTR(dst), RSTRING_LEN(dst));
-	dst = outbuf;
-    }
     return dst;
 }
 
 static VALUE
-gzfile_read_all(struct gzfile *gz)
+gzfile_read_all(struct gzfile *gz, VALUE dst)
 {
-    VALUE dst;
-
     while (!ZSTREAM_IS_FINISHED(&gz->z)) {
-	gzfile_read_more(gz, Qnil);
+	gzfile_read_more(gz, dst);
     }
     if (GZFILE_IS_FINISHED(gz)) {
 	if (!(gz->z.flags & GZFILE_FLAG_FOOTER_FINISHED)) {
-	    gzfile_check_footer(gz, Qnil);
+	    gzfile_check_footer(gz, dst);
 	}
+        if (!NIL_P(dst)) {
+            rb_str_resize(dst, 0);
+            return dst;
+        }
 	return rb_str_new(0, 0);
     }
 
@@ -2993,7 +3064,7 @@ gzfile_getc(struct gzfile *gz)
         de = (unsigned char *)ds + GZFILE_CBUF_CAPA;
         (void)rb_econv_convert(gz->ec, &sp, se, &dp, de, ECONV_PARTIAL_INPUT|ECONV_AFTER_OUTPUT);
         rb_econv_check_error(gz->ec);
-	dst = zstream_shift_buffer(&gz->z, sp - ss);
+	dst = zstream_shift_buffer(&gz->z, sp - ss, Qnil);
 	gzfile_calc_crc(gz, dst);
 	rb_str_resize(cbuf, dp - ds);
 	return cbuf;
@@ -3001,7 +3072,7 @@ gzfile_getc(struct gzfile *gz)
     else {
 	buf = gz->z.buf;
 	len = rb_enc_mbclen(RSTRING_PTR(buf), RSTRING_END(buf), gz->enc);
-	dst = gzfile_read(gz, len);
+	dst = gzfile_read(gz, len, Qnil);
 	if (NIL_P(dst)) return dst;
 	return gzfile_newstr(gz, dst);
     }
@@ -3909,7 +3980,7 @@ rb_gzreader_s_zcat(int argc, VALUE *argv, VALUE klass)
             if (!buf) {
                 buf = rb_str_new(0, 0);
             }
-            tmpbuf = gzfile_read_all(get_gzfile(obj));
+            tmpbuf = gzfile_read_all(get_gzfile(obj), Qnil);
             rb_str_cat(buf, RSTRING_PTR(tmpbuf), RSTRING_LEN(tmpbuf));
         }
 
@@ -4011,19 +4082,19 @@ static VALUE
 rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
 {
     struct gzfile *gz = get_gzfile(obj);
-    VALUE vlen;
+    VALUE vlen, outbuf;
     long len;
 
-    rb_scan_args(argc, argv, "01", &vlen);
+    rb_scan_args(argc, argv, "02", &vlen, &outbuf);
     if (NIL_P(vlen)) {
-	return gzfile_read_all(gz);
+	return gzfile_read_all(gz, outbuf);
     }
 
     len = NUM2INT(vlen);
     if (len < 0) {
 	rb_raise(rb_eArgError, "negative length %ld given", len);
     }
-    return gzfile_read(gz, len);
+    return gzfile_read(gz, len, outbuf);
 }
 
 /*
@@ -4032,7 +4103,7 @@ rb_gzreader_read(int argc, VALUE *argv, VALUE obj)
  *  call-seq:
  *     gzipreader.readpartial(maxlen [, outbuf]) => string, outbuf
  *
- *  Reads at most <i>maxlen</i> bytes from the gziped stream but
+ *  Reads at most <i>maxlen</i> bytes from the gzipped stream but
  *  it blocks only if <em>gzipreader</em> has no data immediately available.
  *  If the optional <i>outbuf</i> argument is present,
  *  it must reference a String, which will receive the data.
@@ -4096,7 +4167,7 @@ rb_gzreader_getbyte(VALUE obj)
     struct gzfile *gz = get_gzfile(obj);
     VALUE dst;
 
-    dst = gzfile_read(gz, 1);
+    dst = gzfile_read(gz, 1, Qnil);
     if (!NIL_P(dst)) {
 	dst = INT2FIX((unsigned int)(RSTRING_PTR(dst)[0]) & 0xff);
     }
@@ -4207,6 +4278,7 @@ gzreader_skip_linebreaks(struct gzfile *gz)
     while (n++, *(p++) == '\n') {
 	if (n >= ZSTREAM_BUF_FILLED(&gz->z)) {
 	    str = zstream_detach_buffer(&gz->z);
+	    ASSUME(!NIL_P(str));
 	    gzfile_calc_crc(gz, str);
 	    while (ZSTREAM_BUF_FILLED(&gz->z) == 0) {
 		if (GZFILE_IS_FINISHED(gz)) return;
@@ -4217,7 +4289,7 @@ gzreader_skip_linebreaks(struct gzfile *gz)
 	}
     }
 
-    str = zstream_shift_buffer(&gz->z, n - 1);
+    str = zstream_shift_buffer(&gz->z, n - 1, Qnil);
     gzfile_calc_crc(gz, str);
 }
 
@@ -4238,7 +4310,7 @@ gzreader_charboundary(struct gzfile *gz, long n)
     if (l < n) {
 	int n_bytes = rb_enc_precise_mbclen(p, e, gz->enc);
 	if (MBCLEN_NEEDMORE_P(n_bytes)) {
-	    if ((l = gzfile_fill(gz, n + MBCLEN_NEEDMORE_LEN(n_bytes))) > 0) {
+	    if ((l = gzfile_fill(gz, n + MBCLEN_NEEDMORE_LEN(n_bytes), Qnil)) > 0) {
 		return l;
 	    }
 	}
@@ -4290,10 +4362,10 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
 
     if (NIL_P(rs)) {
 	if (limit < 0) {
-	    dst = gzfile_read_all(gz);
+	    dst = gzfile_read_all(gz, Qnil);
 	    if (RSTRING_LEN(dst) == 0) return Qnil;
 	}
-	else if ((n = gzfile_fill(gz, limit)) <= 0) {
+	else if ((n = gzfile_fill(gz, limit, Qnil)) <= 0) {
 	    return Qnil;
 	}
 	else {
@@ -4303,7 +4375,7 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
 	    else {
 		n = limit;
 	    }
-	    dst = zstream_shift_buffer(&gz->z, n);
+	    dst = zstream_shift_buffer(&gz->z, n, Qnil);
 	    if (NIL_P(dst)) return dst;
 	    gzfile_calc_crc(gz, dst);
 	    dst = gzfile_newstr(gz, dst);
@@ -4330,7 +4402,7 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
     while (ZSTREAM_BUF_FILLED(&gz->z) < rslen) {
 	if (ZSTREAM_IS_FINISHED(&gz->z)) {
 	    if (ZSTREAM_BUF_FILLED(&gz->z) > 0) gz->lineno++;
-	    return gzfile_read(gz, rslen);
+	    return gzfile_read(gz, rslen, Qnil);
 	}
 	gzfile_read_more(gz, Qnil);
     }
@@ -4367,7 +4439,7 @@ gzreader_gets(int argc, VALUE *argv, VALUE obj)
     }
 
     gz->lineno++;
-    dst = gzfile_read(gz, n);
+    dst = gzfile_read(gz, n, Qnil);
     if (NIL_P(dst)) return dst;
     if (rspara) {
 	gzreader_skip_linebreaks(gz);
@@ -4615,6 +4687,7 @@ zlib_gunzip_run(VALUE arg)
 
     gzfile_read_header(gz, Qnil);
     dst = zstream_detach_buffer(&gz->z);
+    ASSUME(!NIL_P(dst));
     gzfile_calc_crc(gz, dst);
     if (!ZSTREAM_IS_FINISHED(&gz->z)) {
 	rb_raise(cGzError, "unexpected end of file");

metadata

@@ -1,20 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: zlib
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.3
 platform: ruby
 authors:
 - Yukihiro Matsumoto
 - UENO Katsuhiro
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: Ruby interface for the zlib compression/decompression library
 email:
 - matz@ruby-lang.org
-- 
+-
 executables: []
 extensions:
 - ext/zlib/extconf.rb
@@ -31,7 +30,6 @@ licenses:
 - Ruby
 - BSD-2-Clause
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -46,8 +44,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby interface for the zlib compression/decompression library
 test_files: []