cool.io 1.9.5 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3da0843b8a62fd01aab297ce31f885a5856b4326bef2fb3c90d363f9576fe9a3
-  data.tar.gz: d073dd104500ccc2c1b62411c8f02c083df004353f9d2798ccf8ae41166effbd
+  metadata.gz: 84ec70f3ced722b0919a7e3348a6670e9d474343f8b831d9e942222a1edd0314
+  data.tar.gz: b60d4526c1c799119c43db2ae0e0f3debb85cba85086a6c65868477398a88a66
 SHA512:
-  metadata.gz: b3f2fab2151abdbd3e0762aa04675cab8b4d196990227bf5d068f12360a62c87e669480f50e70b47b289a9c0f29deeddb28836590422faafe5d0a5ecaf6173fb
-  data.tar.gz: 233ea14784f4390b6b1f1b8fb131d5b1d20d14d0b78f9f1fd3b39f89bd25d34be505267d23d1b5647be2febcd5216e33a459c0e135ee49737334a06a0626bb47
+  metadata.gz: 924f47393f2ae881e1afb914fa16bb67089840e8ef1c3599502919c5fa53263c06e0f6303d263ae376d8bff33da00ad9577b6549e3fc5128ead104a4f383e9d2
+  data.tar.gz: 8929ec98ce4161507309610d762c5f22f7fe4b756c361902fb0e37afa69ee2d8adc788383866ec7c9d270b80f27a99e902c2ef5128804e3b9e86c2b46c6e0535

data/.github/workflows/test.yaml

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

data/.github/workflows/valgrind.yaml

@@ -17,9 +17,6 @@ jobs:
           - ubuntu
         
         ruby:
-          - "3.2"
-          - "3.3"
-          - "3.4"
           - "4.0"
         
         experimental: [false]

data/Rakefile

@@ -51,6 +51,7 @@ end
 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

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
@@ -303,14 +304,17 @@ 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)
@@ -322,20 +326,24 @@ Coolio_Buffer_read(int argc, VALUE * argv, VALUE self)
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
     if (rb_scan_args(argc, argv, "01", &length_obj) == 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)
+        /* 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");
-        length = (size_t) requested;
-        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("");
 
+    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);
 
@@ -384,6 +392,9 @@ Coolio_Buffer_to_str(VALUE self)
 
     TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf);
 
+    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);
 
@@ -473,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;

data/ext/cool.io/ev_wrap.h

@@ -1,9 +1,17 @@
 #define EV_STANDALONE              /* keeps ev from requiring config.h */
 
 #ifdef _WIN32
+#include "ruby.h"
 #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. */
+/* Close the evpipe sockets with closesocket() through Ruby. The CRT close()
+ * only calls CloseHandle(), which leaves Winsock state behind. A socket later
+ * imported from a WSAPROTOCOL_INFO with the same handle value inherits it, and
+ * listen() fails with WSAEISCONN. */
+#define EV_WIN32_HANDLE_TO_FD(handle) rb_w32_wrap_io_handle((HANDLE)(handle), 0)
+#define EV_WIN32_CLOSE_FD(fd) rb_w32_close(fd)
 #endif
 
 #include "../libev/ev.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;
 }

data/ext/cool.io/stat_watcher.c

@@ -5,6 +5,9 @@
  */
 
 #include "ruby.h"
+#ifdef _WIN32
+#include "ruby/encoding.h"
+#endif
 #include "ev_wrap.h"
 
 #include "cool.io.h"
@@ -74,8 +77,10 @@ void Init_coolio_stat_watcher()
  * specified how often in seconds the path should be polled for changes.
  * Setting interval to zero uses an "automatic" value (typically around 5
  * seconds) which optimizes performance.  Otherwise, values less than
- * 0.1 are not particularly meaningful.  Where available (at present, on Linux)
- * high performance file monitoring interfaces will be used instead of polling.
+ * 0.1 are not particularly meaningful.  Where available (on Linux and Windows),
+ * high performance file monitoring interfaces are used.  On Windows, polling
+ * remains necessary because notification timing is not guaranteed.  An attached
+ * Windows watcher may also prevent renaming an ancestor directory until detached.
  */
 static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
 {
@@ -89,9 +94,14 @@ 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);
 
+#ifdef _WIN32
+  /* libev's wide Windows APIs and stat wrapper use UTF-8 paths. */
+  path = rb_str_export_to_enc(path, rb_utf8_encoding());
+#endif
+  path_str = StringValueCStr(path);
+
   watcher_data = Coolio_Watcher_ptr(self);
 
   /* libev keeps the path pointer passed to ev_stat_init() for the lifetime of
@@ -136,7 +146,7 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop)
   watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop != Qnil)
-    Coolio_StatWatcher_detach(self);
+    rb_funcall(self, rb_intern("detach"), 0);
 
   watcher_data->loop = loop;
 
@@ -248,20 +258,22 @@ static VALUE Coolio_StatInfo_build(ev_statdata *statdata_struct)
   VALUE blksize   = Qnil;
   VALUE blocks    = Qnil;
 
-  mtime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_mtime));
-  ctime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_ctime));
-  atime   = rb_funcall(cTime, at_method, 1, INT2NUM(statdata_struct->st_atime));
-  dev     = INT2NUM(statdata_struct->st_dev);
-  ino     = INT2NUM(statdata_struct->st_ino);
-  mode    = INT2NUM(statdata_struct->st_mode);
-  nlink   = INT2NUM(statdata_struct->st_nlink);
-  uid     = INT2NUM(statdata_struct->st_uid);
-  gid     = INT2NUM(statdata_struct->st_gid);
-  rdev    = INT2NUM(statdata_struct->st_rdev);
-  size    = INT2NUM(statdata_struct->st_size);
-#ifdef HAVE_ST_BLKSIZE
-  blksize = INT2NUM(statdata_struct->st_blksize);
-  blocks  = INT2NUM(statdata_struct->st_blocks);
+  mtime   = rb_funcall(cTime, at_method, 1, LL2NUM((long long)statdata_struct->st_mtime));
+  ctime   = rb_funcall(cTime, at_method, 1, LL2NUM((long long)statdata_struct->st_ctime));
+  atime   = rb_funcall(cTime, at_method, 1, LL2NUM((long long)statdata_struct->st_atime));
+  dev     = LL2NUM((long long)statdata_struct->st_dev);
+  ino     = ULL2NUM((unsigned long long)statdata_struct->st_ino);
+  mode    = LL2NUM((long long)statdata_struct->st_mode);
+  nlink   = LL2NUM((long long)statdata_struct->st_nlink);
+  uid     = LL2NUM((long long)statdata_struct->st_uid);
+  gid     = LL2NUM((long long)statdata_struct->st_gid);
+  rdev    = LL2NUM((long long)statdata_struct->st_rdev);
+  size    = LL2NUM((long long)statdata_struct->st_size);
+#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
+  blksize = LL2NUM((long long)statdata_struct->st_blksize);
+#endif
+#ifdef HAVE_STRUCT_STAT_ST_BLOCKS
+  blocks  = LL2NUM((long long)statdata_struct->st_blocks);
 #endif
 
   return rb_struct_new(cCoolio_StatInfo,

data/ext/cool.io/timer_watcher.c

@@ -102,7 +102,7 @@ static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE loop)
   watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop != Qnil)
-    Coolio_TimerWatcher_detach(self);
+    rb_funcall(self, rb_intern("detach"), 0);
 
   watcher_data->loop = loop;
   

data/ext/cool.io/watcher.h

@@ -7,23 +7,6 @@
 #ifndef WATCHER_H
 #define WATCHER_H
 
-#define Watcher_Attach(watcher_type, detach_func, watcher, 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(watcher); \
-  loop_data = Coolio_Loop_ptr(loop); \
-  \
-  if(watcher_data->loop != Qnil) \
-    detach_func(watcher); \
-  \
-  watcher_data->loop = loop; \
-  ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
-  rb_call_super(1, &loop)
-
 #define Watcher_Detach(watcher_type, watcher) \
   struct Coolio_Watcher *watcher_data; \
   \

data/ext/libev/ev.c

@@ -219,6 +219,11 @@
 # endif
 # include <winsock2.h>
 # include <windows.h>
+# include <process.h>
+# ifndef EV_WIN32_STAT_CODEPAGE
+/* Interpret narrow paths using the active Windows code page unless overridden. */
+#  define EV_WIN32_STAT_CODEPAGE CP_ACP
+# endif
 # ifndef EV_SELECT_IS_WINSOCKET
 #  define EV_SELECT_IS_WINSOCKET 1
 # endif
@@ -1855,6 +1860,10 @@ typedef struct
 
 #endif
 
+#if defined(_WIN32) && EV_STAT_ENABLE && EV_ASYNC_ENABLE
+static void win32_fs_destroy (EV_P);
+#endif
+
 #if EV_FEATURE_API
 # define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
 # define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
@@ -2406,8 +2415,8 @@ static ANSIG signals [EV_NSIG - 1];
 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
 
 noinline ecb_cold
-static void
-evpipe_init (EV_P)
+static int
+evpipe_init_try (EV_P)
 {
   if (!ev_is_active (&pipe_w))
     {
@@ -2422,8 +2431,8 @@ evpipe_init (EV_P)
       if (fds [1] < 0)
 # endif
         {
-          while (pipe (fds))
-            ev_syserr ("(libev) error creating signal/async pipe");
+          if (pipe (fds))
+            return 0;
 
           fd_intern (fds [0]);
         }
@@ -2449,6 +2458,16 @@ evpipe_init (EV_P)
       ev_io_start (EV_A_ &pipe_w);
       ev_unref (EV_A); /* watcher should not keep loop alive */
     }
+
+  return 1;
+}
+
+noinline ecb_cold
+static void
+evpipe_init (EV_P)
+{
+  while (!evpipe_init_try (EV_A))
+    ev_syserr ("(libev) error creating signal/async pipe");
 }
 
 inline_speed void
@@ -2914,6 +2933,10 @@ loop_init (EV_P_ unsigned int flags) EV_THROW
       pipe_write_wanted  = 0;
       evpipe [0]         = -1;
       evpipe [1]         = -1;
+#if defined(_WIN32) && EV_STAT_ENABLE && EV_ASYNC_ENABLE
+      win32_fs          = 0;
+      win32_fs_disabled = (flags & EVFLAG_NOINOTIFY) != 0;
+#endif
 #if EV_USE_INOTIFY
       fs_fd              = flags & EVFLAG_NOINOTIFY ? -1 : -2;
 #endif
@@ -2982,6 +3005,10 @@ ev_loop_destroy (EV_P)
     }
 #endif
 
+#if defined(_WIN32) && EV_STAT_ENABLE && EV_ASYNC_ENABLE
+  win32_fs_destroy (EV_A);
+#endif
+
   if (ev_is_active (&pipe_w))
     {
       /*ev_ref (EV_A);*/
@@ -4330,17 +4357,16 @@ ev_child_stop (EV_P_ ev_child *w) EV_THROW
 
 #if EV_STAT_ENABLE
 
-# ifdef _WIN32
-#  undef lstat
-#  define lstat(a,b) _stati64 (a,b)
-# endif
-
 #define DEF_STAT_INTERVAL  5.0074891
 #define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
 #define MIN_STAT_INTERVAL  0.1074891
 
 noinline static void stat_timer_cb (EV_P_ ev_timer *w_, int revents);
 
+#if defined(_WIN32) && EV_ASYNC_ENABLE
+# include "ev_win32_stat.c"
+#endif
+
 #if EV_USE_INOTIFY
 
 /* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
@@ -4581,7 +4607,23 @@ infy_fork (EV_P)
 #endif
 
 #ifdef _WIN32
-# define EV_LSTAT(p,b) _stati64 (p, b)
+static int
+win32_stat (const char *path, ev_statdata *attr)
+{
+  int result;
+  int length = MultiByteToWideChar (EV_WIN32_STAT_CODEPAGE, 0, path, -1, 0, 0);
+  wchar_t *wide;
+  if (!length)
+    { errno = EINVAL; return -1; }
+  wide = (wchar_t *)malloc (length * sizeof (wchar_t));
+  if (!wide)
+    { errno = ENOMEM; return -1; }
+  MultiByteToWideChar (EV_WIN32_STAT_CODEPAGE, 0, path, -1, wide, length);
+  result = _wstati64 (wide, attr);
+  free (wide);
+  return result;
+}
+# define EV_LSTAT(p,b) win32_stat (p, b)
 #else
 # define EV_LSTAT(p,b) lstat (p, b)
 #endif
@@ -4589,7 +4631,7 @@ infy_fork (EV_P)
 void
 ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
 {
-  if (lstat (w->path, &w->attr) < 0)
+  if (EV_LSTAT (w->path, &w->attr) < 0)
     w->attr.st_nlink = 0;
   else if (!w->attr.st_nlink)
     w->attr.st_nlink = 1;
@@ -4601,6 +4643,11 @@ stat_timer_cb (EV_P_ ev_timer *w_, int revents)
 {
   ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
 
+#if defined(_WIN32) && EV_ASYNC_ENABLE
+  if (revents & EV_TIMER)
+    win32_fs_add (EV_A_ w, 1); /* retry missing parents or failed directory handles */
+#endif
+
   ev_statdata prev = w->attr;
   ev_stat_stat (EV_A_ w);
 
@@ -4623,6 +4670,12 @@ stat_timer_cb (EV_P_ ev_timer *w_, int revents)
       /* to ensure that prev is always different to attr */
       w->prev = prev;
 
+#if defined(_WIN32) && EV_ASYNC_ENABLE
+      if (!prev.st_nlink || !w->attr.st_nlink
+          || (prev.st_mode & S_IFMT) != (w->attr.st_mode & S_IFMT))
+        win32_fs_add (EV_A_ w, 0); /* register directory children after creation */
+#endif
+
       #if EV_USE_INOTIFY
         if (fs_fd >= 0)
           {
@@ -4664,6 +4717,11 @@ ev_stat_start (EV_P_ ev_stat *w) EV_THROW
 
   ev_start (EV_A_ (W)w, 1);
 
+#if defined(_WIN32) && EV_ASYNC_ENABLE
+  win32_fs_add (EV_A_ w, 0);
+  stat_timer_cb (EV_A_ &w->timer, 0); /* close the stat/registration race */
+#endif
+
   EV_FREQUENT_CHECK;
 }
 
@@ -4676,6 +4734,10 @@ ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
 
   EV_FREQUENT_CHECK;
 
+#if defined(_WIN32) && EV_ASYNC_ENABLE
+  win32_fs_del (EV_A_ w);
+#endif
+
 #if EV_USE_INOTIFY
   infy_del (EV_A_ w);
 #endif

data/ext/libev/ev_vars.h

@@ -181,6 +181,10 @@ VAR (fs_hash, ANFS fs_hash [EV_INOTIFY_HASHSIZE])
 #endif
 
 VARx(EV_ATOMIC_T, sig_pending)
+#if defined(_WIN32) && EV_STAT_ENABLE && EV_ASYNC_ENABLE
+VARx(struct ev_win32_fs *, win32_fs)
+VARx(int, win32_fs_disabled)
+#endif
 #if EV_USE_SIGNALFD || EV_GENWRAP
 VARx(int, sigfd)
 VARx(ev_io, sigfd_w)