cool.io 1.9.4 → 1.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f15a89de41069e6ccb37eb28befd01d601851ae1bb9ee2a5081e1c26e0bcc8da
-  data.tar.gz: de69fe197c029bbb4438e2e1c751580712ecc1f1b8326803d2089b738d3f74cc
+  metadata.gz: 3da0843b8a62fd01aab297ce31f885a5856b4326bef2fb3c90d363f9576fe9a3
+  data.tar.gz: d073dd104500ccc2c1b62411c8f02c083df004353f9d2798ccf8ae41166effbd
 SHA512:
-  metadata.gz: c88454501a2b042515b0571a729bac9a829ed7af72be377caf5ab6db08f90bb48adb1e19a69dee1b38eb1c77df9c084c88faa19d0077503c85a965e6c0c556ac
-  data.tar.gz: 8fd2af4f085bbb253df79cb8c9c685df97c5dc233f4be4891cef796120e9b265676e6fa4fe7c39b0b3b77447c000e41cbb1bc66b8939869e8747ac270619c436
+  metadata.gz: b3f2fab2151abdbd3e0762aa04675cab8b4d196990227bf5d068f12360a62c87e669480f50e70b47b289a9c0f29deeddb28836590422faafe5d0a5ecaf6173fb
+  data.tar.gz: 233ea14784f4390b6b1f1b8fb131d5b1d20d14d0b78f9f1fd3b39f89bd25d34be505267d23d1b5647be2febcd5216e33a459c0e135ee49737334a06a0626bb47

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/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

data/lib/cool.io/dns_resolver.rb

@@ -18,6 +18,8 @@
 #++
 
 require 'resolv'
+require 'securerandom'
+require 'socket'
 
 module Coolio
   # A non-blocking DNS resolver.  It provides interfaces for querying both
@@ -67,14 +69,22 @@ module Coolio
     # list of nameservers to query.  By default the resolver will
     # use nameservers listed in /etc/resolv.conf
     def initialize(hostname, *nameservers)
+      nameservers = reject_ipv6_nameservers(nameservers)
       if nameservers.empty?
-        nameservers = Resolv::DNS::Config.default_config_hash[:nameserver]
+        nameservers = reject_ipv6_nameservers(Resolv::DNS::Config.default_config_hash[:nameserver])
         raise RuntimeError, "no nameservers found" if nameservers.empty? # TODO just call resolve_failed, not raise [also handle Errno::ENOENT)]
       end
 
       @nameservers = nameservers.dup
       @question = request_question hostname
 
+      # A guessable ID would let an off-path attacker forge a response
+      @request_id = SecureRandom.random_number(1 << 16)
+
+      # Numeric addresses this query was sent to, and the lookups behind them
+      @queried_addresses = []
+      @numeric_addresses = {}
+
       @socket = UDPSocket.new
       @timer = Timeout.new(self)
 
@@ -113,27 +123,44 @@ module Coolio
 
     # Send a request to the DNS server
     def send_request
-      nameserver = @nameservers.shift
-      @nameservers << nameserver # rotate them
+      @nameservers.rotate!
+
+      # Send to the numeric address, so we know where a response must come from
+      address = numeric_address(@nameservers.first)
+      @queried_addresses << address unless @queried_addresses.include?(address)
+
       begin
-        @socket.send request_message, 0, @nameservers.first, DNS_PORT
+        @socket.send request_message, 0, address, DNS_PORT
       rescue Errno::EHOSTUNREACH # TODO figure out why it has to be wrapper here, when the other wrapper should be wrapping this one!
       end
     end
 
     # Called by the subclass when the DNS response is available
     def on_readable
-      datagram = nil
+      datagram = sender = nil
       begin
-        datagram = @socket.recvfrom_nonblock(DATAGRAM_SIZE).first
+        datagram, sender = @socket.recvfrom_nonblock(DATAGRAM_SIZE)
       rescue Errno::ECONNREFUSED
       end
 
+      # Ignore anything we didn't ask for, rather than resolving or failing on it.
+      # The query stays outstanding, so the retry timer still bounds us.
+      return if datagram and not solicited_response?(datagram, sender)
+
       address = response_address datagram rescue nil
       address ? on_success(address) : on_failure
       detach
     end
 
+    # Is this a reply to our query, from an address we sent it to?
+    # Retries rotate through @nameservers, so any address already queried counts.
+    def solicited_response?(datagram, sender)
+      return false unless datagram.size >= 12
+      return false unless sender and sender[1] == DNS_PORT and @queried_addresses.include?(sender[3])
+
+      datagram[0..1].unpack('n').first.to_i == @request_id
+    end
+
     def request_question(hostname)
       raise ArgumentError, "hostname cannot be nil" if hostname.nil?
 
@@ -151,7 +178,7 @@ module Coolio
 
     def request_message
       # Standard query header
-      message = [2, 1, 0].pack('nCC')
+      message = [@request_id, 1, 0].pack('nCC')
 
       # One entry
       qdcount = 1
@@ -166,7 +193,7 @@ module Coolio
     def response_address(message)
       # Confirm the ID field
       id = message[0..1].unpack('n').first.to_i
-      return unless id == 2
+      return unless id == @request_id
 
       # Check the QR value and confirm this message is a response
       qr = message[2..2].unpack('B1').first.to_i
@@ -204,6 +231,23 @@ module Coolio
       nil
     end
 
+    private
+
+    def reject_ipv6_nameservers(nameservers)
+      nameservers.reject { |ns| ns.include?(':') }
+    end
+
+    # The address of a nameserver, which may be given as a hostname.
+    # Only successful lookups are cached, so a transient failure is looked up again.
+    def numeric_address(nameserver)
+      @numeric_addresses[nameserver] ||= begin
+        addrinfo = Addrinfo.getaddrinfo(nameserver, nil, ::Socket::AF_INET, ::Socket::SOCK_DGRAM).first
+        raise SocketError, "getaddrinfo: no IPv4 address for #{nameserver}" if addrinfo.nil?
+
+        addrinfo.ip_address
+      end
+    end
+
     class Timeout < TimerWatcher
       def initialize(resolver)
         @resolver = resolver

data/lib/cool.io/version.rb

@@ -1,6 +1,6 @@
 module Coolio
-  VERSION = "1.9.4"
-  
+  VERSION = "1.9.5"
+
   def self.version
     VERSION
   end

data/libev_win_select.diff

@@ -1,20 +1,26 @@
 diff --git a/ext/libev/ev.c b/ext/libev/ev.c
-index dae87f1..d15f6bd 100644
+index a59efb2..5c18fd6 100644
 --- a/ext/libev/ev.c
 +++ b/ext/libev/ev.c
-@@ -207,6 +207,7 @@
+@@ -210,6 +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
 diff --git a/ext/libev/ev_select.c b/ext/libev/ev_select.c
-index f38d6ca..7050778 100644
+index ed1fc7a..eccff2b 100644
 --- a/ext/libev/ev_select.c
 +++ b/ext/libev/ev_select.c
-@@ -67,6 +67,54 @@
+@@ -67,6 +67,64 @@
  
  #include <string.h>
  
@@ -58,6 +64,16 @@ index f38d6ca..7050778 100644
 +#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
@@ -69,7 +85,7 @@ index f38d6ca..7050778 100644
  static void
  select_modify (EV_P_ int fd, int oev, int nev)
  {
-@@ -91,17 +139,17 @@ select_modify (EV_P_ int fd, int oev, int nev)
+@@ -91,17 +149,17 @@ select_modify (EV_P_ int fd, int oev, int nev)
      if ((oev ^ nev) & EV_READ)
      #endif
        if (nev & EV_READ)
@@ -91,7 +107,7 @@ index f38d6ca..7050778 100644
  
  #else
  
-@@ -197,8 +245,8 @@ select_poll (EV_P_ ev_tstamp timeout)
+@@ -197,8 +255,8 @@ select_poll (EV_P_ ev_tstamp timeout)
          {
            if (timeout)
              {
@@ -102,7 +118,7 @@ index f38d6ca..7050778 100644
              }
  
            return;
-@@ -230,10 +278,10 @@ select_poll (EV_P_ ev_tstamp timeout)
+@@ -230,10 +288,10 @@ select_poll (EV_P_ ev_tstamp timeout)
            int handle = fd;
            #endif
  
@@ -116,7 +132,7 @@ index f38d6ca..7050778 100644
            #endif
  
            if (expect_true (events))
-@@ -279,9 +327,9 @@ select_init (EV_P_ int flags)
+@@ -280,9 +338,9 @@ select_init (EV_P_ int flags)
    backend_poll    = select_poll;
  
  #if EV_SELECT_USE_FD_SET

data/spec/async_watcher_spec.rb

@@ -30,7 +30,9 @@ describe Cool.io::AsyncWatcher, :env => :exclude_win do
     end
 
     # ensure children are ready
-    nr_fork.times { expect(rd.sysread(1)).to eq('.') }
+    # rd may be O_NONBLOCK on macOS Ruby 3.2+ (IO.pipe sets O_NONBLOCK); use read
+    # instead of sysread so EAGAIN on an empty pipe is retried transparently.
+    nr_fork.times { expect(rd.read(1)).to eq('.') }
 
     # send our signals
     nr_signal.times { aw.signal }

data/spec/detach_race_condition_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
 
 describe Cool.io::Loop do
+  # An IOWatcher that drains its pipe and then runs a user-supplied block,
+  # receiving itself as the argument.
   class Victim < Cool.io::IOWatcher
-    def initialize(io)
-      super
+    def initialize(io, &on_readable)
+      super(io)
       @io = io
+      @on_readable = on_readable
     end
 
     def on_readable
@@ -12,38 +15,57 @@ describe Cool.io::Loop do
         @io.read_nonblock(1024)
       rescue IO::WaitReadable, EOFError
       end
+      @on_readable.call(self) if @on_readable
     end
   end
 
   # https://github.com/socketry/cool.io/issues/87
-  it "does not raise TypeError when a watcher is detached while an event is pending" do
-    loop = Cool.io::Loop.default
-
+  #
+  # Several watchers have an event pending in the same loop iteration.  When the
+  # first one dispatched detaches the others, the loop must skip their now-stale
+  # pending events instead of dispatching them to a detached watcher.  Before the
+  # fix that raised "TypeError: wrong argument type nil (expected Coolio::Loop)"
+  # and could crash the VM.
+  #
+  # This is exercised deterministically within a single thread (a preceding
+  # callback detaching another watcher in the same loop cycle).  The original
+  # reproduction detached from a separate thread while the loop was polling,
+  # which is an unsupported concurrent mutation of libev (not thread-safe) and
+  # crashed intermittently on macOS.
+  it "does not raise when a watcher with a pending event is detached during dispatch" do
     iterations = 200
 
     expect {
       iterations.times do
-        r_victim, w_victim = IO.pipe
-        victim_watcher = Victim.new(r_victim)
-        victim_watcher.attach(loop)
-
-        t1 = Thread.new do
-          sleep 0.01
-          w_victim.write("dummy\n")
-        end
-
-        t2 = Thread.new do
-          sleep 0.01
-          victim_watcher.detach
+        coolio_loop = Cool.io::Loop.new
+        pipes = []
+        watchers = []
+
+        5.times do
+          r, w = IO.pipe
+          pipes << [r, w]
+
+          watcher = Victim.new(r) do |fired|
+            # Detach every other watcher whose event is already queued for this
+            # same loop iteration.
+            watchers.each do |other|
+              other.detach if !other.equal?(fired) && other.attached?
+            end
+          end
+          watcher.attach(coolio_loop)
+          watchers << watcher
+
+          w.write("dummy\n") # make the read end readable so an event is pending
         end
 
-        loop.run_once
+        coolio_loop.run_once
 
-        t1.join
-        t2.join
+        # Only the first dispatched watcher runs; it detaches the other four,
+        # whose pending events are then skipped.
+        expect(watchers.count(&:attached?)).to eq(1)
 
-        r_victim.close
-        w_victim.close
+        watchers.each { |watcher| watcher.detach if watcher.attached? }
+        pipes.each { |r, w| r.close; w.close }
       end
     }.not_to raise_error
   end

data/spec/dns_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../spec_helper', __FILE__)
+require 'tempfile'
 
 VALID_DOMAIN = "google.com"
 INVALID_DOMAIN = "gibidigibigididibitidibigitibidigitidididi.com"
@@ -55,4 +56,189 @@ describe "DNS" do
       expect( Coolio::DNSResolver.hosts("localhost", file.path)).to eq @preferred_localhost_address
     end
   end
+
+  describe "IPv6 nameserver filtering" do
+    it "ignores IPv6 nameservers provided in arguments" do
+      resolver = Coolio::DNSResolver.new("example.com", "8.8.8.8", "2001:4860:4860::8888", "1.1.1.1")
+
+      nameservers = resolver.instance_variable_get(:@nameservers)
+      expect(nameservers).to eq(["8.8.8.8", "1.1.1.1"])
+    end
+
+    it "falls back to default IPv4 config if only IPv6 addresses are provided" do
+      allow(Resolv::DNS::Config).to receive(:default_config_hash).and_return({
+        nameserver: ["8.8.4.4", "2001:4860:4860::8844"]
+      })
+
+      resolver = Coolio::DNSResolver.new("example.com", "2001:4860:4860::8888")
+
+      nameservers = resolver.instance_variable_get(:@nameservers)
+      expect(nameservers).to eq(["8.8.4.4"])
+    end
+  end
+
+  describe "nameserver normalization" do
+    let(:localhost_address) do
+      Addrinfo.getaddrinfo("localhost", nil, ::Socket::AF_INET, ::Socket::SOCK_DGRAM).first.ip_address
+    end
+
+    it "keeps the nameserver list as given" do
+      resolver = Coolio::DNSResolver.new("example.com", "localhost")
+
+      expect(resolver.instance_variable_get(:@nameservers)).to eq(["localhost"])
+    end
+
+    it "queries the numeric address of a nameserver given as a hostname" do
+      resolver = Coolio::DNSResolver.new("example.com", "localhost")
+      resolver.__send__(:send_request)
+
+      expect(resolver.instance_variable_get(:@queried_addresses)).to eq([localhost_address])
+    end
+
+    it "accepts responses from a nameserver which was given as a hostname" do
+      resolver = Coolio::DNSResolver.new("example.com", "localhost")
+      resolver.__send__(:send_request)
+      response = dns_response_for(resolver)
+
+      expect(
+        resolver.__send__(:solicited_response?, response, ["AF_INET", 53, localhost_address, localhost_address])
+      ).to be true
+    end
+
+    it "looks a nameserver up once and reuses the result on retries" do
+      resolved = Addrinfo.getaddrinfo("127.0.0.1", nil, ::Socket::AF_INET, ::Socket::SOCK_DGRAM)
+      resolver = Coolio::DNSResolver.new("example.com", "127.0.0.1")
+
+      expect(Addrinfo).to receive(:getaddrinfo).once.and_return(resolved)
+
+      3.times { resolver.__send__(:send_request) }
+    end
+
+    it "does not reject an unresolvable nameserver at construction" do
+      allow(Addrinfo).to receive(:getaddrinfo).and_raise(SocketError, "getaddrinfo: Name or service not known")
+
+      expect do
+        Coolio::DNSResolver.new("example.com", "no-such-nameserver.invalid")
+      end.to_not raise_error
+    end
+
+    it "surfaces an unresolvable nameserver as a SocketError from the request" do
+      allow(Addrinfo).to receive(:getaddrinfo).and_raise(SocketError, "getaddrinfo: Name or service not known")
+      resolver = Coolio::DNSResolver.new("example.com", "no-such-nameserver.invalid")
+
+      expect { resolver.attach(@loop) }.to raise_error(SocketError)
+      expect(@loop.watchers).to be_empty
+    end
+
+    it "recovers when a nameserver is only transiently unresolvable" do
+      resolved = Addrinfo.getaddrinfo("127.0.0.1", nil, ::Socket::AF_INET, ::Socket::SOCK_DGRAM)
+      resolver = Coolio::DNSResolver.new("example.com", "ns.example.test")
+
+      attempts = 0
+      allow(Addrinfo).to receive(:getaddrinfo) do
+        attempts += 1
+        raise SocketError, "getaddrinfo: Name or service not known" if attempts == 1
+
+        resolved
+      end
+
+      expect { resolver.__send__(:send_request) }.to raise_error(SocketError)
+      expect { resolver.__send__(:send_request) }.to_not raise_error
+      expect(resolver.instance_variable_get(:@queried_addresses)).to eq(["127.0.0.1"])
+    end
+  end
+
+  describe "response validation" do
+    let(:nameserver) { "127.0.0.1" }
+    let(:sender) { ["AF_INET", 53, nameserver, nameserver] }
+    let(:resolver) do
+      Coolio::DNSResolver.new("example.com", nameserver).tap { |r| r.__send__(:send_request) }
+    end
+
+    it "uses an unpredictable transaction ID for each query" do
+      ids = 10.times.map do
+        request_id_of(Coolio::DNSResolver.new("example.com", nameserver))
+      end
+
+      expect(ids.uniq.size).to be > 1
+    end
+
+    it "accepts a response carrying our transaction ID from the queried nameserver" do
+      expect(
+        resolver.__send__(:solicited_response?, dns_response_for(resolver), sender)
+      ).to be true
+    end
+
+    it "rejects a response carrying a different transaction ID" do
+      forged = dns_response_for(resolver, id: (request_id_of(resolver) + 1) % 65536)
+
+      expect(resolver.__send__(:solicited_response?, forged, sender)).to be false
+    end
+
+    it "rejects a response from a source address we did not query" do
+      response = dns_response_for(resolver)
+
+      expect(
+        resolver.__send__(:solicited_response?, response, ["AF_INET", 53, "10.11.12.13", "10.11.12.13"])
+      ).to be false
+    end
+
+    it "rejects a response arriving before the request was sent" do
+      unsent = Coolio::DNSResolver.new("example.com", nameserver)
+
+      expect(unsent.__send__(:solicited_response?, dns_response_for(unsent), sender)).to be false
+    end
+
+    it "rejects a response from a source port other than the DNS port" do
+      response = dns_response_for(resolver)
+
+      expect(
+        resolver.__send__(:solicited_response?, response, ["AF_INET", 4444, nameserver, nameserver])
+      ).to be false
+    end
+
+    it "rejects a truncated datagram" do
+      expect(resolver.__send__(:solicited_response?, "\0\0", sender)).to be false
+    end
+
+    it "resolves from a response sent by the queried nameserver" do
+      response = dns_response_for(resolver, address: "1.2.3.4")
+      allow(resolver.instance_variable_get(:@socket)).to receive(:recvfrom_nonblock).and_return([response, sender])
+
+      expect(resolver).to receive(:on_success).with("1.2.3.4")
+      expect(resolver).to receive(:detach)
+
+      resolver.__send__(:on_readable)
+    end
+
+    it "ignores a spoofed response instead of resolving or failing it" do
+      forged = dns_response_for(resolver, address: "6.6.6.6")
+      allow(resolver.instance_variable_get(:@socket)).to receive(:recvfrom_nonblock)
+        .and_return([forged, ["AF_INET", 53, "10.11.12.13", "10.11.12.13"]])
+
+      expect(resolver).to_not receive(:on_success)
+      expect(resolver).to_not receive(:on_failure)
+      expect(resolver).to_not receive(:detach)
+
+      resolver.__send__(:on_readable)
+    end
+  end
+
+  def request_id_of(resolver)
+    resolver.__send__(:request_message)[0..1].unpack('n').first
+  end
+
+  # A response to the resolver's own query: header plus the echoed question,
+  # and an A record when an address is given.
+  def dns_response_for(resolver, id: request_id_of(resolver), address: nil)
+    question = resolver.instance_variable_get(:@question)
+    answer = if address
+      # Compressed name pointer, type A, class IN, TTL, RDLENGTH, RDATA
+      [0xc00c, 1, 1, 60, 4].pack('nnnNn') + address.split('.').map(&:to_i).pack('CCCC')
+    else
+      ""
+    end
+
+    [id, 0x81, 0x80, 1, answer.empty? ? 0 : 1, 0, 0].pack('nCCnnnn') + question + answer
+  end
 end

data/spec/iobuffer_spec.rb

@@ -31,6 +31,18 @@ describe Cool.io::Buffer do
       expect(buffer << "baz").to eq "baz"
       expect(buffer.read 3).to eq "arb"
     end
+
+    it "raises ArgumentError for a length below one" do
+      buffer << "foo"
+      expect { buffer.read 0 }.to raise_error ArgumentError
+      expect { buffer.read(-1) }.to raise_error ArgumentError
+    end
+
+    it "clamps a length which does not fit in a C int to the buffer size" do
+      buffer << "foobar"
+      expect(buffer.read 2**31).to eq "foobar"
+      expect(buffer.size).to eq 0
+    end
   end
   
   describe "provides methods for performing non-blocking I/O" do
@@ -142,6 +154,25 @@ describe Cool.io::Buffer do
       expect(data).to eq "foo\nbarbaz"
       expect(buffer.to_str).to eq ""
     end
+
+    it "raises TypeError instead of crashing when data is not a String" do
+      buffer << "hello world"
+      expect { buffer.read_frame 12345, " ".ord }.to raise_error(TypeError)
+      expect { buffer.read_frame nil, " ".ord }.to raise_error(TypeError)
+      expect { buffer.read_frame [], " ".ord }.to raise_error(TypeError)
+    end
+
+    it "raises FrozenError when data is a frozen String" do
+      buffer << "hello world"
+      expect { buffer.read_frame "frozen".freeze, " ".ord }.to raise_error(FrozenError)
+    end
+
+    it "coerces objects responding to #to_str" do
+      buffer << "foo\nbar"
+      convertible = Object.new
+      def convertible.to_str; +""; end
+      expect(buffer.read_frame convertible, "\n".ord).to eq true
+    end
   end
 
 end

data/spec/stat_watcher_spec.rb

@@ -18,12 +18,31 @@ class MyStatWatcher < Cool.io::StatWatcher
   end
 end
 
-def run_with_file_change(path)
+def run_with_file_change(path, compact: false)
   reactor = Cool.io::Loop.new
 
   sw = MyStatWatcher.new(path)
   sw.attach(reactor)
 
+  # libev retains the path pointer passed to ev_stat_init() for the lifetime of
+  # the watcher.  If the watcher held RSTRING_PTR(@path) directly, a compaction
+  # that relocates the @path String would leave libev dereferencing a stale
+  # address on every stat.  Force a maximal relocation here so the watcher keeps
+  # operating against a path buffer it owns rather than Ruby-managed memory.
+  if compact
+    if GC.respond_to?(:verify_compaction_references)
+      # verify_compaction_references moves every movable object to a fresh slot.
+      # Its keyword arguments have varied across Ruby versions, so fall back.
+      begin
+        GC.verify_compaction_references(expand_heap: true, toplevel: true)
+      rescue ArgumentError
+        GC.verify_compaction_references(expand_heap: true)
+      end
+    elsif GC.respond_to?(:compact)
+      GC.compact
+    end
+  end
+
   tw = Cool.io::TimerWatcher.new(INTERVAL, true)
   tw.on_timer do
     reactor.stop if sw.accessed
@@ -69,6 +88,17 @@ describe Cool.io::StatWatcher do
     expect(watcher.previous.ino).to eq(watcher.current.ino)
   end
 
+  it "keeps firing on_change after GC compaction relocates objects" do
+    skip "GC compaction not available" unless GC.respond_to?(:compact)
+
+    watcher = run_with_file_change(TEMP_FILE_PATH, compact: true)
+    expect(watcher.accessed).to eq(true)
+  end
+
+  it "raises ArgumentError when the path contains a null byte" do
+    expect { MyStatWatcher.new("foo\0bar") }.to raise_error(ArgumentError)
+  end
+
   it "should raise when the handler does not take 2 parameters" do
     class MyStatWatcher < Cool.io::StatWatcher
       remove_method :on_change

data/spec/tcp_server_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../spec_helper', __FILE__)
+require 'timeout'
 
 TIMEOUT = 0.010
 HOST = '127.0.0.1'
@@ -39,13 +40,31 @@ def on_message(data)
   @data = data
 end
 
+# The reactor can be an order of magnitude slower under valgrind, so sleeping a
+# fixed interval and assuming the event was processed by then makes these specs
+# fail intermittently. Wait for the result instead. The timeout is generous
+# enough that a slow machine still passes, and a genuine hang raises
+# Timeout::Error here instead of blocking the suite forever.
+WAIT_TIMEOUT = 5.0
+
+def wait_until(timeout = WAIT_TIMEOUT)
+  Timeout.timeout(timeout) do
+    sleep 0.001 until yield
+  end
+end
+
 def test_run(data = nil)
+  @data = ""
   reactor = Coolio::Loop.new
   server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
   reactor.attach(server)
   thread = Thread.new { reactor.run }
-  send_data(data) if data
-  sleep TIMEOUT
+  if data
+    send_data(data)
+    wait_until { @data == data }
+  else
+    sleep TIMEOUT
+  end
   reactor.stop
   server.detach
   send_data('') # to leave from blocking loop
@@ -86,6 +105,7 @@ ensure
 end
 
 def test_run_timeout(data = nil, timeout = TIMEOUT)
+  @data = ""
   reactor = Coolio::Loop.new
   server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
   reactor.attach(server)
@@ -95,8 +115,12 @@ def test_run_timeout(data = nil, timeout = TIMEOUT)
       reactor.run_once(timeout)
     end
   end
-  send_data(data) if data
-  sleep timeout
+  if data
+    send_data(data)
+    wait_until { @data == data }
+  else
+    sleep timeout
+  end
   server.detach
   running = false # another send is not required
   thread.join

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.9.4
+  version: 1.9.5
 platform: ruby
 authors:
 - Tony Arcieri
@@ -77,6 +77,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".github/workflows/test.yaml"
+- ".github/workflows/valgrind.yaml"
 - ".gitignore"
 - ".rspec"
 - CHANGES.md
@@ -169,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A cool framework for doing high performance I/O in Ruby
 test_files: