curb 1.3.1 → 1.3.3

data/ext/curb_multi.c

@@ -28,6 +28,7 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#include <stdint.h>
 #include <stdarg.h>
 
 /*
@@ -52,9 +53,7 @@
   #include <fcntl.h>
 #endif
 
-#if 0 /* disabled curl_multi_wait in favor of scheduler-aware fdsets */
-#include <stdint.h>  /* for intptr_t */
-
+#if defined(HAVE_CURL_MULTI_WAIT) && !defined(HAVE_RB_THREAD_FD_SELECT)
 struct wait_args {
   CURLM *handle;
   long timeout_ms;
@@ -95,6 +94,34 @@ static void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy);
 static VALUE ruby_curl_multi_mark_closed(VALUE self);
 static VALUE ruby_curl_multi_alloc(VALUE klass);
 static VALUE ruby_curl_multi_initialize(VALUE self);
+static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self);
+#if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
+static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE self);
+#endif
+
+static ruby_curl_multi *ruby_curl_multi_pointer_if_compatible(VALUE multi_val) {
+  if (NIL_P(multi_val) || !RB_TYPE_P(multi_val, T_DATA)) {
+    return NULL;
+  }
+
+#if defined(RTYPEDDATA_P) && defined(RTYPEDDATA_TYPE) && defined(RTYPEDDATA_DATA)
+  if (!RTYPEDDATA_P(multi_val)) {
+    return NULL;
+  }
+
+  if (RTYPEDDATA_TYPE(multi_val) != &ruby_curl_multi_data_type) {
+    return NULL;
+  }
+
+  return (ruby_curl_multi *)RTYPEDDATA_DATA(multi_val);
+#else
+  if (!rb_typeddata_is_kind_of(multi_val, &ruby_curl_multi_data_type)) {
+    return NULL;
+  }
+
+  return DATA_PTR(multi_val);
+#endif
+}
 
 static VALUE callback_exception(VALUE did_raise, VALUE exception) {
   // TODO: we could have an option to enable exception reporting
@@ -342,6 +369,9 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
   rbcm->active = 0;
   rbcm->running = 0;
   rbcm->closed = 0;
+  rbcm->perform_active = 0;
+  rbcm->callback_active = 0;
+  rbcm->allow_close_during_perform = 0;
 
   if (rbcm->attached) {
     st_free_table(rbcm->attached);
@@ -537,11 +567,21 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
   CURLMcode mcode;
   ruby_curl_easy *rbce;
   ruby_curl_multi *rbcm;
+  ruby_curl_multi *existing_rbcm;
 
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
   TypedData_Get_Struct(easy, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
   ruby_curl_multi_ensure_handle(rbcm);
 
+  if (rb_curl_multi_has_easy(rbcm, rbce)) {
+    return self;
+  }
+
+  existing_rbcm = ruby_curl_multi_pointer_if_compatible(rbce->multi);
+  if (existing_rbcm && existing_rbcm != rbcm && rb_curl_multi_has_easy(existing_rbcm, rbce)) {
+    rb_raise(rb_eRuntimeError, "Cannot add an active Curl::Easy handle to another Curl::Multi");
+  }
+
   /* setup the easy handle */
   ruby_curl_easy_setup( rbce );
 
@@ -797,6 +837,8 @@ static VALUE rb_curl_multi_run_completion_callbacks(VALUE argp) {
   VALUE did_raise = rb_hash_new();
   long redirect_count;
 
+  args->rbcm->callback_active = 1;
+
   easy_callback_error = take_easy_callback_error_if_any(args->easy);
   if (!NIL_P(easy_callback_error)) {
     stash_multi_exception_if_unset(args->self, easy_callback_error, args->easy);
@@ -877,6 +919,10 @@ static VALUE rb_curl_multi_finish_completion_callbacks(VALUE argp) {
     args->rbce->callback_active = 0;
   }
 
+  if (args->rbcm) {
+    args->rbcm->callback_active = 0;
+  }
+
   if (args->rbce->multi == args->self && !rb_curl_multi_has_easy(args->rbcm, args->rbce)) {
     args->rbce->multi = Qnil;
   }
@@ -1072,6 +1118,41 @@ static VALUE fiber_io_wait_protected(VALUE argp) {
 }
 #endif
 
+#if defined(RB_INTEGER_TYPE_P)
+#define CURB_INTEGER_P(value) RB_INTEGER_TYPE_P(value)
+#else
+#define CURB_INTEGER_P(value) (FIXNUM_P(value) || RB_TYPE_P((value), T_BIGNUM))
+#endif
+
+static int multi_socket_wait_events_for_curl_poll(int what) {
+  if (what == CURL_POLL_IN) return RB_WAITFD_IN;
+  if (what == CURL_POLL_OUT) return RB_WAITFD_OUT;
+  if (what == CURL_POLL_INOUT) return RB_WAITFD_IN | RB_WAITFD_OUT;
+  return RB_WAITFD_IN | RB_WAITFD_OUT;
+}
+
+static int multi_socket_cselect_flags_for_curl_poll(int what) {
+  int flags = 0;
+
+  if (what == CURL_POLL_IN || what == CURL_POLL_INOUT) flags |= CURL_CSELECT_IN;
+  if (what == CURL_POLL_OUT || what == CURL_POLL_INOUT) flags |= CURL_CSELECT_OUT;
+  if (flags == 0) flags = CURL_CSELECT_IN | CURL_CSELECT_OUT;
+
+  return flags;
+}
+
+static int multi_socket_cselect_flags_for_wait_events(int events) {
+  int flags = 0;
+
+  if (events & RB_WAITFD_IN) flags |= CURL_CSELECT_IN;
+  if (events & RB_WAITFD_OUT) flags |= CURL_CSELECT_OUT;
+#ifdef RB_WAITFD_PRI
+  if (events & RB_WAITFD_PRI) flags |= CURL_CSELECT_ERR;
+#endif
+
+  return flags;
+}
+
 static void multi_socket_forget_fd(multi_socket_ctx *ctx, int fd) {
   st_data_t key = (st_data_t)fd;
   st_data_t rec;
@@ -1236,6 +1317,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 
     int did_timeout = 0;
     int any_ready = 0;
+    int ready_flags = 0;
 
     int handled_wait = 0;
     if (count_tracked > 1) {
@@ -1270,10 +1352,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
         if (scheduler != Qnil) {
           int events = 0;
           if (wait_fd >= 0) {
-            if (wait_what == CURL_POLL_IN) events = RB_WAITFD_IN;
-            else if (wait_what == CURL_POLL_OUT) events = RB_WAITFD_OUT;
-            else if (wait_what == CURL_POLL_INOUT) events = RB_WAITFD_IN|RB_WAITFD_OUT;
-            else events = RB_WAITFD_IN|RB_WAITFD_OUT;
+            events = multi_socket_wait_events_for_curl_poll(wait_what);
           }
           double timeout_s = (double)tv.tv_sec + ((double)tv.tv_usec / 1e6);
           VALUE timeout = rb_float_new(timeout_s);
@@ -1305,8 +1384,21 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
                 did_timeout = 1;
                 any_ready = 0;
               } else {
-                any_ready = (ready != Qfalse);
+                any_ready = (ready != Qfalse && !NIL_P(ready));
                 did_timeout = !any_ready;
+                if (any_ready) {
+                  if (ready == Qtrue) {
+                    ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
+                  } else if (CURB_INTEGER_P(ready)) {
+                    ready_flags = multi_socket_cselect_flags_for_wait_events(NUM2INT(ready));
+                    if (ready_flags == 0) {
+                      any_ready = 0;
+                      did_timeout = 1;
+                    }
+                  } else {
+                    ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
+                  }
+                }
               }
             }
           }
@@ -1316,10 +1408,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 #endif
 #if defined(HAVE_RB_WAIT_FOR_SINGLE_FD)
       if (!handled_wait && wait_fd >= 0) {
-        int ev = 0;
-        if (wait_what == CURL_POLL_IN) ev = RB_WAITFD_IN;
-        else if (wait_what == CURL_POLL_OUT) ev = RB_WAITFD_OUT;
-        else if (wait_what == CURL_POLL_INOUT) ev = RB_WAITFD_IN|RB_WAITFD_OUT;
+        int ev = multi_socket_wait_events_for_curl_poll(wait_what);
         int rc = rb_wait_for_single_fd(wait_fd, ev, &tv);
         curb_debugf("[curb.socket] rb_wait_for_single_fd rc=%d fd=%d ev=%d", rc, wait_fd, ev);
         if (rc < 0) {
@@ -1328,6 +1417,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
         }
         any_ready = (rc != 0);
         did_timeout = (rc == 0);
+        if (any_ready) ready_flags = multi_socket_cselect_flags_for_wait_events(rc);
         handled_wait = 1;
       }
 #endif
@@ -1351,6 +1441,11 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
         }
         any_ready = (rc > 0);
         did_timeout = (rc == 0);
+        if (any_ready && wait_fd >= 0) {
+          if (rb_fd_isset(wait_fd, &rfds)) ready_flags |= CURL_CSELECT_IN;
+          if (rb_fd_isset(wait_fd, &wfds)) ready_flags |= CURL_CSELECT_OUT;
+          if (rb_fd_isset(wait_fd, &efds)) ready_flags |= CURL_CSELECT_ERR;
+        }
         rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
       }
     } else { /* count_tracked == 0 */
@@ -1368,10 +1463,8 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
       if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
     } else if (any_ready) {
       if (count_tracked == 1 && wait_fd >= 0) {
-        int flags = 0;
-        if (wait_what == CURL_POLL_IN || wait_what == CURL_POLL_INOUT) flags |= CURL_CSELECT_IN;
-        if (wait_what == CURL_POLL_OUT || wait_what == CURL_POLL_INOUT) flags |= CURL_CSELECT_OUT;
-        flags |= CURL_CSELECT_ERR;
+        int flags = ready_flags;
+        if (flags == 0) flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
 #if CURB_SOCKET_DEBUG
         {
           char b[32];
@@ -1415,7 +1508,7 @@ static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
   return Qnil;
 }
 
-VALUE ruby_curl_multi_socket_perform(int argc, VALUE *argv, VALUE self) {
+static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE self) {
   ruby_curl_multi *rbcm;
   VALUE block = Qnil;
   rb_scan_args(argc, argv, "0&", &block);
@@ -1445,7 +1538,11 @@ VALUE ruby_curl_multi_socket_perform(int argc, VALUE *argv, VALUE self) {
   /* finalize */
   rb_curl_multi_read_info(self, rbcm->handle);
   rb_curl_multi_yield_if_given(self, block);
-  if (cCurlMutiAutoClose == 1) rb_funcall(self, rb_intern("_autoclose"), 0);
+  if (cCurlMutiAutoClose == 1) {
+    rbcm->allow_close_during_perform = 1;
+    rb_funcall(self, rb_intern("_autoclose"), 0);
+    rbcm->allow_close_during_perform = 0;
+  }
 
   return Qtrue;
 }
@@ -1493,6 +1590,14 @@ static VALUE curb_select(void *args) {
   int rc = select(set->maxfd, set->fdread, set->fdwrite, set->fdexcep, set->tv);
   return INT2FIX(rc);
 }
+
+#ifdef HAVE_RB_THREAD_CALL_WITHOUT_GVL
+static void *curb_select_without_gvl(void *args) {
+  struct _select_set* set = args;
+  int rc = select(set->maxfd, set->fdread, set->fdwrite, set->fdexcep, set->tv);
+  return (void *)(intptr_t)rc;
+}
+#endif
 #endif
 
 /*
@@ -1510,7 +1615,7 @@ static VALUE curb_select(void *args) {
  *
  * Run multi handles, looping selecting when data can be transfered
  */
-VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
+static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
   CURLMcode mcode;
   ruby_curl_multi *rbcm;
   int maxfd, rc = -1;
@@ -1691,7 +1796,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
         rb_fd_term(&efds);
       }
 #elif defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
-      rc = (int)(VALUE) rb_thread_call_without_gvl((void *(*)(void *))curb_select, &fdset_args, RUBY_UBF_IO, 0);
+      rc = (int)(intptr_t) rb_thread_call_without_gvl(curb_select_without_gvl, &fdset_args, RUBY_UBF_IO, 0);
 #elif HAVE_RB_THREAD_BLOCKING_REGION
       rc = rb_thread_blocking_region(curb_select, &fdset_args, RUBY_UBF_IO, 0);
 #else
@@ -1725,11 +1830,66 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
   rb_curl_multi_read_info( self, rbcm->handle );
   rb_curl_multi_yield_if_given(self, block);
   if (cCurlMutiAutoClose  == 1) {
+    rbcm->allow_close_during_perform = 1;
     rb_funcall(self, rb_intern("_autoclose"), 0);
+    rbcm->allow_close_during_perform = 0;
   }
   return Qtrue;
 }
 
+struct multi_perform_call_args {
+  int argc;
+  VALUE *argv;
+  VALUE self;
+  VALUE result;
+  VALUE (*func)(int, VALUE *, VALUE);
+};
+
+static VALUE ruby_curl_multi_perform_guard_body(VALUE argp) {
+  struct multi_perform_call_args *args = (struct multi_perform_call_args *)argp;
+  args->result = args->func(args->argc, args->argv, args->self);
+  return args->result;
+}
+
+static VALUE ruby_curl_multi_perform_guard_ensure(VALUE self) {
+  ruby_curl_multi *rbcm;
+  TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
+  rbcm->perform_active = 0;
+  rbcm->callback_active = 0;
+  rbcm->allow_close_during_perform = 0;
+  return Qnil;
+}
+
+static VALUE ruby_curl_multi_with_perform_guard(int argc, VALUE *argv, VALUE self, VALUE (*func)(int, VALUE *, VALUE)) {
+  ruby_curl_multi *rbcm;
+  struct multi_perform_call_args args;
+
+  TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
+  if (rbcm->perform_active) {
+    rb_raise(rb_eRuntimeError, "Cannot recursively perform an active Curl::Multi handle");
+  }
+
+  rbcm->perform_active = 1;
+  args.argc = argc;
+  args.argv = argv;
+  args.self = self;
+  args.result = Qnil;
+  args.func = func;
+
+  return rb_ensure(ruby_curl_multi_perform_guard_body, (VALUE)&args,
+                   ruby_curl_multi_perform_guard_ensure, self);
+}
+
+VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
+  return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_perform_impl);
+}
+
+#if defined(HAVE_CURL_MULTI_SOCKET_ACTION) && defined(HAVE_CURLMOPT_SOCKETFUNCTION) && defined(HAVE_CURLMOPT_TIMERFUNCTION) && defined(HAVE_RB_THREAD_FD_SELECT) && !defined(_WIN32)
+VALUE ruby_curl_multi_socket_perform(int argc, VALUE *argv, VALUE self) {
+  return ruby_curl_multi_with_perform_guard(argc, argv, self, ruby_curl_multi_socket_perform_impl);
+}
+#endif
+
 /*
  * call-seq:
  *
@@ -1740,6 +1900,11 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 VALUE ruby_curl_multi_close(VALUE self) {
   ruby_curl_multi *rbcm;
   TypedData_Get_Struct(self, ruby_curl_multi, &ruby_curl_multi_data_type, rbcm);
+
+  if ((rbcm->perform_active || rbcm->callback_active) && !rbcm->allow_close_during_perform) {
+    rb_raise(rb_eRuntimeError, "Cannot close an active Curl::Multi handle during perform");
+  }
+
   rb_curl_multi_detach_all(rbcm);
 
   if (rbcm->handle) {

data/ext/curb_multi.h

@@ -16,6 +16,9 @@ typedef struct {
   int active;
   int running;
   char closed;
+  char perform_active;
+  char callback_active;
+  char allow_close_during_perform;
   CURLM *handle;
   struct st_table *attached;
 } ruby_curl_multi;

data/ext/curb_postfield.c

@@ -183,6 +183,7 @@ static void curl_postfield_mark(void *ptr) {
     rb_gc_mark(rbcpf->name);
     rb_gc_mark(rbcpf->content);
     rb_gc_mark(rbcpf->content_type);
+    rb_gc_mark(rbcpf->content_proc);
     rb_gc_mark(rbcpf->local_file);
     rb_gc_mark(rbcpf->remote_file);
     rb_gc_mark(rbcpf->buffer_str);

data/tests/bug_curb_easy_blocks_ruby_threads.rb

@@ -4,7 +4,7 @@ class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
   include BugTestServerSetupTeardown
 
   def setup
-    @port = 9999
+    @port = unused_local_port
     @response_proc = lambda do|res|
       sleep 0.5
       res.body = "hi"
@@ -19,7 +19,7 @@ class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
 
     5.times do |i|
       t = Thread.new do
-        c = Curl::Easy.perform('http://127.0.0.1:9999/test')
+        c = Curl::Easy.perform("http://127.0.0.1:#{@port}/test")
         c.header_str
       end
       threads << t
@@ -35,7 +35,7 @@ class BugTestInstancePostDiffersFromClassPost < Test::Unit::TestCase
     timer = Time.now
     single_responses = []
     5.times do |i|
-      c = Curl::Easy.perform('http://127.0.0.1:9999/test')
+      c = Curl::Easy.perform("http://127.0.0.1:#{@port}/test")
       single_responses << c.header_str
     end
     

data/tests/bug_follow_redirect_288.rb

@@ -4,7 +4,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
   include BugTestServerSetupTeardown
 
   def setup
-    @port = 9999
+    @port = unused_local_port
     super
     @server.mount_proc("/redirect_to_test") do|req,res|
       res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, "/test")
@@ -13,7 +13,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
 
   def test_follow_redirect_with_no_redirect
 
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
     did_call_redirect = false
     c.on_redirect do|x|
       did_call_redirect = true
@@ -22,7 +22,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
 
     assert !did_call_redirect, "should reach this point redirect should not have been called"
 
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/test")
     did_call_redirect = false
     c.on_redirect do|x|
       did_call_redirect = true
@@ -33,7 +33,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
     assert_equal 0, c.redirect_count
     assert !did_call_redirect, "should reach this point redirect should not have been called"
 
-    c = Curl::Easy.new('http://127.0.0.1:9999/redirect_to_test')
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/redirect_to_test")
     did_call_redirect = false
     c.on_redirect do|x|
       did_call_redirect = true
@@ -43,7 +43,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
 
     assert did_call_redirect, "we should have called on_redirect"
 
-    c = Curl::Easy.new('http://127.0.0.1:9999/redirect_to_test')
+    c = Curl::Easy.new("http://127.0.0.1:#{@port}/redirect_to_test")
     did_call_redirect = false
     c.follow_location = true
     # NOTE: while this API is not supported by libcurl e.g. there is no redirect function callback in libcurl we could 
@@ -57,7 +57,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
 
     assert did_call_redirect, "we should have called on_redirect"
 
-    c.url = 'http://127.0.0.1:9999/test'
+    c.url = "http://127.0.0.1:#{@port}/test"
     c.perform
     assert_equal 0, c.redirect_count
     assert_equal 200, c.response_code
@@ -65,7 +65,7 @@ class BugFollowRedirect288 < Test::Unit::TestCase
     puts "checking for raise support"
     did_raise = false
     begin
-      c = Curl::Easy.new('http://127.0.0.1:9999/redirect_to_test')
+      c = Curl::Easy.new("http://127.0.0.1:#{@port}/redirect_to_test")
       did_call_redirect = false
       c.on_redirect do|x|
         raise "raise"

data/tests/bug_raise_on_callback.rb

@@ -4,16 +4,17 @@ class BugRaiseOnCallback < Test::Unit::TestCase
   include BugTestServerSetupTeardown
 
   def setup
-    @port = 9999
+    @port = unused_local_port
     super
   end
 
   def test_on_complte
-    c = Curl::Easy.new('http://127.0.0.1:9999/test')
+    url = "http://127.0.0.1:#{@port}/test"
+    c = Curl::Easy.new(url)
     did_raise = false
     begin
       c.on_complete do|x|
-        assert_equal 'http://127.0.0.1:9999/test', x.url
+        assert_equal url, x.url
         raise "error complete" # this will get swallowed
       end
       c.perform

data/tests/helper.rb

@@ -206,6 +206,13 @@ class TestServlet < WEBrick::HTTPServlet::AbstractServlet
 end
 
 module BugTestServerSetupTeardown
+  def unused_local_port
+    socket = TCPServer.new('127.0.0.1', 0)
+    socket.addr[1]
+  ensure
+    socket.close if socket
+  end
+
   def setup
     @port ||= 9992
     @server = WEBrick::HTTPServer.new(:Port => @port, :Logger => WEBRICK_TEST_LOG, :AccessLog => [])

data/tests/tc_curl_easy.rb

@@ -123,6 +123,50 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "", easy.body_str.to_s
   end
 
+  def test_head_request_restores_easy_state_after_callback_exception
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.on_complete { raise "head complete blew up" }
+
+    error = assert_raise(Curl::Err::AbortedByCallbackError) { easy.http("HEAD") }
+    assert_equal "head complete blew up", error.message
+
+    easy.on_complete { |_curl| }
+    easy.perform
+
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_patch_request_does_not_leak_custom_method_to_next_perform
+    easy = Curl::Easy.new(TestServlet.url)
+
+    easy.http_patch("a=b")
+    assert_equal "PATCH\na=b", easy.body_str
+
+    easy.perform
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_put_request_does_not_leak_custom_method_to_next_perform
+    easy = Curl::Easy.new(TestServlet.url)
+
+    easy.http_put("payload")
+    assert_equal "PUT\npayload", easy.body_str
+
+    easy.perform
+    assert_equal "GET", easy.body_str
+  end
+
+  def test_failed_put_data_setup_does_not_leave_easy_in_upload_mode
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.headers = ["X-Test: true"]
+
+    assert_raise(RuntimeError) { easy.put_data = "payload" }
+
+    easy.headers = {}
+    easy.perform
+    assert_equal "GET", easy.body_str
+  end
+
   def test_perform_releases_failed_implicit_multi_without_follow_up_easy_perform
     Curl::Easy.flush_deferred_multi_closes
     assert_equal 0, Curl::Easy.deferred_multi_closes.length
@@ -1301,6 +1345,24 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "POST\nfoo=bar", curl.body_str
   end
 
+  def test_multipart_patch_build_failure_restores_easy_request_state
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    field = Curl::PostField.content('document_id', '5')
+
+    field.name = nil
+    error = assert_raise(Curl::Err::InvalidPostFieldError) do
+      # The first field allocates native multipart form state before the second field raises.
+      curl.http_patch(Curl::PostField.content('keep', 'allocated'), field)
+    end
+    assert_match(/Cannot post unnamed field/, error.message)
+
+    curl.multipart_form_post = false
+    curl.perform
+
+    assert_equal 'GET', curl.body_str
+  end
+
   def test_delete_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_delete
@@ -1358,6 +1420,44 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match(/message$/, curl.body_str)
   end
 
+  def test_put_data_from_to_s_object
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = :message
+
+    curl.perform
+
+    assert_equal "PUT\nmessage", curl.body_str
+  end
+
+  def test_put_data_read_exception_sets_result_and_releases_callback_state
+    error_class = Class.new(StandardError)
+    reader_class = Class.new do
+      define_method(:read) do |_len|
+        raise error_class, 'upload read failed'
+      end
+
+      def seek(_offset, _whence = SEEK_SET)
+        0
+      end
+
+      def stat
+        Struct.new(:size).new(1)
+      end
+    end
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = reader_class.new
+
+    error = assert_raise(error_class) { curl.perform }
+    assert_equal 'upload read failed', error.message
+    assert_not_equal 0, curl.last_result
+
+    curl.url = TestServlet.url
+    curl.http_get
+
+    assert_equal 'GET', curl.body_str
+  end
+
   # https://github.com/taf2/curb/issues/101
   def test_put_data_null_bytes
     curl = Curl::Easy.new(TestServlet.url)
@@ -1460,6 +1560,10 @@ class TestCurbCurlEasy < Test::Unit::TestCase
       # header value and encoding; skip the NTLM-specific assertion.
       return
     end
+    # curl 8.20.0 disables NTLM by default and plans to remove it in
+    # September 2026; libcurl silently downgrades to Basic when NTLM is
+    # unavailable, so skip the NTLM-specific assertion in that case.
+    return unless Curl.ntlm?
     curl = Curl::Easy.new(TestServlet.url)
     curl.username = "foo"
     curl.password = "bar"
@@ -1501,6 +1605,18 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   end
 
+  def test_easy_close_restores_error_buffer
+    easy = Curl::Easy.new('http://127.0.0.1:1')
+    assert_raise(Curl::Err::ConnectionFailedError) { easy.perform }
+    assert_not_nil easy.last_error
+
+    easy.close
+    easy.url = 'http://127.0.0.1:1'
+    assert_raise(Curl::Err::ConnectionFailedError) { easy.perform }
+
+    assert_not_nil easy.last_error
+  end
+
   def test_easy_reset
     easy = Curl::Easy.new
     easy.url = TestServlet.url + "?query=foo"