curb 1.3.7 → 1.4.1

data/tests/helper.rb

@@ -228,12 +228,17 @@ module BugTestServerSetupTeardown
     @thread = Thread.new(@server) do|srv|
       srv.start
     end
+
+    # WEBrick#shutdown is a no-op until start has created its shutdown pipe
+    # and set :Running, so wait for that before the test (and its teardown)
+    # runs. Otherwise a teardown racing server startup could miss the brief
+    # :Shutdown status and spin forever once the server settled back on :Stop.
+    sleep 0.001 until @server.status == :Running || !@thread.alive?
+    @thread.value unless @thread.alive?
   end
 
   def teardown
-    while @server.status != :Shutdown
-      @server.shutdown
-    end
+    @server.shutdown
     @thread.join
   end
 end
@@ -730,3 +735,117 @@ end
 unless URI.methods.include?(:encode_www_form)
   URI.extend(Backports::Ruby18::URIFormEncoding)
 end
+
+# Valgrind slows every request enough that tight wall-clock bounds stop
+# meaning anything; tests use this to relax or skip only those bounds.
+def curb_under_valgrind?
+  ENV['LD_PRELOAD'].to_s.include?('vgpreload')
+end
+
+# Queue#pop(timeout:) needs Ruby 3.2. Older Rubies take the keyword hash as
+# the positional non_block flag and raise ThreadError immediately.
+def curb_pop_within(queue, seconds)
+  deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + seconds
+  loop do
+    begin
+      return queue.pop(true)
+    rescue ThreadError
+      return nil if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+      sleep 0.01
+    end
+  end
+end
+
+# Minimal HTTP/1.1 server so a test controls exactly when and how a response
+# is written. Every request gets its own connection (Connection: close).
+#
+#   /fast                   "fast" immediately
+#   /delay/<seconds>        "delayed" after sleeping
+#   /hang                   "released" once release_hung is called
+#   /stream/<chunks>/<n>    <chunks> writes of <n> bytes (see stream_body)
+#   /truncate               promises 100000 bytes, sends 10, then closes
+#   /reset                  sends part of a body, then aborts with a TCP RST
+class CurbTinyHTTPServer
+  attr_reader :port, :requests
+
+  # Chunk i is filled with one letter so a test can verify reassembly.
+  def self.stream_body(chunks, bytes)
+    (0...chunks).map { |i| (97 + (i % 26)).chr * bytes }.join
+  end
+
+  def initialize
+    @listener = TCPServer.new('127.0.0.1', 0)
+    @port = @listener.addr[1]
+    @requests = Queue.new
+    @release = Queue.new
+    @clients = []
+    @thread = Thread.new { accept_loop }
+  end
+
+  def url(path)
+    "http://127.0.0.1:#{@port}#{path}"
+  end
+
+  # Let pending /hang requests finish.
+  def release_hung(count = 64)
+    count.times { @release << true }
+  end
+
+  def close
+    release_hung
+    @listener.close rescue nil
+    @thread.kill
+    @thread.join(2)
+    @clients.each { |t| t.kill; t.join(1) }
+  end
+
+  private
+
+  def accept_loop
+    loop do
+      sock = @listener.accept
+      @clients << Thread.new(sock) { |s| handle(s) }
+    end
+  rescue IOError, Errno::EBADF
+    nil
+  end
+
+  def handle(sock)
+    request_line = sock.gets.to_s
+    while (line = sock.gets) && line != "\r\n"; end
+    path = request_line.split(' ')[1].to_s
+    @requests << path
+
+    case path
+    when %r{\A/delay/([\d.]+)}
+      sleep Float($1)
+      respond(sock, "delayed")
+    when '/hang'
+      curb_pop_within(@release, 10)
+      respond(sock, "released")
+    when %r{\A/stream/(\d+)/(\d+)}
+      chunks = Integer($1)
+      bytes = Integer($2)
+      sock.write("HTTP/1.1 200 OK\r\nContent-Length: #{chunks * bytes}\r\nConnection: close\r\n\r\n")
+      chunks.times do |i|
+        sock.write((97 + (i % 26)).chr * bytes)
+        Thread.pass
+      end
+    when '/truncate'
+      sock.write("HTTP/1.1 200 OK\r\nContent-Length: 100000\r\nConnection: close\r\n\r\n0123456789")
+    when '/reset'
+      sock.write("HTTP/1.1 200 OK\r\nContent-Length: 100000\r\nConnection: close\r\n\r\n0123456789")
+      sock.setsockopt(Socket::Option.linger(true, 0))
+    else
+      respond(sock, "fast")
+    end
+  rescue IOError, SystemCallError
+    nil
+  ensure
+    sock.close rescue nil
+  end
+
+  def respond(sock, body)
+    sock.write("HTTP/1.1 200 OK\r\nContent-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}")
+  end
+end

data/tests/tc_curl_easy.rb

@@ -1,9 +1,131 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
-class FooNoToS 
+class FooNoToS
   undef to_s
 end
 
+class FooBadToS
+  def to_s
+    42
+  end
+end
+
 class TestCurbCurlEasy < Test::Unit::TestCase
+  CONNECTION_INFO_METHODS = %i[
+    last_effective_url response_code code primary_ip http_connect_code file_time
+    total_time name_lookup_time connect_time app_connect_time pre_transfer_time
+    start_transfer_time redirect_time redirect_count redirect_url downloaded_bytes
+    uploaded_bytes download_speed upload_speed header_size request_size
+    ssl_verify_result downloaded_content_length uploaded_content_length content_type
+    os_errno num_connects cookielist ftp_entry_path
+  ].freeze
+
+  def test_uninitialized_handles_reject_native_operations
+    subclass = Class.new(Curl::Easy) { def initialize; end }
+    [Curl::Easy.allocate, subclass.new].each do |easy|
+      methods = CONNECTION_INFO_METHODS + %i[reset close clone dup perform]
+      methods.each do |method|
+        next unless easy.respond_to?(method)
+        error = assert_raise(Curl::Err::FailedInitError, method.to_s) { easy.public_send(method) }
+        assert_match(/not initialized/, error.message)
+      end
+      [[:escape, "x"], [:unescape, "x"], [:setopt, Curl::CURLOPT_VERBOSE, true],
+       [:http_post, "x"], [:http_put, "x"], [:http_patch, "x"]].each do |args|
+        assert_raise(Curl::Err::FailedInitError, args.first.to_s) { easy.public_send(*args) }
+      end
+      multi = Curl::Multi.new
+      begin
+        assert_raise(Curl::Err::FailedInitError) { multi.add(easy) }
+        assert_raise(Curl::Err::FailedInitError) { multi.send(:_remove, easy) }
+      ensure
+        multi.close
+      end
+    end
+  end
+
+  def test_allocated_handle_can_be_initialized
+    easy = Curl::Easy.allocate
+    easy.send(:initialize, $TEST_URL)
+    easy.perform
+    # libcurl normalizes file:///C:/ to file://C:/ on Windows.
+    expected_url = WINDOWS ? $TEST_URL.sub(%r{\Afile:///}, "file://") : $TEST_URL
+    assert_equal expected_url, easy.last_effective_url
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+  end
+
+  def test_connection_info_before_perform
+    easy = Curl::Easy.new
+    CONNECTION_INFO_METHODS.each do |method|
+      next unless easy.respond_to?(method)
+      assert_nothing_raised(method.to_s) { easy.public_send(method) }
+    end
+    assert_nil easy.last_effective_url
+    assert_nil easy.content_type
+    assert_equal 0, easy.response_code
+  end
+
+  def test_reinitialize_detaches_previous_handle
+    easy = Curl::Easy.new($TEST_URL)
+    easy.headers = { "X-Old" => "old" }
+    multi = Curl::Multi.new
+    multi.add(easy)
+    easy.send(:initialize, $TEST_URL)
+    assert_nil easy.multi
+    assert_equal({}, easy.headers)
+    multi.perform
+    easy.perform
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+    multi.add(easy)
+    multi.perform
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+  ensure
+    multi.close if multi
+  end
+
+  [:initialize, :close, :reset].each do |operation|
+    define_method("test_#{operation}_removes_multi_bookkeeping_before_readd") do
+      easy = Curl::Easy.new($TEST_URL)
+      multi = Curl::Multi.new
+      multi.add(easy)
+      easy.__send__(operation)
+
+      assert_nil easy.multi
+      assert_empty multi.requests
+      assert_empty multi.__send__(:__curb_native_safety_signatures)
+
+      easy.url = $TEST_URL
+      multi.add(easy)
+      assert_equal [easy], multi.requests.values
+      multi.perform
+      assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+    ensure
+      multi.close if multi
+      easy.close if easy
+    end
+  end
+
+  def test_reinitialize_during_callback_is_blocked
+    easy = Curl::Easy.new($TEST_URL)
+    easy.on_body do |data|
+      error = assert_raise(RuntimeError) { easy.send(:initialize, $TEST_URL) }
+      assert_match(/Cannot initialize an active curl handle/, error.message)
+      data.bytesize
+    end
+    easy.perform
+    easy.send(:initialize, $TEST_URL)
+    easy.perform
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+  end
+
+  def test_reinitialize_during_argument_coercion_is_blocked
+    easy = Curl::Easy.new($TEST_URL)
+    field = Object.new
+    field.define_singleton_method(:to_s) { easy.send(:initialize, $TEST_URL); "a=b" }
+    error = assert_raise(RuntimeError) { easy.http_post(field) }
+    assert_match(/Cannot initialize an active curl handle/, error.message)
+    easy.perform
+    assert_match(/^# DO NOT REMOVE THIS COMMENT/, easy.body_str)
+  end
+
   def test_global_reset
     Curl.get($TEST_URL)
     # in a Timeout block you should reset the thread current handle 
@@ -560,7 +682,24 @@ class TestCurbCurlEasy < Test::Unit::TestCase
       assert_equal "one\000two three", c.unescape("one%00two%20three")
     end
   end
-  
+
+  def test_escape_with_non_string_to_s_result_does_not_crash
+    c = Curl::Easy.new
+    result = nil
+    # #to_s returning a non-String (42, a Fixnum) makes rb_obj_as_string
+    # fall back to the default Object#to_s representation rather than "42" -
+    # the point of this test is that it doesn't crash, not the exact value.
+    assert_nothing_raised { result = c.escape(FooBadToS.new) }
+    assert_kind_of String, result
+  end
+
+  def test_unescape_with_non_string_to_s_result_raises_type_error
+    c = Curl::Easy.new
+    # unescape expects an actual String (or something #to_str-coercible);
+    # it must raise cleanly rather than crash on a bad #to_s.
+    assert_raise(TypeError) { c.unescape(FooBadToS.new) }
+  end
+
   def test_headers
     c = Curl::Easy.new($TEST_URL)
     
@@ -745,7 +884,23 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     c.http_auth_types = nil
     assert_nil c.http_auth_types
   end
-  
+
+  def test_http_auth_types_with_non_string_to_s_result_does_not_crash
+    c = Curl::Easy.new
+    assert_nothing_raised { c.http_auth_types = FooBadToS.new }
+    assert_nothing_raised { c.http_auth_types = [FooBadToS.new, :basic] }
+    assert_equal Curl::CURLAUTH_BASIC, c.http_auth_types
+  end
+
+  def test_http_auth_types_array_of_symbols
+    c = Curl::Easy.new
+    c.http_auth_types = [:basic, :digest]
+    assert_equal Curl::CURLAUTH_BASIC | Curl::CURLAUTH_DIGEST, c.http_auth_types
+
+    c.send(:http_auth_types=, :basic, :ntlm)
+    assert_equal Curl::CURLAUTH_BASIC | Curl::CURLAUTH_NTLM, c.http_auth_types
+  end
+
   def test_proxy_auth_types_01
     c = Curl::Easy.new($TEST_URL)
     
@@ -757,7 +912,23 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     c.proxy_auth_types = nil
     assert_nil c.proxy_auth_types
   end
-  
+
+  def test_proxy_auth_types_symbols
+    c = Curl::Easy.new
+
+    c.proxy_auth_types = :basic
+    assert_equal Curl::CURLAUTH_BASIC, c.proxy_auth_types
+
+    c.proxy_auth_types = [:basic, :ntlm]
+    assert_equal Curl::CURLAUTH_BASIC | Curl::CURLAUTH_NTLM, c.proxy_auth_types
+
+    c.send(:proxy_auth_types=, :basic, :digest)
+    assert_equal Curl::CURLAUTH_BASIC | Curl::CURLAUTH_DIGEST, c.proxy_auth_types
+
+    assert_nothing_raised { c.proxy_auth_types = [FooBadToS.new, :basic] }
+    assert_equal Curl::CURLAUTH_BASIC, c.proxy_auth_types
+  end
+
   def test_max_redirects_01
     c = Curl::Easy.new($TEST_URL)
     

data/tests/tc_curl_easy_cookielist.rb

@@ -46,14 +46,17 @@ class TestCurbCurlEasyCookielist < Test::Unit::TestCase
     expires = (Date.today + 2).to_datetime
     easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/set_cookies"
     easy.setopt(Curl::CURLOPT_COOKIELIST, "Set-Cookie: c1=v1; domain=localhost; expires=#{expires.httpdate};")
-    easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', domain: 'localhost', expires: expires.httpdate, path: '/' }])
+    # c2 has no Domain attribute so it is host-only on every libcurl version.
+    # With domain=localhost, curl >= 8.22 built with libpsl makes it host-only
+    # (localhost is a public suffix) while older curl tail-matches (#483).
+    easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', expires: expires.httpdate, path: '/' }])
     easy.perform
     easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
     easy.post_body = nil
     easy.perform
 
     assert !easy.enable_cookies?
-    assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc1\tv1", ".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc2\tv2"], easy.cookielist
+    assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc1\tv1", "localhost\tFALSE\t/\tFALSE\t#{expires.to_time.to_i}\tc2\tv2"], easy.cookielist
     assert_equal 'c2=v2; c1=v1', easy.body_str
   end
 
@@ -183,13 +186,15 @@ class TestCurbCurlEasyCookielist < Test::Unit::TestCase
       cookiefile = File.join(Dir.tmpdir, 'curl_test_cookiefile')
       assert !File.exist?(cookiefile)
       begin
+        # Use host-only file cookies: libpsl builds normalize localhost domain
+        # cookies on file load, but COOKIELIST imports retain tail matching.
         cookielist = [
           # Won't be updated, added instead
-          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent\t84",
-          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent_file\t84",
+          "localhost\tFALSE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent\t84",
+          "localhost\tFALSE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent_file\t84",
           # Won't be updated, added instead
-          ".localhost\tTRUE\t/\tFALSE\t0\tsession\t840",
-          ".localhost\tTRUE\t/\tFALSE\t0\tsession_file\t840",
+          "localhost\tFALSE\t/\tFALSE\t0\tsession\t840",
+          "localhost\tFALSE\t/\tFALSE\t0\tsession_file\t840",
           '',
         ]
         File.write(cookiefile, cookielist.join("\n"))
@@ -201,10 +206,10 @@ class TestCurbCurlEasyCookielist < Test::Unit::TestCase
         expected_cookielist = [
           ".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tpermanent\t42",
           ".localhost\tTRUE\t/\tFALSE\t0\tsession\t420",
-          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent\t84",
-          ".localhost\tTRUE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent_file\t84",
-          ".localhost\tTRUE\t/\tFALSE\t0\tsession\t840",
-          ".localhost\tTRUE\t/\tFALSE\t0\tsession_file\t840",
+          "localhost\tFALSE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent\t84",
+          "localhost\tFALSE\t/\tFALSE\t#{expires_file.to_time.to_i}\tpermanent_file\t84",
+          "localhost\tFALSE\t/\tFALSE\t0\tsession\t840",
+          "localhost\tFALSE\t/\tFALSE\t0\tsession_file\t840",
         ]
         assert_equal expected_cookielist, easy.cookielist
         easy.perform
@@ -245,14 +250,15 @@ class TestCurbCurlEasyCookielist < Test::Unit::TestCase
       expires = (Date.today + 2).to_datetime
       easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/set_cookies"
       easy.setopt(Curl::CURLOPT_COOKIELIST, command)
-      easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', domain: 'localhost', expires: expires.httpdate, path: '/' }])
+      # host-only c2, see test_setopt_cookielist_enables_cookie_engine (#483)
+      easy.post_body = JSON.generate([{ name: 'c2', value: 'v2', expires: expires.httpdate, path: '/' }])
       easy.perform
       easy.url = "http://localhost:#{TestServlet.port}#{TestServlet.path}/get_cookies"
       easy.post_body = nil
       easy.perform
 
       assert !easy.enable_cookies?
-      assert_equal [".localhost\tTRUE\t/\tFALSE\t#{expires.to_time.to_i}\tc2\tv2"], easy.cookielist
+      assert_equal ["localhost\tFALSE\t/\tFALSE\t#{expires.to_time.to_i}\tc2\tv2"], easy.cookielist
       assert_equal 'c2=v2', easy.body_str
     end
   end

data/tests/tc_curl_maxfilesize.rb

@@ -10,6 +10,94 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
     super
   end
 
+  def test_safe_body_limit_defaults_and_raw_requests
+    assert_equal 10 * 1024 * 1024, Curl::SafetyConfig.new.max_body_bytes
+    assert_nil @easy.max_body_bytes
+    stub_public_network_policy_for_local_fixture(@easy)
+    @easy.safe_http!
+    assert_equal Curl::SafetyConfig::DEFAULT_MAX_BODY_BYTES, @easy.max_body_bytes
+    @easy.max_body_bytes = nil
+    Curl.__send__(:apply_safety!, @easy)
+    assert_equal Curl::SafetyConfig::DEFAULT_MAX_BODY_BYTES, @easy.max_body_bytes
+  end
+
+  [:global, :helper, :handle].each do |mode|
+    define_method("test_#{mode}_default_body_limit_rejects_oversized_response") do
+      payload = 'x' * (Curl::SafetyConfig::DEFAULT_MAX_BODY_BYTES + 1)
+      with_raw_http_response("HTTP/1.1 200 OK\r\nContent-Length: #{payload.bytesize}\r\n\r\n#{payload}") do |url|
+        assert_body_limit_error do
+          if mode == :helper
+            Curl.safe_get(url) { |easy| stub_public_network_policy_for_local_fixture(easy) }
+          else
+            Curl.safe! if mode == :global
+            @easy.url = url
+            stub_public_network_policy_for_local_fixture(@easy)
+            @easy.safe_http! if mode == :handle
+            @easy.perform
+          end
+        end
+      end
+    end
+  end
+
+  def test_default_body_limit_bounds_callback_delivery_without_content_length
+    limit = Curl::SafetyConfig::DEFAULT_MAX_BODY_BYTES
+    payload = 'x' * (limit + 1)
+    received = 0
+    with_raw_http_response("HTTP/1.0 200 OK\r\n\r\n#{payload}") do |url|
+      @easy.url = url
+      stub_public_network_policy_for_local_fixture(@easy)
+      @easy.safe_http!
+      @easy.on_body { |data| received += data.bytesize; data.bytesize }
+      assert_body_limit_error { @easy.perform }
+    end
+    assert_operator received, :<=, limit
+    assert_operator received, :>, 0
+  end
+
+  def test_global_body_limit_can_be_explicitly_disabled
+    Curl.safe! { |config| config.max_body_bytes = nil }
+    stub_public_network_policy_for_local_fixture(@easy)
+    @easy.safe_http!
+    assert_nil @easy.max_body_bytes
+  end
+
+  def test_safe_helper_accepts_explicit_larger_limit_and_unlimited
+    [20 * 1024 * 1024, nil, 0].each do |limit|
+      with_raw_http_response("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok") do |url|
+        easy = Curl.safe_get(url, :max_body_bytes => limit) do |handle|
+          stub_public_network_policy_for_local_fixture(handle)
+        end
+        assert_equal(limit == 0 ? nil : limit, easy.max_body_bytes)
+        assert_equal 'ok', easy.body_str
+      end
+    end
+  end
+
+  def test_safe_helper_inherits_global_body_limit
+    Curl.safe! { |config| config.max_body_bytes = 20 * 1024 * 1024 }
+    stub_public_network_policy_for_local_fixture(@easy)
+    @easy.safe_http!
+    assert_equal 20 * 1024 * 1024, @easy.max_body_bytes
+  end
+
+  def test_safe_helper_cannot_weaken_global_body_limit
+    Curl.safe! { |config| config.max_body_bytes = 10 }
+    [100, nil, 0].each do |limit|
+      with_raw_http_response("HTTP/1.1 200 OK\r\nContent-Length: 64\r\n\r\n#{'x' * 64}") do |url|
+        assert_body_limit_error do
+          Curl.safe_get(url, :max_body_bytes => limit) do |handle|
+            stub_public_network_policy_for_local_fixture(handle)
+          end
+        end
+      end
+    end
+  end
+
+  def test_safe_http_rejects_negative_body_limit
+    assert_raise(ArgumentError) { @easy.safe_http!(:max_body_bytes => -1) }
+  end
+
   def test_maxfilesize_setopt
     @easy.set(Curl::CURLOPT_MAXFILESIZE, 5000000)
     @easy.set(Curl::CURLOPT_MAXFILESIZE_LARGE, 5000000) if Curl.const_defined?(:CURLOPT_MAXFILESIZE_LARGE)
@@ -41,7 +129,7 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
   def test_safe_get_accepts_max_body_bytes_as_second_argument
     with_raw_http_response("HTTP/1.1 200 OK\r\nContent-Length: 64\r\n\r\n#{'x' * 64}") do |url|
       assert_body_limit_error do
-        Curl.safe_get(url, :max_body_bytes => 10)
+        Curl.safe_get(url, :max_body_bytes => 10) { |easy| stub_public_network_policy_for_local_fixture(easy) }
       end
     end
   end
@@ -50,6 +138,7 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
     with_raw_http_response("HTTP/1.1 200 OK\r\nContent-Length: 64\r\n\r\n#{'x' * 64}") do |url|
       assert_body_limit_error do
         Curl.safe_get(url, {}, :max_body_bytes => 10) do |easy|
+          stub_public_network_policy_for_local_fixture(easy)
           easy.max_body_bytes = nil
         end
       end
@@ -63,6 +152,7 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
       end
 
       @easy.url = url
+      stub_public_network_policy_for_local_fixture(@easy)
 
       assert_body_limit_error do
         @easy.perform
@@ -78,6 +168,7 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
 
       assert_body_limit_error do
         Curl.get(url) do |easy|
+          stub_public_network_policy_for_local_fixture(easy)
           easy.max_body_bytes = nil
         end
       end
@@ -91,7 +182,7 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
       end
 
       assert_body_limit_error do
-        Curl.safe_get(url, :max_body_bytes => 10)
+        Curl.safe_get(url, :max_body_bytes => 10) { |easy| stub_public_network_policy_for_local_fixture(easy) }
       end
     end
   end
@@ -106,7 +197,7 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
 
   def test_safe_head_does_not_apply_body_cap_to_content_length
     with_raw_http_response("HTTP/1.1 200 OK\r\nContent-Length: 65536\r\n\r\n") do |url|
-      easy = Curl.safe_head(url, :max_body_bytes => 1)
+      easy = Curl.safe_head(url, :max_body_bytes => 1) { |handle| stub_public_network_policy_for_local_fixture(handle) }
 
       assert_equal 200, easy.response_code
       assert_equal '', easy.body_str
@@ -182,6 +273,14 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
 
   private
 
+  # Keep body-limit integration tests local; real destination enforcement is
+  # covered separately 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 assert_body_limit_error
     assert_raise(Curl::Err::FileSizeExceededError) do
       yield
@@ -197,8 +296,13 @@ class TestCurbCurlMaxFileSize < Test::Unit::TestCase
         socket.readpartial(4096)
       rescue EOFError
       end
-      socket.write(response)
-      socket.close
+      begin
+        socket.write(response)
+      rescue Errno::EPIPE, Errno::ECONNRESET
+        # Expected when the client aborts at the body limit.
+      ensure
+        socket.close
+      end
     end
 
     yield "http://127.0.0.1:#{port}/"

data/tests/tc_curl_multi.rb

@@ -586,6 +586,35 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  # Only easies attached by the raising callback itself are withdrawn. Work
+  # queued by an earlier, successful callback in the same perform was already
+  # attached when the failing callback started, so it keeps running and the
+  # deferred exception is raised once it drains.
+  def test_multi_perform_keeps_work_added_by_earlier_callback_when_later_callback_raises
+    server = CurbTinyHTTPServer.new
+    multi = Curl::Multi.new
+    first = Curl::Easy.new(server.url('/fast'))
+    failing = Curl::Easy.new(server.url('/delay/0.15'))
+    kept = Curl::Easy.new(server.url('/delay/0.4'))
+
+    first.on_complete { multi.add(kept) }
+    failing.on_complete { raise "complete blew up" }
+
+    error = assert_raise(Curl::Err::AbortedByCallbackError) do
+      multi.add(first)
+      multi.add(failing)
+      multi.perform
+    end
+
+    assert_equal "complete blew up", error.message
+    assert_equal 0, kept.last_result
+    assert_equal "delayed", kept.body_str,
+                 "work added by an earlier successful callback should finish, not be withdrawn with the failing callback's additions"
+  ensure
+    multi.close if multi
+    server.close if server
+  end
+
   def test_multi_perform_does_not_start_work_added_within_on_complete_after_on_body_exception
     with_queue_refill_test_server do |port, hits|
       multi = Curl::Multi.new