curb 1.4.0 → 1.5.0

data/tests/tc_curl_easy.rb

@@ -10,6 +10,122 @@ class FooBadToS
 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 
@@ -63,6 +179,32 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match(/GET/, http.body)
   end
 
+  # The default body/header buffers used to reserve 32 KB/16 KB up front, and
+  # that capacity stayed attached to every returned string.
+  def test_small_response_strings_do_not_retain_large_buffers
+    require 'objspace'
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.perform
+
+    body = easy.body_str
+    header = easy.header_str
+    assert_operator body.bytesize, :>, 0
+    assert_operator ObjectSpace.memsize_of(body), :<, 4096, 'body_str keeps excess capacity'
+    assert_operator ObjectSpace.memsize_of(header), :<, 4096, 'header_str keeps excess capacity'
+  end
+
+  def test_large_response_body_is_complete
+    require 'objspace'
+    server = CurbTinyHTTPServer.new
+    expected = CurbTinyHTTPServer.stream_body(64, 4096)
+    easy = Curl::Easy.new(server.url('/stream/64/4096'))
+    easy.perform
+    assert_equal expected, easy.body_str
+    assert_operator ObjectSpace.memsize_of(easy.body_str), :<, expected.bytesize + 4096
+  ensure
+    server.close if server
+  end
+
   def test_curlopt_stderr_with_file
     # does not work with Tempfile directly
     path = Tempfile.new('curb_test_curlopt_stderr').path
@@ -123,6 +265,92 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     tmp.close! if defined?(tmp) && tmp
   end
 
+  # libcurl used to write through the IO's own FILE*, which Ruby frees on
+  # close. curb now owns a stream on a duplicate descriptor instead.
+  def test_curlopt_stderr_survives_block_form_file_close
+    tmp = Tempfile.new('curb_test_curlopt_stderr_closed')
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    File.open(tmp.path, 'w') { |file| easy.setopt(Curl::CURLOPT_STDERR, file) }
+
+    2.times { easy.perform }
+
+    output = File.read(tmp.path)
+    assert_equal 2, output.scan(/HTTP\/1\.1 200 OK/).length
+  ensure
+    tmp.close! if tmp
+  end
+
+  def test_curlopt_stderr_survives_close_after_multi_add
+    tmp = Tempfile.new('curb_test_curlopt_stderr_multi')
+    file = File.open(tmp.path, 'w')
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    easy.setopt(Curl::CURLOPT_STDERR, file)
+    multi = Curl::Multi.new
+    multi.add(easy)
+    file.close
+    GC.start
+
+    multi.perform
+
+    assert_equal 200, easy.response_code
+    assert_match(/HTTP\/1\.1 200 OK/, File.read(tmp.path))
+  ensure
+    multi.close if multi
+    tmp.close! if tmp
+  end
+
+  def test_curlopt_stderr_clone_owns_its_stream
+    tmp = Tempfile.new('curb_test_curlopt_stderr_clone')
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    File.open(tmp.path, 'w') { |file| easy.setopt(Curl::CURLOPT_STDERR, file) }
+    copy = easy.clone
+
+    # Releasing the original's stream must not affect the clone's.
+    easy.close
+    GC.start
+    copy.perform
+
+    assert_equal 200, copy.response_code
+    assert_match(/HTTP\/1\.1 200 OK/, File.read(tmp.path))
+  ensure
+    tmp.close! if tmp
+  end
+
+  def test_curlopt_stderr_streams_are_released
+    fd_dir = '/proc/self/fd'
+    omit('needs /proc/self/fd to count open descriptors') unless File.directory?(fd_dir)
+    tmp = Tempfile.new('curb_test_curlopt_stderr_release')
+    file = File.open(tmp.path, 'w')
+    easy = Curl::Easy.new(TestServlet.url)
+    before = Dir.children(fd_dir).length
+
+    # Replacement, reset, and close each release curb's descriptor.
+    20.times { easy.setopt(Curl::CURLOPT_STDERR, file) }
+    easy.reset
+    easy.setopt(Curl::CURLOPT_STDERR, file)
+    easy.close
+    easy.setopt(Curl::CURLOPT_STDERR, file)
+    easy.clone.close
+    easy.close
+
+    assert_equal before, Dir.children(fd_dir).length
+  ensure
+    file.close if file && !file.closed?
+    tmp.close! if tmp
+  end
+
+  def test_curlopt_stderr_rejects_unwritable_io
+    tmp = Tempfile.new('curb_test_curlopt_stderr_readonly')
+    File.open(tmp.path, 'r') do |file|
+      assert_raise(IOError) { Curl::Easy.new.setopt(Curl::CURLOPT_STDERR, file) }
+    end
+  ensure
+    tmp.close! if tmp
+  end
+
   def test_head_request_no_body_and_no_timeout
     # Ensure a HEAD request completes and does not attempt to read a body
     # even when the server advertises a Content-Length.
@@ -2003,4 +2231,80 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     server_setup
   end
 
+  # Replacing request state while libcurl is still sending the old state
+  # freed buffers libcurl was reading (use-after-free). Every entry point that
+  # hands libcurl new request state must refuse while the handle is active.
+  ACTIVE_HANDLE_MUTATORS = {
+    'post_body=' => ->(easy) { easy.post_body = 'replacement' },
+    'put_data=' => ->(easy) { easy.put_data = 'replacement' },
+    'autoreferer=' => ->(easy) { easy.autoreferer = true },
+    'http_post' => ->(easy) { easy.http_post('replacement') },
+    'http_put' => ->(easy) { easy.http_put('replacement') },
+    'http_patch' => ->(easy) { easy.http_patch('replacement') },
+    'http_delete' => ->(easy) { easy.http_delete },
+    'http(:OPTIONS)' => ->(easy) { easy.http(:OPTIONS) },
+    '__curb_native_setup!' => ->(easy) { easy.__send__(:__curb_native_setup!) },
+  }.freeze
+
+  def test_request_state_cannot_be_replaced_during_own_transfer
+    ACTIVE_HANDLE_MUTATORS.each do |name, mutate|
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.post_body = 'original'
+      errors = []
+      easy.on_body do |data|
+        begin
+          mutate.call(easy)
+        rescue RuntimeError => e
+          errors << e
+        end
+        data.bytesize
+      end
+
+      easy.perform
+
+      assert_equal 1, errors.length, name
+      assert_match(/Cannot modify an active curl handle/, errors.first.message, name)
+      assert_equal 200, easy.response_code, name
+      assert_equal 'original', easy.post_body, name
+
+      # Once idle, the same mutation is allowed again.
+      easy.on_body
+      assert_nothing_raised(name) { mutate.call(easy) }
+    end
+  end
+
+  def test_request_state_cannot_be_replaced_on_active_sibling_transfer
+    ACTIVE_HANDLE_MUTATORS.each do |name, mutate|
+      # The sibling's response is delayed so it is still in flight when the
+      # first transfer's body callback runs.
+      server = CurbTinyHTTPServer.new
+      multi = Curl::Multi.new
+      first = Curl::Easy.new(TestServlet.url)
+      sibling = Curl::Easy.new(server.url('/delay/0.3'))
+      sibling.post_body = 'original'
+      errors = []
+      first.on_body do |data|
+        begin
+          mutate.call(sibling)
+        rescue RuntimeError => e
+          errors << e
+        end
+        data.bytesize
+      end
+
+      multi.add(first)
+      multi.add(sibling)
+      multi.perform
+
+      assert_operator errors.length, :>=, 1, name
+      errors.each { |e| assert_match(/Cannot modify an active curl handle/, e.message, name) }
+      assert_equal 200, sibling.response_code, name
+      assert_equal 'delayed', sibling.body_str, name
+      assert_equal 'original', sibling.post_body, name
+    ensure
+      multi.close if multi
+      server.close if server
+    end
+  end
+
 end

data/tests/tc_curl_easy_cookielist.rb

@@ -186,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"))
@@ -204,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

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

@@ -799,6 +799,7 @@ class TestCurbCurlMulti < Test::Unit::TestCase
   end
 
   def test_native_safety_signatures_are_pruned_after_perform
+    Curl.safe! { |config| config.network_policy = :none }
     m = Curl::Multi.new
     easy = Curl::Easy.new($TEST_URL)
 
@@ -811,6 +812,37 @@ class TestCurbCurlMulti < Test::Unit::TestCase
 
     assert_equal 0, m.requests.length
     assert_empty signatures
+  ensure
+    m.close if m
+    Curl.__send__(:clear_safe!)
+  end
+
+  def test_unconstrained_easy_skips_safety_signature_bookkeeping
+    m = Curl::Multi.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    m.add(easy)
+    assert_empty m.__send__(:__curb_native_safety_signatures)
+
+    m.perform
+    assert_equal 200, easy.response_code
+  ensure
+    m.close if m
+  end
+
+  def test_native_policy_set_after_unconstrained_add_is_applied
+    m = Curl::Multi.new
+    easy = Curl::Easy.new(TestServlet.url)
+    m.add(easy)
+    begin
+      easy.network_policy = :public
+    rescue NotImplementedError
+      omit('network_policy=:public requires CURLOPT_OPENSOCKETFUNCTION support')
+    end
+
+    m.perform
+
+    assert_match(/127\.0\.0\.1/, easy.unsafe_destination_error)
   ensure
     m.close if m
   end

data/tests/tc_curl_native_coverage.rb

@@ -106,6 +106,63 @@ class TestCurbCurlNativeCoverage < Test::Unit::TestCase
     easy.close if defined?(easy) && easy
   end
 
+  [:clone, :dup].each do |copy_method|
+    [:on_body, :on_header, :on_progress, :on_debug, :on_complete].each do |callback|
+      define_method("test_#{copy_method}_during_multipart_#{callback}_detaches_form") do
+        easy = Curl::Easy.new(TestServlet.url)
+        easy.multipart_form_post = true
+        easy.verbose = true if callback == :on_debug
+        copies = []
+        easy.public_send(callback) do |*args|
+          if copies.empty?
+            # The public option can change while the native form is attached.
+            easy.multipart_form_post = false
+            copies << easy.public_send(copy_method)
+          end
+          [:on_body, :on_header].include?(callback) ? args.first.bytesize : true
+        end
+
+        easy.http_post(Curl::PostField.content('original', 'temporary-form'))
+        assert_equal 1, copies.size, "#{callback} must run during the multipart request"
+        copy = copies.first
+        copy.public_send(callback) # Remove the inherited callback.
+        copy.verbose = false
+
+        # Plain perform must not access or resend the original's freed form.
+        copy.perform
+        easy.public_send(callback)
+        easy.verbose = false
+        easy.perform
+        assert_equal easy.body_str, copy.body_str
+        assert_no_match(/temporary-form|name="original"/, copy.body_str)
+
+        copy.multipart_form_post = true
+        copy.http_post(Curl::PostField.content('replacement', 'fresh-form'))
+        assert_match(/name="replacement"/, copy.body_str)
+        assert_match(/fresh-form/, copy.body_str)
+        assert_no_match(/temporary-form/, copy.body_str)
+      ensure
+        copies&.each(&:close)
+        easy&.close
+      end
+    end
+
+    define_method("test_#{copy_method}_preserves_post_after_multipart_cleanup") do
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.multipart_form_post = true
+      easy.http_post(Curl::PostField.content('original', 'temporary-form'))
+      easy.multipart_form_post = false
+      easy.post_body = 'ordinary=post'
+
+      copy = easy.public_send(copy_method)
+      copy.perform
+      assert_equal "POST\nordinary=post", copy.body_str
+    ensure
+      copy&.close
+      easy&.close
+    end
+  end
+
   def test_native_accessors_round_trip
     easy = Curl::Easy.new(TestServlet.url)