curb 1.3.5 → 1.3.7

data/tests/helper.rb

@@ -238,6 +238,85 @@ module BugTestServerSetupTeardown
   end
 end
 
+# Test::Unit creates a new test instance for every test method. Keep the
+# common WEBrick fixture process-scoped so those instances can share it while
+# still allowing an explicit stop_test_server call to exercise lifecycle code.
+module CurbTestServerRegistry
+  Entry = Struct.new(:key, :port, :server, :thread, :lock_file, :pid)
+
+  @mutex = Mutex.new
+  @entries = {}
+
+  class << self
+    def acquire(port, servlet)
+      key = [port, servlet]
+
+      @mutex.synchronize do
+        entry = @entries[key]
+        return entry if active?(entry)
+
+        @entries.delete(key)
+        entry = yield
+        @entries[key] = entry if entry
+        entry
+      end
+    end
+
+    def stop(entry, timeout)
+      return false unless remove(entry)
+
+      shutdown_entry(entry, timeout)
+      true
+    end
+
+    def register_shutdown_hook(entry)
+      # Test::Unit can run a directly executed test file from its own at_exit
+      # callback. Register after startup so this hook runs after that callback.
+      at_exit { stop(entry, 5) }
+    end
+
+    private
+
+    def active?(entry)
+      entry && entry.server && entry.thread && entry.thread.alive? && entry.server.status == :Running
+    rescue StandardError
+      false
+    end
+
+    def remove(entry)
+      @mutex.synchronize do
+        return false unless @entries[entry.key].equal?(entry)
+
+        @entries.delete(entry.key)
+        true
+      end
+    end
+
+    def shutdown_entry(entry, timeout)
+      return unless Process.pid == entry.pid
+
+      begin
+        entry.server.shutdown if entry.server
+      rescue StandardError
+        nil
+      end
+
+      thread = entry.thread
+      if thread
+        thread.join(timeout)
+        if thread.alive?
+          thread.kill
+          thread.join(timeout)
+        end
+      end
+
+      File.unlink(entry.lock_file) if entry.lock_file && File.exist?(entry.lock_file)
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end
+
 module TestServerMethods
   def server_responding?(port)
     socket = TCPSocket.new('127.0.0.1', port)
@@ -267,6 +346,22 @@ module TestServerMethods
     end
   end
 
+  # Waiting on WEBrick's state avoids opening a probe connection for every
+  # startup. On Windows those short-lived connections make server teardown
+  # disproportionately expensive.
+  def wait_for_server_started(server, port, thread: nil)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + server_startup_timeout
+
+    loop do
+      return true if server.status == :Running
+      return false if thread && !thread.alive?
+
+      raise "Failed to startup test server on port #{port}" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+      sleep 0.01
+    end
+  end
+
   def server_shutdown_timeout
     [server_startup_timeout, 0.25].max
   end
@@ -337,6 +432,13 @@ module TestServerMethods
   end
 
   def stop_test_server
+    shared_entry = instance_variable_defined?(:@__shared_test_server_entry) ? @__shared_test_server_entry : nil
+    if shared_entry
+      CurbTestServerRegistry.stop(shared_entry, server_shutdown_timeout)
+      release_shared_test_server
+      return
+    end
+
     server = instance_variable_defined?(:@server) ? @server : nil
     pid = instance_variable_defined?(:@__pid) ? @__pid : nil
     return unless server || pid
@@ -382,11 +484,28 @@ module TestServerMethods
   def teardown
     super
   ensure
-    stop_test_server
+    if instance_variable_defined?(:@__shared_test_server_entry) && @__shared_test_server_entry
+      release_shared_test_server
+    else
+      stop_test_server
+    end
   end
 
   def server_setup(port=9129,servlet=TestServlet)
     @__port = port
+
+    unless TEST_SINGLE_THREADED
+      entry = CurbTestServerRegistry.acquire(port, servlet) do
+        start_shared_test_server(port, servlet)
+      end
+
+      if entry
+        attach_shared_test_server(entry)
+      end
+
+      return
+    end
+
     @server = nil unless instance_variable_defined?(:@server)
     @__pid = nil unless instance_variable_defined?(:@__pid)
     @test_thread = nil unless instance_variable_defined?(:@test_thread)
@@ -474,6 +593,64 @@ module TestServerMethods
     end
   rescue Errno::EADDRINUSE
   end
+
+  def attach_shared_test_server(entry)
+    @server = entry.server
+    @test_thread = entry.thread
+    @__pid = nil
+    @__shared_test_server_entry = entry
+  end
+
+  def release_shared_test_server
+    @server = nil
+    @test_thread = nil
+    @__pid = nil
+    @__shared_test_server_entry = nil
+  end
+
+  def start_shared_test_server(port, servlet)
+    clear_stale_server_lock(port)
+
+    if File.exist?(locked_file)
+      begin
+        wait_for_server_ready(port)
+        return nil
+      rescue RuntimeError
+        clear_stale_server_lock(port)
+      end
+    end
+
+    write_server_lock
+    server = WEBrick::HTTPServer.new(:Port => port, :DocumentRoot => File.expand_path(File.dirname(__FILE__)), :Logger => WEBRICK_TEST_LOG, :AccessLog => [])
+
+    server.mount(servlet.path, servlet)
+    server.mount("/ext", WEBrick::HTTPServlet::FileHandler, File.join(File.dirname(__FILE__),'..','ext'))
+
+    thread = Thread.new(server) { |srv| srv.start }
+    unless wait_for_server_started(server, port, thread: thread)
+      server.shutdown
+      thread.join(server_shutdown_timeout)
+      raise "Failed to startup test server on port #{port}"
+    end
+
+    entry = CurbTestServerRegistry::Entry.new([port, servlet], port, server, thread, locked_file, Process.pid)
+    CurbTestServerRegistry.register_shutdown_hook(entry)
+    entry
+  rescue Errno::EADDRINUSE
+    File.unlink(locked_file) if File.exist?(locked_file)
+    return nil if server_responding?(port)
+
+    raise
+  rescue StandardError
+    begin
+      server.shutdown if defined?(server) && server
+      thread.join(server_shutdown_timeout) if defined?(thread) && thread
+    rescue StandardError
+      nil
+    end
+    File.unlink(locked_file) if File.exist?(locked_file)
+    raise
+  end
 end
 
 

data/tests/io_select_less_scheduler_probe.rb

@@ -0,0 +1,105 @@
+# Reproduces the FIBER_TODO.md [Critical] finding: a Fiber scheduler that
+# implements io_wait/kernel_sleep/block/unblock but NOT the optional io_select
+# hook. rb_fiber_scheduler_io_select returns Qundef (without waiting) for such
+# schedulers; if the multi-fd wait path of Curl::Multi#_socket_perform treats
+# that as a completed wait, the drive loop spins at 100% CPU with no interrupt
+# checkpoint and this script never exits — it cannot even service SIGTERM.
+#
+# Run by tc_fiber_scheduler.rb in a subprocess guarded by a SIGKILL fuse.
+# Usage: ruby io_select_less_scheduler_probe.rb <port>
+#   <port> must serve HTTP GET /test (see BugTestServerSetupTeardown).
+
+require 'fiber'
+require 'curb'
+
+port = Integer(ARGV[0])
+url = "http://127.0.0.1:#{port}/test"
+
+class NoIoSelectScheduler
+  def fiber(&block)
+    Fiber.new(blocking: false, &block)
+  end
+
+  def io_wait(io, events, timeout = nil)
+    readers = (events & IO::READABLE) != 0 ? [io] : nil
+    writers = (events & IO::WRITABLE) != 0 ? [io] : nil
+    deadline = monotonic_now + timeout if timeout
+
+    loop do
+      readable, writable = IO.select(readers, writers, nil, 0)
+      ready = 0
+      ready |= IO::READABLE if readable && !readable.empty?
+      ready |= IO::WRITABLE if writable && !writable.empty?
+      return ready unless ready.zero?
+      return false if deadline && monotonic_now >= deadline
+
+      Fiber.yield
+    end
+  end
+
+  def kernel_sleep(duration = nil)
+    deadline = monotonic_now + (duration || 0)
+    Fiber.yield while monotonic_now < deadline
+    duration
+  end
+
+  def block(_blocker, timeout = nil)
+    kernel_sleep(timeout)
+    false
+  end
+
+  def unblock(*); end
+
+  def close; end
+
+  def fiber_interrupt(*); end
+
+  private
+
+  def monotonic_now
+    Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end
+
+results = []
+ticks = 0
+done = false
+
+Fiber.set_scheduler(NoIoSelectScheduler.new)
+fiber = Fiber.schedule do
+  multi = Curl::Multi.new
+  begin
+    # Two easies so the drive loop tracks more than one socket and takes the
+    # multi-fd (io_select) wait branch.
+    2.times do
+      easy = Curl::Easy.new(url)
+      easy.on_complete { results << easy.response_code }
+      multi.add(easy)
+    end
+    multi.send(:_socket_perform)
+  ensure
+    multi.close
+    done = true
+  end
+end
+ticker = Fiber.schedule do
+  until done
+    sleep 0.005
+    ticks += 1 unless done
+  end
+end
+
+while fiber.alive? || ticker.alive?
+  fiber.resume if fiber.alive?
+  ticker.resume if ticker.alive?
+  sleep 0.001
+end
+Fiber.set_scheduler(nil)
+
+if results == [200, 200]
+  puts "OK ticks=#{ticks}"
+  exit 0
+else
+  puts "FAILED results=#{results.inspect}"
+  exit 1
+end

data/tests/tc_curl_download.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'tmpdir'
 
 class TestCurbCurlDownload < Test::Unit::TestCase
   include TestServerMethods 
@@ -18,6 +19,91 @@ class TestCurbCurlDownload < Test::Unit::TestCase
     File.unlink(dl_path) if File.exist?(dl_path)
   end
 
+  def test_download_default_path_does_not_overwrite_existing_file
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+
+    Dir.mktmpdir('curb-download-') do |dir|
+      Dir.chdir(dir) do
+        File.write('curb_easy.c', 'sentinel')
+
+        assert_raise(Curl::DownloadTargetExistsError) do
+          Curl::Easy.download(dl_url)
+        end
+
+        assert_equal 'sentinel', File.read('curb_easy.c')
+      end
+    end
+  end
+
+  def test_download_default_path_strips_query_from_url_basename
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c?cache=1"
+    source_path = File.expand_path(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c'))
+
+    Dir.mktmpdir('curb-download-') do |dir|
+      Dir.chdir(dir) do
+        Curl::Easy.download(dl_url)
+
+        assert File.exist?('curb_easy.c')
+        assert !File.exist?('curb_easy.c?cache=1')
+        assert_equal File.read(source_path), File.read('curb_easy.c')
+      end
+    end
+  end
+
+  def test_download_safe_directory_rejects_unsafe_names
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+
+    Dir.mktmpdir('curb-download-') do |dir|
+      ['../escape.c', '.env', 'nested/file', '/tmp/escape.c', "bad\0name"].each do |name|
+        assert_raise(ArgumentError, "expected #{name.inspect} to be rejected") do
+          Curl::Easy.download(dl_url, name, :download_dir => dir)
+        end
+      end
+    end
+  end
+
+  def test_download_safe_directory_rejects_dotfile_from_url
+    dl_url = "http://127.0.0.1:9129/ext/.env"
+
+    Dir.mktmpdir('curb-download-') do |dir|
+      assert_raise(ArgumentError) do
+        Curl::Easy.download(dl_url, :download_dir => dir)
+      end
+
+      assert !File.exist?(File.join(dir, '.env'))
+    end
+  end
+
+  def test_download_overwrite_true_replaces_existing_file
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+
+    Dir.mktmpdir('curb-download-') do |dir|
+      dl_path = File.join(dir, 'curb_easy.c')
+      File.write(dl_path, 'sentinel')
+
+      Curl::Easy.download(dl_url, dl_path, :overwrite => true)
+
+      assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+    end
+  end
+
+  def test_download_callback_abort_does_not_replace_existing_file
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+
+    Dir.mktmpdir('curb-download-') do |dir|
+      dl_path = File.join(dir, 'curb_easy.c')
+      File.write(dl_path, 'sentinel')
+
+      assert_raise(Curl::Err::WriteError, Curl::Err::RecvError) do
+        Curl::Easy.download(dl_url, dl_path, :overwrite => true) do |curl|
+          curl.on_body { |_data| 0 }
+        end
+      end
+
+      assert_equal 'sentinel', File.read(dl_path)
+    end
+  end
+
   def test_download_url_to_file_via_file_io
     dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
     dl_path = File.join(Dir::tmpdir, "dl_url_test.file")

data/tests/tc_curl_easy.rb

@@ -18,6 +18,13 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 200, easy.code
   end
 
+  def test_perform_with_implicit_multi
+    easy = Curl::Easy.new($TEST_URL)
+
+    assert_nothing_raised { easy.perform }
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+  end
+
   def test_curlopt_resolve
     require 'resolv'
     uri = URI.parse(TestServlet.url)
@@ -39,6 +46,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
 
     http = Curl::Easy.new(url)
     http.dns_cache_timeout = 0
+    http.proxy_url = ""
     http.resolve = [mapping]
     http.get
     assert_match(/GET/, http.body)
@@ -1629,6 +1637,36 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   end
 
+  def test_easy_reset_clears_network_policy_allowlists
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.allowed_hosts = ['127.0.0.1']
+    easy.network_policy = :public
+    easy.allowed_cidrs = ['1.1.1.0/24']
+
+    settings = easy.reset
+
+    assert settings.key?(:allowed_hosts)
+    assert settings.key?(:allowed_cidrs)
+    assert_nil easy.allowed_hosts
+    assert_nil easy.allowed_cidrs
+    assert_equal :none, easy.network_policy
+  rescue NotImplementedError
+    omit('network_policy=:public requires CURLOPT_OPENSOCKETFUNCTION support')
+  end
+
+  def test_frozen_easy_close_and_reset_skip_safety_override_cleanup
+    closed_easy = Curl::Easy.new
+    closed_easy.freeze
+
+    assert_nothing_raised { closed_easy.close }
+
+    reset_easy = Curl::Easy.new
+    reset_easy.safe_http!
+    reset_easy.freeze
+
+    assert_nothing_raised { reset_easy.reset }
+  end
+
   def test_last_result_initialization
     # Test for issue #463 - ensure last_result is properly initialized to 0
     easy = Curl::Easy.new
@@ -1780,6 +1818,35 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     end
   end
 
+  def test_close_during_http_post_argument_coercion_is_blocked
+    curl = Curl::Easy.new(TestServlet.url)
+    field = Object.new
+    field.define_singleton_method(:to_s) do
+      curl.close
+      "a=b"
+    end
+
+    error = assert_raise(RuntimeError) { curl.http_post(field) }
+    assert_match(/Cannot close an active curl handle/, error.message)
+
+    assert_nothing_raised { curl.close }
+  end
+
+  def test_close_during_url_coercion_is_blocked
+    curl = Curl::Easy.new
+    url = Object.new
+    url.define_singleton_method(:to_str) do
+      curl.close
+      TestServlet.url
+    end
+
+    curl.url = url
+    error = assert_raise(RuntimeError) { curl.perform }
+    assert_match(/Cannot close an active curl handle/, error.message)
+
+    assert_nothing_raised { curl.close }
+  end
+
   def test_close_in_on_progress_is_blocked
     curl = Curl::Easy.new(TestServlet.url)
     did_raise = false
@@ -1865,6 +1932,16 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     end
   end
 
+  def test_poison
+    res_a = Curl.get("#{TestServlet.url}?a_body")
+    first_a_body = Digest::MD5.hexdigest(res_a.body)
+    res_b = Curl.get("#{TestServlet.url}?b_body")
+
+    b_body = Digest::MD5.hexdigest(res_b.body)
+    a_body = Digest::MD5.hexdigest(res_a.body)
+    assert_not_equal a_body, b_body, "we expected #{a_body} to be #{first_a_body}"
+  end
+
   include TestServerMethods 
 
   def setup

data/tests/tc_curl_easy_resolve.rb

@@ -22,6 +22,7 @@ class TestCurbCurlEasyResolve < Test::Unit::TestCase
     mapping = "#{host}:#{TestServlet.port}:127.0.0.1"
 
     @easy.url = "http://#{host}:#{TestServlet.port}#{TestServlet.path}"
+    @easy.proxy_url = ""
     @easy.dns_cache_timeout = 0
     @easy.set(:resolve, [mapping])
 
@@ -39,6 +40,7 @@ class TestCurbCurlEasyResolve < Test::Unit::TestCase
     entry.define_singleton_method(:to_s) { mapping }
 
     @easy.url = "http://#{host}:#{TestServlet.port}#{TestServlet.path}"
+    @easy.proxy_url = ""
     @easy.dns_cache_timeout = 0
     @easy.resolve = [entry]