brotli 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 05ff932639bf540d1187af86b6fedc95bbda8bbdfecee33631a6d8fb279c3c4f
-  data.tar.gz: d5041a8558bddb2935739372f95fa2c3a145155ac7fa1c0482f01048b20489ab
+  metadata.gz: 035e04e32804b36b5525cf4ba7688e19a199288e0056fcfceeeac67f11f72c9f
+  data.tar.gz: 8ce5e925a781060c0d46dfebd69beb367c62622fb808ef247906e0bf2229aaa8
 SHA512:
-  metadata.gz: 3f4cb09e9781d26a84bc7395a599f4ae5978c590aa67e7ecb56699d20e5a0834851d14330a09cad9213c42e42bd1c31ee387a030882da60835c788777f77ec69
-  data.tar.gz: 89156626b80f23ff447e51fd903f1b94e63952a1fa6ed9b53b08272287a6c22ca40f81e1f17155a242a28da9739a07f2c4b7fa4a8305807870abb8e2d6d6a0e9
+  metadata.gz: 70c2bdf0f5028d80f5f0c578f89bf2c6818de1c9c4f795fe61aeeffbbcf570353d97699ce02f9e44e713f54e34fd9c0a745d9b6f3ef9e7f9b62e5ffc6f1b0707
+  data.tar.gz: dd17edfde50109928ca623452044288b6d369cd6a29706727248623f8ad6d03ea89857fd668e67ca01b22a1baf39b27fbd47c86635a2455ec1c1d2400c4c5d77

data/ext/brotli/brotli.c

@@ -74,6 +74,7 @@ typedef struct {
     BrotliDecoderResult r;
     uint8_t* dict;
     size_t dict_len;
+    int oom;
 } brotli_inflate_args_t;
 
 static void
@@ -116,14 +117,19 @@ brotli_inflate_no_gvl(void *arg)
         if (r != BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT) {
             break;
         }
-        append_buffer(buffer, output, BUFSIZ);
+        if (append_buffer(buffer, output, BUFSIZ) != 0) {
+            args->oom = 1;
+            break;
+        }
         available_out = BUFSIZ;
         next_out = output;
     }
 
     if (r == BROTLI_DECODER_RESULT_SUCCESS) {
         if (next_out != output) {
-            append_buffer(buffer, output, next_out - output);
+            if (append_buffer(buffer, output, next_out - output) != 0) {
+                args->oom = 1;
+            }
         }
     }
     args->r = r;
@@ -166,6 +172,10 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
     args.len = (size_t)RSTRING_LEN(str);
     args.s = brotli_decoder_state_create();
     args.buffer = create_buffer(BUFSIZ);
+    if (!args.buffer) {
+        brotli_inflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate decompression buffer");
+    }
     args.r = BROTLI_DECODER_RESULT_ERROR;
 
     if (!NIL_P(dict)) {
@@ -180,6 +190,12 @@ brotli_inflate(int argc, VALUE *argv, VALUE self)
     RB_GC_GUARD(str);
     RB_GC_GUARD(dict);
 
+    /* Check before args.r: a failed final append leaves r at SUCCESS. */
+    if (args.oom) {
+        brotli_inflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate decompression buffer");
+    }
+
     if (args.r == BROTLI_DECODER_RESULT_SUCCESS) {
         int state = 0;
         value = rb_protect(brotli_inflate_take_result, (VALUE)&args, &state);
@@ -324,6 +340,7 @@ typedef struct {
     buffer_t* buffer;
     BROTLI_BOOL finished;
     BrotliEncoderPreparedDictionary* prepared_dict;
+    int oom;
 } brotli_deflate_args_t;
 
 static void
@@ -364,7 +381,11 @@ brotli_deflate_no_gvl(void *arg)
             args->finished = BROTLI_FALSE;
             break;
         } else {
-            append_buffer(buffer, output, next_out - output);
+            if (append_buffer(buffer, output, next_out - output) != 0) {
+                args->oom = 1;
+                args->finished = BROTLI_FALSE;
+                break;
+            }
             available_out = BUFSIZ;
             next_out = output;
 
@@ -418,6 +439,10 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     }
     max_compressed_size = BrotliEncoderMaxCompressedSize(args.len);
     args.buffer = create_buffer(max_compressed_size);
+    if (!args.buffer) {
+        brotli_deflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate compression buffer");
+    }
     args.finished = BROTLI_FALSE;
 
     args.prepared_dict = NULL;
@@ -443,6 +468,10 @@ brotli_deflate(int argc, VALUE *argv, VALUE self)
     rb_thread_call_without_gvl(brotli_deflate_no_gvl, &args, NULL, NULL);
     RB_GC_GUARD(str);
     RB_GC_GUARD(dict);
+    if (args.oom) {
+        brotli_deflate_cleanup(&args);
+        rb_raise(rb_eNoMemError, "failed to allocate compression buffer");
+    }
     if (args.finished == BROTLI_TRUE) {
         int state = 0;
         value = rb_protect(brotli_deflate_take_result, (VALUE)&args, &state);

data/ext/brotli/buffer.c

@@ -1,18 +1,32 @@
 #include "buffer.h"
-#include "ruby/ruby.h"
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
 #define BUFFER_INITIAL_SIZE 1024
 
+/*
+ * append_buffer runs inside rb_thread_call_without_gvl. A failing Ruby
+ * allocator there raises NoMemoryError past the caller's cleanup, so this
+ * buffer uses malloc/realloc/free and reports failure through return values.
+ */
+
 buffer_t*
 create_buffer(size_t initial)
 {
-    buffer_t *buffer = ruby_xmalloc(sizeof(*buffer));
+    buffer_t *buffer = malloc(sizeof(*buffer));
+
+    if (!buffer) {
+        return NULL;
+    }
     buffer->used = 0;
     buffer->size = initial > 0 ? initial : BUFFER_INITIAL_SIZE;
-    buffer->ptr = ruby_xmalloc(buffer->size);
+    buffer->ptr = malloc(buffer->size);
+    if (!buffer->ptr) {
+        free(buffer);
+        return NULL;
+    }
     return buffer;
 }
 
@@ -23,8 +37,8 @@ delete_buffer(buffer_t* buffer)
         return;
     }
 
-    ruby_xfree(buffer->ptr);
-    ruby_xfree(buffer);
+    free(buffer->ptr);
+    free(buffer);
 }
 
 static size_t
@@ -42,27 +56,37 @@ buffer_size_for(size_t current, size_t required)
     return size;
 }
 
-static void
+static int
 expand_buffer(buffer_t* buffer, size_t required)
 {
-    buffer->size = buffer_size_for(buffer->size, required);
-    buffer->ptr = ruby_xrealloc(buffer->ptr, buffer->size);
+    size_t size = buffer_size_for(buffer->size, required);
+    char* ptr = realloc(buffer->ptr, size);
+
+    if (!ptr) {
+        return -1;
+    }
+    buffer->ptr = ptr;
+    buffer->size = size;
+    return 0;
 }
 
-void
+int
 append_buffer(buffer_t* buffer, const void* ptr, size_t size)
 {
     size_t required;
 
     if (size == 0) {
-        return;
+        return 0;
     }
 
     required = buffer->used + size;
     if (required > buffer->size) {
-        expand_buffer(buffer, required);
+        if (expand_buffer(buffer, required) != 0) {
+            return -1;
+        }
     }
 
     memcpy(buffer->ptr + buffer->used, ptr, size);
     buffer->used += size;
+    return 0;
 }

data/ext/brotli/buffer.h

@@ -9,8 +9,10 @@ typedef struct {
     size_t used;
 } buffer_t;
 
+/* Never raise, so they are safe without the GVL. create_buffer returns NULL
+ * and append_buffer returns -1 when allocation fails. */
 buffer_t* create_buffer(size_t initial);
 void delete_buffer(buffer_t* buffer);
-void append_buffer(buffer_t* buffer, const void* ptr, size_t size);
+int append_buffer(buffer_t* buffer, const void* ptr, size_t size);
 
 #endif /* BUFFER_H */

data/ext/brotli/extconf.rb

@@ -129,5 +129,19 @@ if use_vendored_brotli
   $INCFLAGS << " -Ienc -Idec -Icommon -Iinclude"
 end
 
+# Leak-harness build hooks (inert unless the env var is set).
+# One append reaches brotli.c, buffer.c, and the vendored sources, because
+# add_vendored_sources_to_makefile rewrites ORIG_SRCS/OBJS after create_makefile.
+if ENV["BROTLI_DEBUG"] || ENV["BROTLI_ASAN"]
+  # Append -O0 last so it overrides any earlier optimization flag already in
+  # $CFLAGS (-O2/-O3/-Os/-Ofast/bare -O) -- the last -O on the command line wins
+  # for both gcc and clang. A gsub(/-O\d/) would miss -Os/-Ofast/-O.
+  $CFLAGS << " -O0 -g3 -fno-omit-frame-pointer"
+end
+if ENV["BROTLI_ASAN"]
+  $CFLAGS  << " -fsanitize=address"
+  $LDFLAGS << " -fsanitize=address"
+end
+
 create_makefile("brotli/brotli")
 add_vendored_sources_to_makefile if use_vendored_brotli

data/lib/brotli/version.rb

@@ -1,3 +1,3 @@
 module Brotli
-  VERSION = '0.9.1'
+  VERSION = '0.9.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brotli
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - miyucy