cool.io 1.9.0 → 1.9.5

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

@@ -0,0 +1,117 @@
+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, &on_readable)
+      super(io)
+      @io = io
+      @on_readable = on_readable
+    end
+
+    def on_readable
+      begin
+        @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
+  #
+  # 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
+        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
+
+        coolio_loop.run_once
+
+        # Only the first dispatched watcher runs; it detaches the other four,
+        # whose pending events are then skipped.
+        expect(watchers.count(&:attached?)).to eq(1)
+
+        watchers.each { |watcher| watcher.detach if watcher.attached? }
+        pipes.each { |r, w| r.close; w.close }
+      end
+    }.not_to raise_error
+  end
+
+  class HttpHandler < Coolio::IO
+    RESPONSE = "HTTP/1.1 200 OK\r\nContent-Length: 1024\r\nConnection: close\r\n\r\n" + ("X" * 1024)
+
+    def on_connect
+    end
+
+    def on_read(data)
+      write(RESPONSE)
+    end
+
+    def on_write_complete
+      close
+    end
+  end
+
+  # https://github.com/socketry/cool.io/issues/89
+  it "does not cause memory leaks" do
+    port = 18989
+    loop = Coolio::Loop.default
+
+    server = Coolio::TCPServer.new('127.0.0.1', port, HttpHandler)
+    server.attach(loop)
+
+    event_thread = Thread.new { loop.run }
+
+    request = "GET / HTTP/1.1\r\nHost: localhost\r\n\r\n"
+
+    10.times do |iteration|
+      begin
+        sock = TCPSocket.new('127.0.0.1', port)
+        sock.write(request)
+        sock.read
+        sock.close
+      rescue => e
+        sleep 0.01
+        retry
+      end
+    end
+
+    server.close
+    event_thread.join
+
+    expect(loop.watchers).to be_empty
+  end
+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,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cool.io
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.9.5
 platform: ruby
 authors:
 - Tony Arcieri
 - Masahiro Nakagawa
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-02 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -78,6 +77,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".github/workflows/test.yaml"
+- ".github/workflows/valgrind.yaml"
 - ".gitignore"
 - ".rspec"
 - CHANGES.md
@@ -141,6 +141,7 @@ files:
 - libev_ruby_gil.diff
 - libev_win_select.diff
 - spec/async_watcher_spec.rb
+- spec/detach_race_condition_spec.rb
 - spec/dns_spec.rb
 - spec/iobuffer_spec.rb
 - spec/spec_helper.rb
@@ -155,7 +156,6 @@ homepage: https://github.com/socketry/cool.io
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -170,12 +170,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A cool framework for doing high performance I/O in Ruby
 test_files:
 - spec/async_watcher_spec.rb
+- spec/detach_race_condition_spec.rb
 - spec/dns_spec.rb
 - spec/iobuffer_spec.rb
 - spec/spec_helper.rb