curb 1.4.0 → 1.4.1

data/tests/tc_curl_protocols.rb

@@ -104,11 +104,10 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
     end
   end
 
-  def test_safe_get_allows_http_protocol
-    easy = Curl.safe_get(TestServlet.url)
-
-    assert_equal 200, easy.response_code
-    assert_match(/GET/, easy.body_str)
+  def test_safe_get_blocks_local_http_destination
+    assert_raise(Curl::Err::UnsafeDestinationError) do
+      Curl.safe_get(TestServlet.url)
+    end
   end
 
   def test_safe_bang_denies_file_protocol_for_easy_perform
@@ -159,8 +158,8 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
     end
   end
 
-  def test_safe_bang_allows_http_protocol
-    Curl.safe!
+  def test_safe_bang_explicit_none_allows_trusted_http_destination
+    Curl.safe! { |config| config.network_policy = :none }
     easy = Curl.get(TestServlet.url)
 
     assert_equal 200, easy.response_code
@@ -184,6 +183,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
     with_file_redirect_server do |url|
       easy = Curl::Easy.new(url)
       easy.follow_location = true
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       assert_raises Curl::Err::UnsupportedProtocolError do
@@ -198,6 +198,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
 
       easy = Curl::Easy.new(url)
       easy.follow_location = true
+      stub_public_network_policy_for_local_fixture(easy)
 
       assert_raises Curl::Err::UnsupportedProtocolError do
         easy.perform
@@ -211,6 +212,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
       easy.follow_location = true
       easy.ssl_verify_peer = false
       easy.ssl_verify_host = false
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       easy.perform
@@ -226,6 +228,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
       easy.follow_location = true
       easy.ssl_verify_peer = false
       easy.ssl_verify_host = false
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       easy.perform
@@ -240,6 +243,7 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
       easy = Curl::Easy.new(url)
       easy.follow_location = true
       easy.max_redirects = 2
+      stub_public_network_policy_for_local_fixture(easy)
       easy.safe_http!
 
       assert_raises Curl::Err::TooManyRedirectsError do
@@ -252,6 +256,14 @@ class TestCurbCurlProtocols < Test::Unit::TestCase
 
   private
 
+  # Isolate protocol/redirect behavior using local fixtures. Destination blocking
+  # is exercised without this stub in tc_curl_network_policy.rb.
+  def stub_public_network_policy_for_local_fixture(easy)
+    def easy.network_policy=(policy)
+      raise "unexpected policy: #{policy}" unless policy == :public
+    end
+  end
+
   def with_file_redirect_server
     port_socket = TCPServer.new('127.0.0.1', 0)
     port = port_socket.addr[1]

data/tests/tc_curl_transfer_guard.rb

@@ -0,0 +1,112 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbTransferGuard < Test::Unit::TestCase
+  class InterruptedTransfer < StandardError; end
+
+  [:perform, :_socket_perform].each do |drive|
+    define_method("test_#{drive}_rejects_cross_thread_handle_access") do
+      with_waiting_transfer(drive) do |easy, multi, worker, release|
+        operations = {
+          close: -> { easy.close },
+          reset: -> { easy.reset },
+          initialize: -> { easy.__send__(:initialize) },
+          clone: -> { easy.clone },
+          dup: -> { easy.dup },
+          setopt: -> { easy.setopt(Curl::CURLOPT_CUSTOMREQUEST, 'DELETE') },
+          post_body: -> { easy.post_body = 'replacement' },
+          url: -> { easy.url = 'http://127.0.0.1/' },
+          timeout: -> { easy.timeout = 1 },
+          multi_assignment: -> { easy.multi = nil },
+          multi_remove: -> { multi.remove(easy) },
+          multi_close: -> { multi.close },
+          multi_initialize: -> { multi.__send__(:initialize) },
+          multi_add: -> { multi.add(Curl::Easy.new('http://127.0.0.1/')) },
+          multi_option: -> { multi.max_connects = 1 }
+        }
+        operations.each do |name, operation|
+          error = assert_raise(RuntimeError, name.to_s, &operation)
+          assert_match(/another thread|active Curl::Multi/, error.message, name.to_s)
+        end
+        assert_equal [easy], multi.requests.values
+
+        release << true
+        assert worker.join(5), 'perform did not finish'
+        worker.value
+        assert_equal 'ok', easy.body_str
+        assert_nothing_raised { easy.clone.close }
+        assert_nothing_raised { easy.reset }
+        assert_nothing_raised { easy.close }
+      end
+    end
+
+    define_method("test_#{drive}_releases_guard_after_interruption") do
+      with_waiting_transfer(drive) do |easy, multi, worker, release|
+        worker.raise(InterruptedTransfer, 'stop')
+        assert worker.join(5), 'interrupted perform did not finish'
+        assert_kind_of InterruptedTransfer, worker[:transfer_error]
+        assert_nothing_raised { multi.remove(easy) }
+        assert_nothing_raised { easy.reset }
+        assert_nothing_raised { easy.close }
+        release << true
+      end
+    end
+  end
+
+  def with_waiting_transfer(drive)
+    if drive == :_socket_perform && !Curl::Multi.private_method_defined?(drive)
+      omit('socket-action perform path is not available')
+    end
+    server = TCPServer.new('127.0.0.1', 0)
+    started = Queue.new
+    release = Queue.new
+    server_thread = Thread.new do
+      socket = server.accept
+      begin
+        request = +''
+        request << socket.readpartial(4096) until request.include?("\r\n\r\n")
+        started << true
+        release.pop
+        socket.write("HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\nok")
+      rescue Errno::EPIPE, Errno::ECONNRESET
+        # The interruption test intentionally closes the connection early.
+      ensure
+        socket.close
+      end
+    end
+    easy = Curl::Easy.new("http://127.0.0.1:#{server.addr[1]}/")
+    multi = Curl::Multi.new
+    # Exercise reuse after autoclose as well as the active-transfer checks.
+    previous_autoclose = Curl::Multi.autoclose
+    begin
+      Curl::Multi.autoclose = true
+      multi.add(Curl::Easy.new($TEST_URL))
+      multi.perform
+    ensure
+      Curl::Multi.autoclose = previous_autoclose
+    end
+    multi.add(easy)
+    worker = Thread.new do
+      Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+      begin
+        multi.__send__(drive)
+      rescue InterruptedTransfer => error
+        # Keep join non-raising so the test can inspect the exception explicitly.
+        Thread.current[:transfer_error] = error
+      end
+    end
+    Timeout.timeout(5) { started.pop }
+    yield easy, multi, worker, release
+  ensure
+    release << true if release
+    if worker && worker.alive?
+      worker.kill
+      worker.join(5)
+    end
+    multi.close if multi
+    server.close if server && !server.closed?
+    if server_thread
+      server_thread.join(5)
+      server_thread.kill if server_thread.alive?
+    end
+  end
+end

data/tests/tc_ractor.rb

@@ -30,7 +30,10 @@ class TestCurbRactor < Test::Unit::TestCase
 
     workers = RACTOR_WORKERS.times.map do |worker_id|
       Ractor.new(url, worker_id, REQUESTS_PER_WORKER) do |target, id, request_count|
-        Curl.safe! { |config| config.protocols = [:http] }
+        Curl.safe! do |config|
+          config.protocols = [:http]
+          config.network_policy = :none # This concurrency fixture uses localhost.
+        end
         Curl::Multi.default_timeout = 25 + id
         Curl::Multi.autoclose = true
 
@@ -76,6 +79,50 @@ class TestCurbRactor < Test::Unit::TestCase
     Curl::Multi.autoclose = original_autoclose if defined?(original_autoclose)
   end
 
+  def test_multipart_snapshots_are_private_to_parallel_ractors
+    omit_unless_curb_ractor_safe
+    worker_count = Integer(ENV.fetch('CURB_MULTIPART_RACTORS', '4'))
+    request_count = Integer(ENV.fetch('CURB_MULTIPART_REQUESTS', '5'))
+    workers = worker_count.times.map do |worker_id|
+      Ractor.new(TestServlet.url, worker_id, request_count) do |url, id, count|
+        easy = Curl::Easy.new(url)
+        easy.multipart_form_post = true
+        count.times do |iteration|
+          name = +"field_#{id}_#{iteration}"
+          payload = "payload_#{id}_#{iteration}\0" + ('x' * 1024)
+          expected_name = name.dup
+          expected_payload = payload.dup
+          direct = Curl::PostField.content(name, payload, 'application/octet-stream')
+          file = Curl::PostField.file('upload', 'payload.bin') { payload }
+          later = Curl::PostField.content('later') do
+            name.replace('changed' * 1000)
+            payload.replace('changed' * 1000)
+            # Ruby #21537: explicit GC in a Windows Ractor can deadlock
+            # the VM barrier. Keep parallel mutation coverage on Windows;
+            # single-Ractor compaction is covered by the PostField tests.
+            if iteration % 10 == 0 && !WINDOWS
+              GC.start
+              GC.compact if GC.respond_to?(:compact)
+            end
+            'done'
+          end
+          easy.http_post(direct, file, later)
+          body = easy.body_str
+          unless easy.response_code == 200 &&
+                 body.include?("name=\"#{expected_name}\"") &&
+                 body.include?('filename="payload.bin"') &&
+                 body.scan(expected_payload).length == 2 &&
+                 !body.include?('changed')
+            raise "Multipart snapshot changed in Ractor #{id}, request #{iteration}"
+          end
+        end
+        easy.close
+        count
+      end
+    end
+    assert_equal Array.new(worker_count, request_count), workers.map { |worker| ractor_value(worker) }
+  end
+
   private
 
   def omit_unless_curb_ractor_safe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.4.1
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2026-09-27 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies: []
 description: Curb (probably CUrl-RuBy or something) provides Ruby-language bindings
   for the libcurl(3), a fully-featured client-side URL transfer library. cURL and
@@ -21,6 +21,7 @@ extra_rdoc_files:
 - LICENSE
 - README.md
 files:
+- ChangeLog.md
 - LICENSE
 - README.md
 - Rakefile
@@ -84,6 +85,7 @@ files:
 - tests/tc_curl_network_policy.rb
 - tests/tc_curl_postfield.rb
 - tests/tc_curl_protocols.rb
+- tests/tc_curl_transfer_guard.rb
 - tests/tc_fiber_scheduler.rb
 - tests/tc_ftp_options.rb
 - tests/tc_gc_compact.rb
@@ -157,6 +159,7 @@ test_files:
 - tests/tc_curl_network_policy.rb
 - tests/tc_curl_postfield.rb
 - tests/tc_curl_protocols.rb
+- tests/tc_curl_transfer_guard.rb
 - tests/tc_fiber_scheduler.rb
 - tests/tc_ftp_options.rb
 - tests/tc_gc_compact.rb