cool.io 1.9.3 → 1.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 744af9f4092900f46b6db222fadf805f4fe107fb8f3c5c0a5c9661508d957ac5
-  data.tar.gz: 594ae4eb024a1c4519ec912859126b5e739f52cc3bdfab1f93ae8fc9cbf7610f
+  metadata.gz: 3da0843b8a62fd01aab297ce31f885a5856b4326bef2fb3c90d363f9576fe9a3
+  data.tar.gz: d073dd104500ccc2c1b62411c8f02c083df004353f9d2798ccf8ae41166effbd
 SHA512:
-  metadata.gz: 5b27d1af86f5647d9409b7b394d5ed9f2c85de9b68ab88d1d6363ca94aa05d84326f4feed754319f8409b371c53c61cb814292f7849618d806235b7e6de65007
-  data.tar.gz: 58839f3800e0aa902f4c0b60b7b23eff2414cb1c34a14df688b318e4b1d31151ce7dfcc6a8e9d7b1d818d5160cf858b0a8a533ee5d1adf1c195d00baa7f50d43
+  metadata.gz: b3f2fab2151abdbd3e0762aa04675cab8b4d196990227bf5d068f12360a62c87e669480f50e70b47b289a9c0f29deeddb28836590422faafe5d0a5ecaf6173fb
+  data.tar.gz: 233ea14784f4390b6b1f1b8fb131d5b1d20d14d0b78f9f1fd3b39f89bd25d34be505267d23d1b5647be2febcd5216e33a459c0e135ee49737334a06a0626bb47

data/.github/workflows/test.yaml

@@ -12,6 +12,7 @@ jobs:
     continue-on-error: ${{matrix.experimental}}
     
     strategy:
+      fail-fast: false
       matrix:
         os:
           - ubuntu

data/.github/workflows/valgrind.yaml

@@ -0,0 +1,44 @@
+name: Memcheck
+
+on: [push, pull_request]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{matrix.ruby}} on ${{matrix.os}}
+    runs-on: ${{matrix.os}}-latest
+    continue-on-error: ${{matrix.experimental}}
+    
+    strategy:
+      matrix:
+        os:
+          - ubuntu
+        
+        ruby:
+          - "3.2"
+          - "3.3"
+          - "3.4"
+          - "4.0"
+        
+        experimental: [false]
+        
+        include:
+          - os: ubuntu
+            ruby: head
+            experimental: true
+    
+    steps:
+    - uses: actions/checkout@v6
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{matrix.ruby}}
+        bundler-cache: true
+    - name: Install Valgrind
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y valgrind
+    - name: Run tests
+      timeout-minutes: 10
+      run: bundle exec rake spec:valgrind

data/Rakefile

@@ -22,7 +22,7 @@ end
 
 require 'rake/extensiontask'
 
-spec = eval(File.read("cool.io.gemspec"))
+spec = Gem::Specification.load("cool.io.gemspec")
 
 def configure_cross_compilation(ext)
   unless RUBY_PLATFORM =~ /mswin|mingw/
@@ -48,24 +48,11 @@ namespace :build do
   end
 end
 
-# adapted from http://flavoriffic.blogspot.com/2009/06/easily-valgrind-gdb-your-ruby-c.html
-def specs_command
-  require "find"
-  files = []
-  Find.find("spec") do |f|
-    files << f if File.basename(f) =~ /.*spec.*\.rb$/
-  end
-  cmdline = "#{RUBY} -I.:lib:ext:spec \
-               -e '%w[#{files.join(' ')}].each { |f| require f }'"
-end
-
-namespace :spec do
-  desc "run specs with valgrind"
-  task :valgrind => :compile do
-    system "valgrind --num-callers=15 \
-      --partial-loads-ok=yes --undef-value-errors=no \
-      --tool=memcheck --leak-check=yes --track-fds=yes \
-      --show-reachable=yes #{specs_command}"
+if RUBY_PLATFORM.include?('linux')
+  require 'ruby_memcheck'
+  require 'ruby_memcheck/rspec/rake_task'
+  namespace :spec do
+    RubyMemcheck::RSpec::RakeTask.new(valgrind: :compile)
   end
 end
 

data/cool.io.gemspec

@@ -1,6 +1,4 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "cool.io/version"
+require_relative "lib/cool.io/version"
 
 Gem::Specification.new do |s|
   s.name        = "cool.io"

data/ext/cool.io/buffer.c

@@ -28,17 +28,22 @@
 
 /* Default number of bytes in each node's buffer.  Should be >= MTU */
 #define DEFAULT_NODE_SIZE 16384
-static unsigned default_node_size = DEFAULT_NODE_SIZE;
+static size_t default_node_size = DEFAULT_NODE_SIZE;
 
+/*
+ * Byte counts are kept in size_t so the accounting cannot wrap while the
+ * buffer itself still holds the data.  node_size is capped at MAX_BUFFER_SIZE,
+ * but size grows with whatever the buffer is asked to hold.
+ */
 struct buffer {
-    unsigned size, node_size;
+    size_t size, node_size;
     struct buffer_node *head, *tail;
     struct buffer_node *pool_head, *pool_tail;
 
 };
 
 struct buffer_node {
-    unsigned start, end;
+    size_t start, end;
     struct buffer_node *next;
     unsigned char   data[0];
 };
@@ -68,13 +73,13 @@ static struct buffer *buffer_init(struct buffer *);
 static void     buffer_clear(struct buffer * buf);
 static void     buffer_free(struct buffer * buf);
 static void     buffer_free_pool(struct buffer * buf);
-static void     buffer_prepend(struct buffer * buf, char *str, unsigned len);
-static void     buffer_append(struct buffer * buf, char *str, unsigned len);
-static void     buffer_read(struct buffer * buf, char *str, unsigned len);
+static void     buffer_prepend(struct buffer * buf, char *str, size_t len);
+static void     buffer_append(struct buffer * buf, char *str, size_t len);
+static void     buffer_read(struct buffer * buf, char *str, size_t len);
 static int      buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark);
-static void     buffer_copy(struct buffer * buf, char *str, unsigned len);
-static int      buffer_read_from(struct buffer * buf, int fd);
-static int      buffer_write_to(struct buffer * buf, int fd);
+static void     buffer_copy(struct buffer * buf, char *str, size_t len);
+static ssize_t  buffer_read_from(struct buffer * buf, int fd);
+static ssize_t  buffer_write_to(struct buffer * buf, int fd);
 
 /*
  * High-performance I/O buffer intended for use in non-blocking programs
@@ -145,21 +150,21 @@ Coolio_Buffer_free(void * buf)
 
 /**
  * call-seq:
- *   Coolio::Buffer.default_node_size -> 4096
+ *   Coolio::Buffer.default_node_size -> 16384
  *
  * Retrieves the current value of the default node size.
  */
 static VALUE
 Coolio_Buffer_default_node_size(VALUE klass)
 {
-    return UINT2NUM(default_node_size);
+    return SIZET2NUM(default_node_size);
 }
 
 /*
  * safely converts node sizes from Ruby numerics to C and raising
  * ArgumentError or RangeError on invalid sizes
  */
-static unsigned
+static size_t
 convert_node_size(VALUE size)
 {
     if (
@@ -168,7 +173,7 @@ convert_node_size(VALUE size)
     )
         rb_raise(rb_eArgError, "invalid buffer size");
 
-    return (unsigned) NUM2INT(size);
+    return NUM2SIZET(size);
 }
 
 /**
@@ -241,7 +246,7 @@ Coolio_Buffer_size(VALUE self)
     struct buffer *buf;
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
-    return INT2NUM(buf->size);
+    return SIZET2NUM(buf->size);
 }
 
 /**
@@ -311,15 +316,18 @@ static VALUE
 Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
 {
     VALUE  length_obj, str;
-    int    length;
+    size_t length;
     struct buffer *buf;
 
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     if (rb_scan_args(argc, argv, "01", &length_obj) == 1) {
-        length = NUM2INT(length_obj);
-        if(length < 1)
+        /* Read signed so a negative argument still raises ArgumentError here
+         * rather than RangeError out of the conversion */
+        long requested = NUM2LONG(length_obj);
+        if(requested < 1)
           rb_raise(rb_eArgError, "length must be greater than zero");
+        length = (size_t) requested;
         if(length > buf->size)
           length = buf->size;
     } else
@@ -328,7 +336,7 @@ Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
     if(buf->size == 0)
         return rb_str_new2("");
 
-    str = rb_str_new(0, length);
+    str = rb_str_new(0, (long) length);
     buffer_read(buf, RSTRING_PTR(str), length);
 
     return str;
@@ -352,6 +360,9 @@ Coolio_Buffer_read_frame(VALUE self, VALUE data, VALUE mark)
 
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
+    StringValue(data);
+    rb_str_modify(data);
+
     if (buffer_read_frame(buf, data, mark_c)) {
         return Qtrue;
     } else {
@@ -373,7 +384,7 @@ Coolio_Buffer_to_str(VALUE self)
 
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
-    str = rb_str_new(0, buf->size);
+    str = rb_str_new(0, (long) buf->size);
     buffer_copy(buf, RSTRING_PTR(str), buf->size);
 
     return str;
@@ -391,7 +402,7 @@ static VALUE
 Coolio_Buffer_read_from(VALUE self, VALUE io)
 {
     struct buffer  *buf;
-    int             ret;
+    ssize_t         ret;
 #if defined(HAVE_RB_IO_T) || defined(HAVE_RB_IO_DESCRIPTOR)
     rb_io_t        *fptr;
 #else
@@ -408,7 +419,7 @@ Coolio_Buffer_read_from(VALUE self, VALUE io)
 #else
     ret = buffer_read_from(buf, FPTR_TO_FD(fptr));
 #endif
-    return ret == -1 ? Qnil : INT2NUM(ret);
+    return ret == -1 ? Qnil : SSIZET2NUM(ret);
 }
 
 /**
@@ -435,9 +446,9 @@ Coolio_Buffer_write_to(VALUE self, VALUE io)
     rb_io_set_nonblock(fptr);
 
 #ifdef HAVE_RB_IO_DESCRIPTOR
-    return INT2NUM(buffer_write_to(buf, rb_io_descriptor(io)));
+    return SSIZET2NUM(buffer_write_to(buf, rb_io_descriptor(io)));
 #else
-    return INT2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
+    return SSIZET2NUM(buffer_write_to(buf, FPTR_TO_FD(fptr)));
 #endif
 }
 
@@ -535,7 +546,7 @@ buffer_node_free(struct buffer * buf, struct buffer_node * node)
 
 /* Prepend data to the front of the buffer */
 static void
-buffer_prepend(struct buffer * buf, char *str, unsigned len)
+buffer_prepend(struct buffer * buf, char *str, size_t len)
 {
     struct buffer_node *node, *tmp;
     buf->size += len;
@@ -576,9 +587,9 @@ buffer_prepend(struct buffer * buf, char *str, unsigned len)
 
 /* Append data to the front of the buffer */
 static void
-buffer_append(struct buffer * buf, char *str, unsigned len)
+buffer_append(struct buffer * buf, char *str, size_t len)
 {
-    unsigned nbytes;
+    size_t nbytes;
     buf->size += len;
 
     /* If it fits in the remaining space in the tail */
@@ -613,9 +624,9 @@ buffer_append(struct buffer * buf, char *str, unsigned len)
 
 /* Read data from the buffer (and clear what we've read) */
 static void
-buffer_read(struct buffer * buf, char *str, unsigned len)
+buffer_read(struct buffer * buf, char *str, size_t len)
 {
-    unsigned nbytes;
+    size_t nbytes;
     struct buffer_node *tmp;
 
     while (buf->size > 0 && len > 0) {
@@ -649,7 +660,7 @@ buffer_read(struct buffer * buf, char *str, unsigned len)
 static int
 buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
 {
-    unsigned nbytes = 0;
+    size_t nbytes = 0;
     struct buffer_node *tmp;
 
     while (buf->size > 0) {
@@ -664,7 +675,7 @@ buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
         }
 
         /* Copy less than everything if we found a frame byte */
-        rb_str_cat(str, s, nbytes);
+        rb_str_cat(str, s, (long) nbytes);
 
         /* Fixup the buffer pointers to indicate the bytes were consumed */
         head->start += nbytes;
@@ -688,9 +699,9 @@ buffer_read_frame(struct buffer * buf, VALUE str, char frame_mark)
 
 /* Copy data from the buffer without clearing it */
 static void
-buffer_copy(struct buffer * buf, char *str, unsigned len)
+buffer_copy(struct buffer * buf, char *str, size_t len)
 {
-    unsigned nbytes;
+    size_t nbytes;
     struct buffer_node *node;
 
     node = buf->head;
@@ -709,10 +720,10 @@ buffer_copy(struct buffer * buf, char *str, unsigned len)
 }
 
 /* Write data from the buffer to a file descriptor */
-static int
+static ssize_t
 buffer_write_to(struct buffer * buf, int fd)
 {
-    int bytes_written, total_bytes_written = 0;
+    ssize_t bytes_written, total_bytes_written = 0;
     struct buffer_node *tmp;
 
     while (buf->head) {
@@ -730,7 +741,7 @@ buffer_write_to(struct buffer * buf, int fd)
         buf->size -= bytes_written;
 
         /* If the write blocked... */
-        if (bytes_written < buf->head->end - buf->head->start) {
+        if ((size_t) bytes_written < buf->head->end - buf->head->start) {
             buf->head->start += bytes_written;
             return total_bytes_written;
         }
@@ -748,11 +759,11 @@ buffer_write_to(struct buffer * buf, int fd)
 
 /* Read data from a file descriptor to a buffer */
 /* Append data to the front of the buffer */
-static int
+static ssize_t
 buffer_read_from(struct buffer * buf, int fd)
 {
-    int      bytes_read, total_bytes_read = 0;
-    unsigned nbytes;
+    ssize_t bytes_read, total_bytes_read = 0;
+    size_t  nbytes;
 
     /* Empty list needs initialized */
     if (!buf->head) {
@@ -782,7 +793,7 @@ buffer_read_from(struct buffer * buf, int fd)
             buf->tail->next = buffer_node_new(buf);
             buf->tail = buf->tail->next;
         }
-    } while (bytes_read == nbytes);
+    } while ((size_t) bytes_read == nbytes);
 
     return total_bytes_read;
 }

data/ext/cool.io/cool.io.h

@@ -55,6 +55,12 @@ struct Coolio_Watcher
   int enabled;
   VALUE loop;
 
+  /* Stable copy of the watched path for ev_stat watchers.  libev retains the
+   * path pointer passed to ev_stat_init() for the lifetime of the watcher, so
+   * it must not point into a Ruby String whose buffer GC.compact may relocate.
+   * NULL for watcher types that don't use it. */
+  char *stat_path;
+
   void (*dispatch_callback)(VALUE self, int revents);
 };
 

data/ext/cool.io/extconf.rb

@@ -11,7 +11,6 @@ have_func('rb_thread_alone')
 have_func('rb_str_set_len')
 have_library('rt', 'clock_gettime')
 
-have_func("rb_io_descriptor")
 have_library("c", "main")
 if have_macro("HAVE_RB_IO_T", "ruby/io.h")
   have_struct_member("rb_io_t", "fd", "ruby/io.h")

data/ext/cool.io/loop.c

@@ -110,8 +110,7 @@ void Coolio_Loop_process_event(VALUE watcher, int revents)
   struct Coolio_Loop *loop_data;
   struct Coolio_Watcher *watcher_data;
 
-  /* The Global VM lock isn't held right now, but hopefully
-   * we can still do this safely */
+  /* The Global VM Lock is held here, see the explanation below */
   watcher_data = Coolio_Watcher_ptr(watcher);
 
   if (watcher_data->enabled == 0) {
@@ -126,13 +125,14 @@ void Coolio_Loop_process_event(VALUE watcher, int revents)
    *
    *  Our call path up to here looks a little something like:
    *
-   *  -> release GVL -> event syscall -> libev callback
-   *  (GVL = Global VM Lock)             ^^^ You are here
+   *  -> release GVL -> event syscall -> reacquire GVL -> libev callback
+   *  (GVL = Global VM Lock)                              ^^^ You are here
    *
-   *  We released the GVL in the Coolio_Loop_run_once() function
-   *  so other Ruby threads can run while we make a blocking 
-   *  system call (one of epoll, kqueue, port, poll, or select,
-   *  depending on the platform).
+   *  libev is patched (see ev.c) to release the GVL around the blocking
+   *  system call (one of epoll, kqueue, port, poll, or select, depending
+   *  on the platform) so other Ruby threads can run while we wait there.
+   *  Only that call runs without the GVL: libev invokes the events it
+   *  collected after the call has returned, so we hold the GVL here.
    *
    *  More specifically, this is a libev callback abstraction
    *  called from a real libev callback in every watcher,
@@ -150,19 +150,19 @@ void Coolio_Loop_process_event(VALUE watcher, int revents)
    *  event fired, why the hell is it telling the loop?  Why
    *  doesn't it just rb_funcall() the appropriate callback?
    *
-   *  Well, the problem is the Global VM Lock isn't held right
-   *  now, so we can't rb_funcall() anything.  In order to get
-   *  it back we have to:
+   *  Because Ruby code doesn't run from inside libev's own event
+   *  invocation.  Instead:
    *
-   *  stash event and return -> acquire GVL -> dispatch to Ruby
+   *  stash event and return -> ev_loop() returns -> dispatch to Ruby
    *
-   *  Which is kinda ugly and confusing, but still gives us 
+   *  Which is kinda ugly and confusing, but still gives us
    *  an O(1) event loop whose heart is in the kernel itself. w00t!
    *
    *  So, stash the event in the loop's data struct.  When we return
    *  the ev_loop() call being made in the Coolio_Loop_run_once_blocking()
-   *  function below will also return, at which point the GVL is
-   *  reacquired and we can call out to Ruby */
+   *  function below will also return, and Coolio_Loop_dispatch_events()
+   *  walks what we stashed and calls out to Ruby.  A watcher detached
+   *  along the way nils its own stashed entries, which that walk skips */
 
   /* Grow the event buffer if it's too small */
   if(loop_data->events_received >= loop_data->eventbuf_size) {

data/ext/cool.io/stat_watcher.c

@@ -79,7 +79,9 @@ void Init_coolio_stat_watcher()
  */
 static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
 {
-	VALUE path, interval;
+  VALUE path, interval;
+  const char *path_str;
+  long path_len;
   struct Coolio_Watcher *watcher_data;
 
   rb_scan_args(argc, argv, "11", &path, &interval);
@@ -87,15 +89,26 @@ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
     interval = rb_convert_type(interval, T_FLOAT, "Float", "to_f");
 
   path = rb_String(path);
+  path_str = StringValueCStr(path);
   rb_iv_set(self, "@path", path);
 
   watcher_data = Coolio_Watcher_ptr(self);
 
+  /* libev keeps the path pointer passed to ev_stat_init() for the lifetime of
+   * the watcher.  RSTRING_PTR(path) points into a Ruby String whose buffer
+   * GC.compact may relocate, leaving libev with a dangling pointer.  Keep an
+   * owned copy instead; it is released in Coolio_Watcher_free(). */
+  path_len = strlen(path_str);
+  if(watcher_data->stat_path)
+    xfree(watcher_data->stat_path);
+  watcher_data->stat_path = xmalloc(path_len + 1);
+  memcpy(watcher_data->stat_path, path_str, path_len + 1);
+
   watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback;
   ev_stat_init(
       &watcher_data->event_types.ev_stat,
       Coolio_StatWatcher_libev_callback,
-      RSTRING_PTR(path),
+      watcher_data->stat_path,
       interval == Qnil ? 0 : NUM2DBL(interval)
   );
   watcher_data->event_types.ev_stat.data = (void *)self;

data/ext/cool.io/watcher.c

@@ -14,6 +14,7 @@ static VALUE cCoolio_Watcher = Qnil;
 
 static VALUE Coolio_Watcher_allocate(VALUE klass);
 static void Coolio_Watcher_mark(void *data);
+static void Coolio_Watcher_free(void *data);
 
 static VALUE Coolio_Watcher_initialize(VALUE self);
 static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop);
@@ -56,7 +57,7 @@ static const rb_data_type_t Coolio_Watcher_type = {
   "Coolio::Watcher",
   {
     Coolio_Watcher_mark,
-    RUBY_DEFAULT_FREE,
+    Coolio_Watcher_free,
   },
 };
 
@@ -75,6 +76,7 @@ static VALUE Coolio_Watcher_allocate(VALUE klass)
 
   watcher_data->loop = Qnil;
   watcher_data->enabled = 0;
+  watcher_data->stat_path = NULL;
 
   return watcher;
 }
@@ -87,6 +89,16 @@ static void Coolio_Watcher_mark(void *data)
     rb_gc_mark(watcher_data->loop);
 }
 
+static void Coolio_Watcher_free(void *data)
+{
+  struct Coolio_Watcher *watcher_data = data;
+
+  if(watcher_data->stat_path)
+    xfree(watcher_data->stat_path);
+
+  xfree(watcher_data);
+}
+
 static VALUE Coolio_Watcher_initialize(VALUE self)
 {
   rb_raise(rb_eRuntimeError, "watcher base class should not be initialized directly");

data/ext/cool.io/watcher.h

@@ -26,20 +26,15 @@
 
 #define Watcher_Detach(watcher_type, watcher) \
   struct Coolio_Watcher *watcher_data; \
-  struct Coolio_Loop *loop_data; \
   \
   watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
-  if (watcher_data->enabled == 0) { \
-    /* Ignore because watcher was already detached. */ \
-    return Qnil; \
+  if (watcher_data->enabled) { \
+    rb_funcall(watcher, rb_intern("disable"), 0); \
   } \
-  loop_data = Coolio_Loop_ptr(watcher_data->loop); \
-  \
-  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
   rb_call_super(0, 0)
 
 #define Watcher_Enable(watcher_type, watcher) \
@@ -66,10 +61,10 @@
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
-  rb_call_super(0, 0); \
-  \
-  loop_data = Coolio_Loop_ptr(watcher_data->loop); \
-  \
-  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
+  if (watcher_data->enabled) { \
+    loop_data = Coolio_Loop_ptr(watcher_data->loop); \
+    ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  } \
+  rb_call_super(0, 0);
 
 #endif

data/ext/libev/ev.c

@@ -210,7 +210,13 @@
 #else
 # include <io.h>
 # define WIN32_LEAN_AND_MEAN
-# define FD_SETSIZE 1024
+/* ruby.h above already pulled in winsock2.h, so fd_set may be dimensioned
+ * already. Defining FD_SETSIZE unconditionally here would only move the bound
+ * used by EV_WIN_FD_SET, not the array it indexes. Take whatever is in effect
+ * and only supply a default when nothing has been decided yet. */
+# ifndef FD_SETSIZE
+#  define FD_SETSIZE 1024
+# endif
 # include <winsock2.h>
 # include <windows.h>
 # ifndef EV_SELECT_IS_WINSOCKET

data/ext/libev/ev_select.c

@@ -107,6 +107,16 @@ if (__i == ((fd_set *)(set))->fd_count) {\
 #define EV_WIN_FD_ZERO(set) (((fd_set *)(set))->fd_count=0)
 #define EV_WIN_FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set *)(set))
 #define EV_WIN_FD_COUNT(set) (((fd_set *)(set))->fd_count)
+
+/*
+fd_set is dimensioned by whatever FD_SETSIZE was in effect when winsock2.h was
+first pulled in, but EV_WIN_FD_SET and select_modify bound-check against the
+FD_SETSIZE visible here. The two are decided by separate paths, so if the bound
+ever exceeds the declared array we would write past the end of the allocation in
+select_init. Catch that at build time instead.
+*/
+typedef char coolio_fd_setsize_matches_fd_set[
+	(sizeof (((fd_set *)0)->fd_array) / sizeof (SOCKET) >= (size_t)FD_SETSIZE) ? 1 : -1];
 /* ######################################## */
 #else
 #define EV_WIN_FD_CLR FD_CLR

data/gems.rb

@@ -7,3 +7,7 @@ group :maintenance, optional: true do
   gem "bake-gem"
   gem "bake-modernize"
 end
+
+group :development, :test do
+  gem 'ruby_memcheck', '~> 3.0' if RUBY_PLATFORM.include?('linux')
+end