curb 1.3.7 → 1.4.0

data/ext/curb_multi.h

@@ -21,6 +21,10 @@ typedef struct {
   char allow_close_during_perform;
   CURLM *handle;
   struct st_table *attached;
+  /* Bumped on every add and stamped onto the easy (multi_attachment_generation),
+   * so "attached after point X" is a comparison instead of a table snapshot.
+   * Monotonic for the object's lifetime; never reset. */
+  unsigned long attachment_sequence;
 } ruby_curl_multi;
 
 extern VALUE cCurlMulti;

data/ext/curb_postfield.c

@@ -468,7 +468,10 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
     name = rbcpf->name;
     if (TYPE(name) != T_STRING) {
       if (rb_respond_to(name, rb_intern("to_s")))
-        name = rb_funcall(name, rb_intern("to_s"), 0);
+        /* rb_obj_as_string always yields a String, even if #to_s misbehaves
+         * and returns a non-String; a raw rb_funcall result could later be
+         * handed to RSTRING_PTR/RSTRING_LEN and crash. */
+        name = rb_obj_as_string(name);
       else
         name = Qnil;
     }
@@ -481,6 +484,33 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
   /* Force field name to UTF-8 before escaping */
   VALUE name_utf8 = rb_str_export_to_enc(name, rb_utf8_encoding());
 
+  /* Resolve and coerce the content before creating the curl handle: the
+   * content proc, #to_s and the UTF-8 export can all raise, which would
+   * otherwise leak the handle. */
+  VALUE tmpcontent = Qnil;
+  if (rbcpf->content_proc != Qnil) {
+    tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
+  } else if (rbcpf->content != Qnil) {
+    tmpcontent = rbcpf->content;
+  } else if (rbcpf->local_file != Qnil) {
+    tmpcontent = rbcpf->local_file;
+  } else if (rbcpf->remote_file != Qnil) {
+    tmpcontent = rbcpf->remote_file;
+  } else {
+    tmpcontent = rb_str_new2("");
+  }
+  if (TYPE(tmpcontent) != T_STRING) {
+    if (rb_respond_to(tmpcontent, rb_intern("to_s")))
+      /* rb_obj_as_string always yields a String, even if #to_s misbehaves */
+      tmpcontent = rb_obj_as_string(tmpcontent);
+    else
+      rb_raise(rb_eRuntimeError,
+               "postfield(%"PRIsVALUE") is not a string and does not respond_to to_s",
+               name);
+  }
+  /* Force content to UTF-8 before escaping */
+  VALUE content_utf8 = rb_str_export_to_enc(tmpcontent, rb_utf8_encoding());
+
 #ifdef HAVE_CURL_EASY_ESCAPE
   curl_handle = curl_easy_init();
   if (!curl_handle) {
@@ -499,38 +529,8 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
 #endif
 
   VALUE escd_name = rb_str_new2(tmpchrs);
-#ifdef HAVE_CURL_EASY_ESCAPE
-  curl_free(tmpchrs);
-#else
   curl_free(tmpchrs);
-#endif
 
-  VALUE tmpcontent = Qnil;
-  if (rbcpf->content_proc != Qnil) {
-    tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-  } else if (rbcpf->content != Qnil) {
-    tmpcontent = rbcpf->content;
-  } else if (rbcpf->local_file != Qnil) {
-    tmpcontent = rbcpf->local_file;
-  } else if (rbcpf->remote_file != Qnil) {
-    tmpcontent = rbcpf->remote_file;
-  } else {
-    tmpcontent = rb_str_new2("");
-  }
-  if (TYPE(tmpcontent) != T_STRING) {
-    if (rb_respond_to(tmpcontent, rb_intern("to_s")))
-      tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
-    else {
-#ifdef HAVE_CURL_EASY_ESCAPE
-      curl_easy_cleanup(curl_handle);
-#endif
-      rb_raise(rb_eRuntimeError,
-               "postfield(%s) is not a string and does not respond_to to_s",
-               RSTRING_PTR(escd_name));
-    }
-  }
-  /* Force content to UTF-8 before escaping */
-  VALUE content_utf8 = rb_str_export_to_enc(tmpcontent, rb_utf8_encoding());
 #ifdef HAVE_CURL_EASY_ESCAPE
   tmpchrs = curl_easy_escape(curl_handle, StringValuePtr(content_utf8), (int)RSTRING_LEN(content_utf8));
   if (!tmpchrs) {

data/ext/extconf.rb

@@ -260,6 +260,7 @@ have_constant "curl_version_idn"
 have_constant "curl_version_sspi"
 have_constant "curl_version_conv"
 have_constant "curl_version_http2"
+have_constant "curl_version_threadsafe"
 have_constant "curlproxy_http"
 have_constant "curlproxy_socks4"
 have_constant "curlproxy_socks4a"
@@ -704,6 +705,7 @@ have_func('rb_fiber_scheduler_current', 'ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_io_wait', 'ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_io_select', 'ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_kernel_sleep', 'ruby/fiber/scheduler.h')
+have_func('rb_ext_ractor_safe')
 have_func('rb_io_stdio_file')
 have_func('curl_multi_wait')
 have_func('curl_multi_socket_action')
@@ -714,6 +716,10 @@ have_func('curl_multi_socket')
 have_func('curl_multi_timer_callback')
 have_constant 'curlmopt_socketfunction'
 have_constant 'curlmopt_timerfunction'
+# Kernel event queues let the socket-action loop wait on one descriptor for
+# every libcurl socket under a fiber scheduler.
+have_header('sys/epoll.h') && have_func('epoll_create1', 'sys/epoll.h')
+have_header('sys/event.h') && have_func('kqueue', ['sys/types.h', 'sys/event.h'])
 have_func('curl_easy_duphandle')
 
 # Optional: enable verbose socket-action debug logging.

data/lib/curl/easy.rb

@@ -3,13 +3,20 @@ require 'curl/download'
 module Curl
   class Easy
     class << self
+      def deferred_multi_close_state
+        Curl.__send__(:ractor_local_state)
+      end
+      private :deferred_multi_close_state
+
       def deferred_multi_close_mutex
-        @deferred_multi_close_mutex ||= Mutex.new
+        state = deferred_multi_close_state
+        state[:deferred_multi_close_mutex] ||= Mutex.new
       end
 
       def deferred_multi_closes
+        state = deferred_multi_close_state
         deferred_multi_close_mutex.synchronize do
-          (@deferred_multi_closes ||= []).dup
+          (state[:deferred_multi_closes] ||= []).dup
         end
       end
 
@@ -34,27 +41,29 @@ module Curl
       end
 
       def defer_multi_close(multi, easy, owner: Thread.current)
+        state = deferred_multi_close_state
         deferred_multi_close_mutex.synchronize do
-          @deferred_multi_closes ||= []
-          return if @deferred_multi_closes.any? { |entry| entry[:multi].equal?(multi) }
+          state[:deferred_multi_closes] ||= []
+          return if state[:deferred_multi_closes].any? { |entry| entry[:multi].equal?(multi) }
 
           multi.instance_variable_set(:@deferred_close, true)
-          @deferred_multi_closes << { multi: multi, easy: easy, owner: owner }
+          state[:deferred_multi_closes] << { multi: multi, easy: easy, owner: owner }
         end
       end
 
       def flush_deferred_multi_closes(all_threads: false)
+        state = deferred_multi_close_state
         pending = deferred_multi_close_mutex.synchronize do
-          @deferred_multi_closes ||= []
+          deferred_closes = (state[:deferred_multi_closes] ||= [])
 
           if all_threads
-            @deferred_multi_closes.shift(@deferred_multi_closes.length)
+            deferred_closes.shift(deferred_closes.length)
           else
             owner = Thread.current
             remaining = []
             current = []
 
-            @deferred_multi_closes.each do |entry|
+            deferred_closes.each do |entry|
               if entry[:owner].equal?(owner)
                 current << entry
               else
@@ -62,7 +71,7 @@ module Curl
               end
             end
 
-            @deferred_multi_closes = remaining
+            state[:deferred_multi_closes] = remaining
             current
           end
         end

data/lib/curl.rb

@@ -8,6 +8,19 @@ require 'uri'
 
 # expose shortcut methods
 module Curl
+  # Module/class instance variables cannot be read or written by non-main
+  # Ractors, even when the value itself would otherwise be safe. Keep curb's
+  # mutable Ruby-side configuration in storage owned by the current Ractor.
+  # Older Rubies retain the historical process-wide state.
+  def self.ractor_local_state
+    if defined?(Ractor) && Ractor.respond_to?(:current) &&
+       Ractor.current.respond_to?(:[]) && Ractor.current.respond_to?(:[]=)
+      Ractor.current[:__curb_ractor_local_state] ||= {}
+    else
+      @legacy_local_state ||= {}
+    end
+  end
+
   class SafetyConfig
     DEFAULT_PROTOCOLS = [:http, :https].freeze
 
@@ -176,12 +189,12 @@ module Curl
   def self.safe!
     config = SafetyConfig.new
     yield config if block_given?
-    @safety_config = config
+    ractor_local_state[:safety_config] = config
     bump_safety_generation!
   end
 
   def self.apply_safety!(easy)
-    config = @safety_config
+    config = ractor_local_state[:safety_config]
     override = safety_override_for(easy)
     return easy unless config || override
 
@@ -215,12 +228,12 @@ module Curl
   end
 
   def self.clear_safe!
-    @safety_config = nil
+    ractor_local_state[:safety_config] = nil
     bump_safety_generation!
   end
 
   def self.safety_active_for?(easy)
-    !!(@safety_config || safety_override_for(easy))
+    !!(ractor_local_state[:safety_config] || safety_override_for(easy))
   end
 
   def self.safety_signature_for(easy)
@@ -240,11 +253,11 @@ module Curl
   end
 
   def self.safety_generation
-    @safety_generation ||= 0
+    ractor_local_state[:safety_generation] ||= 0
   end
 
   def self.bump_safety_generation!
-    @safety_generation = safety_generation + 1
+    ractor_local_state[:safety_generation] = safety_generation + 1
   end
 
   def self.safety_protocol_intersection(base_protocols, override_protocols)
@@ -395,7 +408,8 @@ module Curl
     easy.set(Curl::CURLOPT_NOPROXY, "*") if Curl.const_defined?(:CURLOPT_NOPROXY)
   end
 
-  private_class_method :apply_safety!, :clear_safe!, :safety_active_for?,
+  private_class_method :ractor_local_state,
+                       :apply_safety!, :clear_safe!, :safety_active_for?,
                        :safety_signature_for, :safety_override_for,
                        :safety_generation, :bump_safety_generation!,
                        :safety_protocol_intersection,
@@ -480,23 +494,44 @@ module Curl
     end
   end
 
+  # Wakes the waiters whose transfers finished since the last call. Completions
+  # are queued by the on_complete wrapper in perform_with_scheduler, so each
+  # drive-loop pass costs O(new completions) rather than O(all waiters).
   def self.release_scheduler_waiters(state)
-    source_id = deferred_exception_source_id(state)
+    completed = state[:completed]
+    return if completed.empty?
 
-    state[:waiters].each do |easy_id, waiter|
-      next if source_id == easy_id
+    source_id = deferred_exception_source_id(state)
+    retained = nil
+
+    until completed.empty?
+      easy_id, waiter = completed.shift
+      # A waiter whose perform already returned (it raised) is no longer
+      # blocked on this completion; waking its fiber would be spurious.
+      next unless state[:waiters][easy_id].equal?(waiter)
+
+      if source_id == easy_id
+        # The transfer that raised the deferred exception gets that error via
+        # release_scheduler_error. Keep it queued in case the source changes.
+        (retained ||= []) << [easy_id, waiter]
+        next
+      end
 
-      complete_scheduler_waiter(waiter) if waiter[:completed]
+      complete_scheduler_waiter(waiter)
     end
+
+    completed.concat(retained) if retained
   end
 
   def self.perform_with_scheduler(easy)
     state = scheduler_state
+    easy_id = easy.object_id
     waiter = {completed: false, done: false, error: nil, fiber: nil, scheduler: Fiber.scheduler}
-    state[:waiters][easy.object_id] = waiter
+    state[:waiters][easy_id] = waiter
     previous_complete = easy.on_complete do |completed_easy|
       previous_complete.call(completed_easy) if previous_complete
       waiter[:completed] = true
+      state[:completed] << [easy_id, waiter]
     end
 
     state[:pending] << easy
@@ -533,6 +568,8 @@ module Curl
         driver_running: false,
         error: nil,
         waiters: {},
+        # [easy object_id, waiter] pairs completed but not yet woken
+        completed: [],
       }
       Thread.current.thread_variable_set(:curb_scheduler_state, state)
       state

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,8 +1,14 @@
 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
   def test_global_reset
     Curl.get($TEST_URL)
@@ -560,7 +566,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 +768,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 +796,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
 
@@ -245,14 +248,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_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