cool.io 1.9.0 → 1.9.5

data/ext/cool.io/loop.c

@@ -14,8 +14,7 @@ static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Loop = Qnil;
 
 static VALUE Coolio_Loop_allocate(VALUE klass);
-static void Coolio_Loop_mark(struct Coolio_Loop *loop);
-static void Coolio_Loop_free(struct Coolio_Loop *loop);
+static void Coolio_Loop_free(void *data);
 
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags);
 static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self);
@@ -47,9 +46,26 @@ void Init_coolio_loop()
   rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0);
 }
 
+static const rb_data_type_t Coolio_Loop_type = {
+  "Coolio::Loop",
+  {
+    NULL,
+    Coolio_Loop_free,
+  },
+};
+
+struct Coolio_Loop *Coolio_Loop_ptr(VALUE self)
+{
+  struct Coolio_Loop *loop;
+
+  TypedData_Get_Struct(self, struct Coolio_Loop, &Coolio_Loop_type, loop);
+  return loop;
+}
+
 static VALUE Coolio_Loop_allocate(VALUE klass)
 {
-  struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop));
+  struct Coolio_Loop *loop;
+  VALUE obj = TypedData_Make_Struct(klass, struct Coolio_Loop, &Coolio_Loop_type, loop);
 
   loop->ev_loop = 0;
   ev_init(&loop->timer, Coolio_Loop_timeout_callback);
@@ -58,15 +74,13 @@ static VALUE Coolio_Loop_allocate(VALUE klass)
   loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
   loop->eventbuf = (struct Coolio_Event *)xmalloc(sizeof(struct Coolio_Event) * DEFAULT_EVENTBUF_SIZE);
 
-  return Data_Wrap_Struct(klass, Coolio_Loop_mark, Coolio_Loop_free, loop);
+  return obj;
 }
 
-static void Coolio_Loop_mark(struct Coolio_Loop *loop)
+static void Coolio_Loop_free(void *data)
 {
-}
+  struct Coolio_Loop *loop = data;
 
-static void Coolio_Loop_free(struct Coolio_Loop *loop)
-{
   if(!loop->ev_loop)
     return;
 
@@ -80,7 +94,7 @@ static void Coolio_Loop_free(struct Coolio_Loop *loop)
 static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags)
 {
   struct Coolio_Loop *loop_data;
-  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(self);
 
   if(loop_data->ev_loop)
     rb_raise(rb_eRuntimeError, "loop already initialized");
@@ -96,23 +110,29 @@ 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 */
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data);
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+  /* The Global VM Lock is held here, see the explanation below */
+  watcher_data = Coolio_Watcher_ptr(watcher);
+
+  if (watcher_data->enabled == 0) {
+    /* Ignore event because watcher was already detached. */
+    return;
+  }
+
+  loop_data = Coolio_Loop_ptr(watcher_data->loop);
 
   /*  Well, what better place to explain how this all works than
    *  where the most wonky and convoluted stuff is going on!
    *
    *  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,
@@ -130,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) {
@@ -184,7 +204,7 @@ static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self)
     rb_raise(rb_eArgError, "time interval must be positive");
   }
 
-  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(self);
 
   assert(loop_data->ev_loop && !loop_data->events_received);
 
@@ -222,7 +242,7 @@ static VALUE Coolio_Loop_run_nonblock(VALUE self)
   struct Coolio_Loop *loop_data;
   VALUE nevents;
   
-  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(self);
 
   assert(loop_data->ev_loop && !loop_data->events_received);
 
@@ -247,7 +267,7 @@ static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data)
     if(loop_data->eventbuf[i].watcher == Qnil)
       continue;
 
-    Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Coolio_Watcher, watcher_data);
+    watcher_data = Coolio_Watcher_ptr(loop_data->eventbuf[i].watcher);
     watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents);
   }
 }

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);
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  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;
@@ -119,8 +132,8 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop)
   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)));
 
-  Data_Get_Struct(loop, struct Coolio_Loop, loop_data);
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  loop_data = Coolio_Loop_ptr(loop);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop != Qnil)
     Coolio_StatWatcher_detach(self);
@@ -206,7 +219,7 @@ static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev
 static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents)
 {
   struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   VALUE previous_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.prev);
   VALUE current_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.attr);

data/ext/cool.io/timer_watcher.c

@@ -68,7 +68,7 @@ static VALUE Coolio_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self)
   rb_iv_set(self, "@interval", interval);
   rb_iv_set(self, "@repeating", repeating);
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   watcher_data->dispatch_callback = Coolio_TimerWatcher_dispatch_callback;
   ev_timer_init(
@@ -98,8 +98,8 @@ static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE loop)
   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)));
 
-  Data_Get_Struct(loop, struct Coolio_Loop, loop_data);
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  loop_data = Coolio_Loop_ptr(loop);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop != Qnil)
     Coolio_TimerWatcher_detach(self);
@@ -180,12 +180,12 @@ static VALUE Coolio_TimerWatcher_reset(VALUE self)
   struct Coolio_Watcher *watcher_data;
   struct Coolio_Loop *loop_data;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop == Qnil)
     rb_raise(rb_eRuntimeError, "not attached to a loop");
 
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(watcher_data->loop);
 
   ev_timer_again(loop_data->ev_loop, &watcher_data->event_types.ev_timer);
 

data/ext/cool.io/watcher.c

@@ -13,8 +13,8 @@ static VALUE mCoolio = Qnil;
 static VALUE cCoolio_Watcher = Qnil;
 
 static VALUE Coolio_Watcher_allocate(VALUE klass);
-static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher);
-static void Coolio_Watcher_free(struct Coolio_Watcher *watcher);
+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);
@@ -53,24 +53,49 @@ void Init_coolio_watcher()
   rb_define_method(cCoolio_Watcher, "enabled?", Coolio_Watcher_enabled, 0);
 }
 
+static const rb_data_type_t Coolio_Watcher_type = {
+  "Coolio::Watcher",
+  {
+    Coolio_Watcher_mark,
+    Coolio_Watcher_free,
+  },
+};
+
+struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher)
+{
+  struct Coolio_Watcher *watcher_data;
+
+  TypedData_Get_Struct(watcher, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data);
+  return watcher_data;
+}
+
 static VALUE Coolio_Watcher_allocate(VALUE klass)
 {
-  struct Coolio_Watcher *watcher_data = (struct Coolio_Watcher *)xmalloc(sizeof(struct Coolio_Watcher));
+  struct Coolio_Watcher *watcher_data;
+  VALUE watcher = TypedData_Make_Struct(klass, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data);
 
   watcher_data->loop = Qnil;
   watcher_data->enabled = 0;
+  watcher_data->stat_path = NULL;
 
-  return Data_Wrap_Struct(klass, Coolio_Watcher_mark, Coolio_Watcher_free, watcher_data);
+  return watcher;
 }
 
-static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher_data)
+static void Coolio_Watcher_mark(void *data)
 {
+  struct Coolio_Watcher *watcher_data = data;
+
   if(watcher_data->loop != Qnil)
     rb_gc_mark(watcher_data->loop);
 }
 
-static void Coolio_Watcher_free(struct Coolio_Watcher *watcher_data)
+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);
 }
 
@@ -91,7 +116,7 @@ static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop)
   VALUE loop_watchers, active_watchers;
   struct Coolio_Watcher *watcher_data;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   watcher_data->enabled = 1;
     
   loop_watchers = rb_iv_get(loop, "@watchers");
@@ -132,7 +157,7 @@ static VALUE Coolio_Watcher_detach(VALUE self)
   VALUE loop_watchers;
   int i;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->loop == Qnil)
     rb_raise(rb_eRuntimeError, "not attached to a loop");
@@ -155,7 +180,7 @@ static VALUE Coolio_Watcher_detach(VALUE self)
 
   watcher_data->enabled = 0;
 
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+  loop_data = Coolio_Loop_ptr(watcher_data->loop);
 
   /* Iterate through the events in the loop's event buffer.  If there
    * are any pending events from this watcher, mark them NULL.  The
@@ -182,7 +207,7 @@ static VALUE Coolio_Watcher_detach(VALUE self)
 static VALUE Coolio_Watcher_enable(VALUE self)
 {
   struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(watcher_data->enabled)
     rb_raise(rb_eRuntimeError, "already enabled");
@@ -208,7 +233,7 @@ static VALUE Coolio_Watcher_enable(VALUE self)
 static VALUE Coolio_Watcher_disable(VALUE self)
 {
   struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
 
   if(!watcher_data->enabled)
     rb_raise(rb_eRuntimeError, "already disabled");
@@ -234,7 +259,7 @@ static VALUE Coolio_Watcher_evloop(VALUE self)
 {
   struct Coolio_Watcher *watcher_data;
 
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   return watcher_data->loop;
 }
 
@@ -258,7 +283,7 @@ static VALUE Coolio_Watcher_attached(VALUE self)
 static VALUE Coolio_Watcher_enabled(VALUE self)
 {
 	struct Coolio_Watcher *watcher_data;
-  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  watcher_data = Coolio_Watcher_ptr(self);
   
 	return watcher_data->enabled ? Qtrue : Qfalse;
 }

data/ext/cool.io/watcher.h

@@ -14,8 +14,8 @@
   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))); \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
-  Data_Get_Struct(loop, struct Coolio_Loop, loop_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
+  loop_data = Coolio_Loop_ptr(loop); \
   \
   if(watcher_data->loop != Qnil) \
     detach_func(watcher); \
@@ -26,30 +26,29 @@
 
 #define Watcher_Detach(watcher_type, watcher) \
   struct Coolio_Watcher *watcher_data; \
-  struct Coolio_Loop *loop_data; \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
-  \
-  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  if (watcher_data->enabled) { \
+    rb_funcall(watcher, rb_intern("disable"), 0); \
+  } \
   rb_call_super(0, 0)
 
 #define Watcher_Enable(watcher_type, watcher) \
   struct Coolio_Watcher *watcher_data; \
   struct Coolio_Loop *loop_data; \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
   rb_call_super(0, 0); \
   \
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
+  loop_data = Coolio_Loop_ptr(watcher_data->loop); \
   \
   ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
 
@@ -57,15 +56,15 @@
   struct Coolio_Watcher *watcher_data; \
   struct Coolio_Loop *loop_data; \
   \
-  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \
+  watcher_data = Coolio_Watcher_ptr(watcher); \
   \
   if(watcher_data->loop == Qnil) \
     rb_raise(rb_eRuntimeError, "not attached to a loop"); \
   \
-  rb_call_super(0, 0); \
-  \
-  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \
-  \
-  ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)
+  if (watcher_data->enabled) { \
+    loop_data = Coolio_Loop_ptr(watcher_data->loop); \
+    ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \
+  } \
+  rb_call_super(0, 0);
 
 #endif

data/ext/libev/ev.c

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

data/ext/libev/ev_select.c

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

data/gems.rb

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

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
+      @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.0"
-  
+  VERSION = "1.9.5"
+
   def self.version
     VERSION
   end