cool.io 1.9.4 → 1.10.0

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,12 +77,16 @@ 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)
 {
-	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);
@@ -89,13 +96,29 @@ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self)
   path = rb_String(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
+   * 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;
@@ -123,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;
 
@@ -235,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.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

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

@@ -210,9 +210,20 @@
 #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>
+# 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
@@ -1849,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)
@@ -2400,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))
     {
@@ -2416,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]);
         }
@@ -2443,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
@@ -2908,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
@@ -2976,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);*/
@@ -4324,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 */
@@ -4575,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
@@ -4583,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;
@@ -4595,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);
 
@@ -4617,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)
           {
@@ -4658,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;
 }
 
@@ -4670,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_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/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)