cool.io 1.9.4 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f15a89de41069e6ccb37eb28befd01d601851ae1bb9ee2a5081e1c26e0bcc8da
-  data.tar.gz: de69fe197c029bbb4438e2e1c751580712ecc1f1b8326803d2089b738d3f74cc
+  metadata.gz: 9494578f6a02a987a84805bca37919a7c0e63c4c585a7bdf8c68e18e38d21e8d
+  data.tar.gz: 0cae209afee54a8f6f59014afb71ee2357dabdc350cfc60dfe2a6212062dbf1e
 SHA512:
-  metadata.gz: c88454501a2b042515b0571a729bac9a829ed7af72be377caf5ab6db08f90bb48adb1e19a69dee1b38eb1c77df9c084c88faa19d0077503c85a965e6c0c556ac
-  data.tar.gz: 8fd2af4f085bbb253df79cb8c9c685df97c5dc233f4be4891cef796120e9b265676e6fa4fe7c39b0b3b77447c000e41cbb1bc66b8939869e8747ac270619c436
+  metadata.gz: ccb23719b38180b44cd6485901a35a15710daf77f4079a7fbdbc1d77fcfe86b75787d82c8cd8f455f5199a7f390125d6d62320eeff2785b2193c6fe5612c7653
+  data.tar.gz: 2ab5356bc8ab69fb93c6f3c6532ada9c67b63c774e7a952f20526b1bf3660fde681a3b480130deaf436212b4b0d77b51859fefcb9d4f0a6dc983b0a46de70f2c

data/.github/workflows/test.yaml

@@ -17,6 +17,7 @@ jobs:
         os:
           - ubuntu
           - macos
+          - windows
         
         ruby:
           - "3.2"

data/.github/workflows/valgrind.yaml

@@ -0,0 +1,41 @@
+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:
+          - "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,12 @@ 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'
+  RubyMemcheck.config(binary_name: 'cool.io_ext')
+  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

@@ -15,6 +15,7 @@
 #include <unistd.h>
 #endif
 #include <errno.h>
+#include <limits.h>
 
 /* 1 GiB maximum buffer size */
 #define MAX_BUFFER_SIZE 0x40000000
@@ -28,17 +29,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 +74,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 +151,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 +174,7 @@ convert_node_size(VALUE size)
     )
         rb_raise(rb_eArgError, "invalid buffer size");
 
-    return (unsigned) NUM2INT(size);
+    return NUM2SIZET(size);
 }
 
 /**
@@ -241,7 +247,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);
 }
 
 /**
@@ -298,37 +304,47 @@ Coolio_Buffer_prepend(VALUE self, VALUE data)
 
 /**
  *  call-seq:
- *    Coolio::Buffer#read(length = nil) -> String
+ *    Coolio::Buffer#read -> String
+ *    Coolio::Buffer#read(length) -> String
  *
- * Read the specified abount of data from the buffer.  If no value
- * is given the entire contents of the buffer are returned.  Any data
- * read from the buffer is cleared.
- * The given length must be greater than 0 or an exception would raise.
- * If the buffer size is zero then an empty string is returned (regardless
- * the given length).
+ * Read data from the buffer.  Any data read from the buffer is cleared.
+ * With no argument, the entire contents of the buffer are returned.  With
+ * length, at most length bytes are returned.
+ * At most LONG_MAX bytes are returned per call; on platforms where a String
+ * cannot hold the whole buffer the remainder is kept for later reads.
+ * length is converted with to_int, so nil raises TypeError.  A length less
+ * than 1 raises ArgumentError, even when the buffer is empty.
+ * Otherwise, if the buffer is empty, an empty string is returned.
  */
 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)
+        /* Clamp before converting to C: long is only 32 bits on 64-bit Windows,
+         * and a request larger than the buffer never needs to fit in C at all.
+         * Keep the integer coercion and ArgumentError for non-positive lengths. */
+        VALUE requested = rb_to_int(length_obj);
+        if(rb_funcall(requested, rb_intern("<"), 1, INT2NUM(1)) == Qtrue)
           rb_raise(rb_eArgError, "length must be greater than zero");
-        if(length > buf->size)
-          length = buf->size;
+        length = buf->size;
+        if(rb_funcall(requested, rb_intern("<"), 1, SIZET2NUM(length)) == Qtrue)
+          length = NUM2SIZET(requested);
     } else
         length = buf->size;
 
     if(buf->size == 0)
         return rb_str_new2("");
 
-    str = rb_str_new(0, length);
+    if(length > (size_t) LONG_MAX)
+        length = (size_t) LONG_MAX;
+
+    str = rb_str_new(0, (long) length);
     buffer_read(buf, RSTRING_PTR(str), length);
 
     return str;
@@ -352,6 +368,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 +392,10 @@ Coolio_Buffer_to_str(VALUE self)
 
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
-    str = rb_str_new(0, buf->size);
+    if(buf->size > (size_t) LONG_MAX)
+        rb_raise(rb_eRangeError, "buffer is too large to convert to a String");
+
+    str = rb_str_new(0, (long) buf->size);
     buffer_copy(buf, RSTRING_PTR(str), buf->size);
 
     return str;
@@ -391,7 +413,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 +430,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 +457,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
 }
 
@@ -462,10 +484,13 @@ static void
 buffer_clear(struct buffer * buf)
 {
     /* Move everything into the buffer pool */
-    if (!buf->pool_tail) {
-        buf->pool_head = buf->pool_tail = buf->head;
-    } else {
-        buf->pool_tail->next = buf->head;
+    if (buf->head) {
+        if (!buf->pool_tail) {
+            buf->pool_head = buf->head;
+        } else {
+            buf->pool_tail->next = buf->head;
+        }
+        buf->pool_tail = buf->tail;
     }
 
     buf->head = buf->tail = 0;
@@ -535,7 +560,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 +601,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 +638,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 +674,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 +689,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 +713,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 +734,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 +755,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 +773,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 +807,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/ev_wrap.h

@@ -4,6 +4,7 @@
 #define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
 #define EV_USE_MONOTONIC 0
 #define EV_USE_REALTIME 0
+#define EV_WIN32_STAT_CODEPAGE CP_UTF8 /* Ruby paths are UTF-8. */
 #endif
 
 #include "../libev/ev.h"

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/iowatcher.c

@@ -111,7 +111,24 @@ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
  */
 static VALUE Coolio_IOWatcher_attach(VALUE self, VALUE loop)
 {
-  Watcher_Attach(io, Coolio_IOWatcher_detach, self, loop);
+  struct Coolio_Watcher *watcher_data;
+  struct Coolio_Loop *loop_data;
+
+  if(!rb_obj_is_kind_of(loop, cCoolio_Loop))
+    rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop)));
+
+  watcher_data = Coolio_Watcher_ptr(self);
+  loop_data = Coolio_Loop_ptr(loop);
+
+  if(watcher_data->loop != Qnil)
+    rb_funcall(self, rb_intern("detach"), 0);
+
+  /* A new loop must resolve the Windows socket handle for this fd again. */
+  ev_io_set(&watcher_data->event_types.ev_io,
+    watcher_data->event_types.ev_io.fd, watcher_data->event_types.ev_io.events);
+  watcher_data->loop = loop;
+  ev_io_start(loop_data->ev_loop, &watcher_data->event_types.ev_io);
+  rb_call_super(1, &loop);
 
   return self;  
 }

data/ext/cool.io/loop.c

@@ -81,10 +81,9 @@ static void Coolio_Loop_free(void *data)
 {
   struct Coolio_Loop *loop = data;
 
-  if(!loop->ev_loop)
-    return;
-
-  ev_loop_destroy(loop->ev_loop);
+  if(loop->ev_loop) {
+    ev_loop_destroy(loop->ev_loop);
+  }
 
   xfree(loop->eventbuf);
   xfree(loop);
@@ -100,6 +99,9 @@ static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags)
     rb_raise(rb_eRuntimeError, "loop already initialized");
 
   loop_data->ev_loop = ev_loop_new(NUM2INT(flags));
+  if(!loop_data->ev_loop) {
+    rb_raise(rb_eRuntimeError, "unable to initialize the event loop (no usable backend)");
+  }
 
   return Qnil;
 }
@@ -110,8 +112,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 +127,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 +152,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) {