curb 1.3.2 → 1.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f62e867480076ceef877a4adcb5c3b4a344769207af06ded4535a3ce1e87375
-  data.tar.gz: 4caa926321d05804edbd4b0470951a617192ffd2504ac741524306edec1fe193
+  metadata.gz: 91423579fc22ce296ae84abfa27438de27d2e9bf6da58658ce86939aabecfe86
+  data.tar.gz: 46f1a051e546934eee05283bdbed84635ae1be3f46adaf48625140f260feb27f
 SHA512:
-  metadata.gz: 917f5e735b7187b5089896a83442462ed7f7b9311dbf616e58ab2cae3b2dff38e28f51f401e183214779d8f5159da6fa6dc7d842c0b5e21993cd428f61868d1f
-  data.tar.gz: 986d63577872fc80a563a4f2ac29a169888eb549d7ba462ecdef89636f3087be48ad7895e13954824e5af069614601ae30730a0af88cd4b3ad3391997b37c3e3
+  metadata.gz: b863797088f6ade8e6a48c3018a7f24b4469fda0daa35cabdacc826452b31c028ba75a2d0fd9bfefeb90817a39421110979d7013b0a573c7b06016f27e7d93fd
+  data.tar.gz: 851be0f60e8e7e53db42f2e6b03742c403c55c7d2242282dd4bab8b77f33c4b0eb206fb221c7f26d26dafa2f6fdddd7a0e84369ca94a0afd038510910cf7d5de

data/ext/curb.h

@@ -28,11 +28,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "1.3.2"
-#define CURB_VER_NUM   1032
+#define CURB_VERSION   "1.3.4"
+#define CURB_VER_NUM   1034
 #define CURB_VER_MAJ   1
 #define CURB_VER_MIN   3
-#define CURB_VER_MIC   2
+#define CURB_VER_MIC   4
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -829,6 +829,10 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
 
   /* now deep copy */
   newrbce->curl = curl_easy_duphandle(rbce->curl);
+  if (!newrbce->curl) {
+    free(newrbce);
+    rb_raise(rb_eNoMemError, "Failed to duplicate Curl::Easy handle");
+  }
   newrbce->curl_headers = (rbce->curl_headers) ? duplicate_curl_slist(rbce->curl_headers) : NULL;
   newrbce->curl_proxy_headers = (rbce->curl_proxy_headers) ? duplicate_curl_slist(rbce->curl_proxy_headers) : NULL;
   newrbce->curl_ftp_commands = (rbce->curl_ftp_commands) ? duplicate_curl_slist(rbce->curl_ftp_commands) : NULL;
@@ -1367,35 +1371,15 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE upload;
+  VALUE upload_stream = data;
   VALUE headers;
+  VALUE infile_size = Qnil;
 
   TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  upload = ruby_curl_upload_new(cCurlUpload);
-  ruby_curl_upload_stream_set(upload,data);
-
-  curl = rbce->curl;
-  rb_easy_set("upload", upload); /* keep the upload object alive as long as
-                                    the easy handle is active or until the upload
-                                    is complete or terminated... */
-
-  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
-  curl_easy_setopt(curl, CURLOPT_POST, 0);
-  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
-  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
-  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
-  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
-#ifdef HAVE_CURLOPT_SEEKFUNCTION
-  curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, (curl_seek_callback)seek_data_handler);
-#endif
-  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
-#ifdef HAVE_CURLOPT_SEEKDATA
-  curl_easy_setopt(curl, CURLOPT_SEEKDATA, rbce);
-#endif
-
   /*
-   * we need to set specific headers for the PUT to work... so
-   * convert the internal headers structure to a HASH if one is set
+   * Validate and prepare Ruby-visible state before mutating the CURL handle.
+   * Several branches below can raise (header type, stat, size, to_s).
    */
   if (!rb_easy_nil("headers")) {
     if (rb_easy_type_check("headers", T_ARRAY) || rb_easy_type_check("headers", T_STRING)) {
@@ -1403,43 +1387,80 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
     }
   }
 
-  // exit fast if the payload is empty
-  if (NIL_P(data)) { return data; }
+  if (!NIL_P(data) && !rb_respond_to(data, rb_intern("read"))) {
+    if (rb_respond_to(data, rb_intern("to_s"))) {
+      upload_stream = rb_obj_as_string(data);
+    } else {
+      rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
+    }
+  }
 
   headers = rb_easy_get("headers");
   if( headers == Qnil ) {
     headers = rb_hash_new();
   }
 
-  if (rb_respond_to(data, rb_intern("read"))) {
-    VALUE stat = rb_funcall(data, rb_intern("stat"), 0);
-    if( stat && rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil) {
+  if (!NIL_P(data) && rb_respond_to(data, rb_intern("read"))) {
+    VALUE stat = Qnil;
+    if (rb_respond_to(data, rb_intern("stat"))) {
+      stat = rb_funcall(data, rb_intern("stat"), 0);
+    }
+    if(!NIL_P(stat) && stat != Qfalse && rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil) {
       VALUE size;
       if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
         rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
       }
       size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, NUM2LONG(size));
+      infile_size = size;
     }
     else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) == Qnil && rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
     }
     else if( rb_hash_aref(headers, rb_str_new2("Content-Length")) ) {
       VALUE size = rb_funcall(rb_hash_aref(headers, rb_str_new2("Content-Length")), rb_intern("to_i"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, NUM2LONG(size));
+      infile_size = size;
     }
   }
-  else if (rb_respond_to(data, rb_intern("to_s"))) {
-    curl_easy_setopt(curl, CURLOPT_INFILESIZE, RSTRING_LEN(data));
+  else if (!NIL_P(data) && rb_respond_to(data, rb_intern("to_s"))) {
+    infile_size = LONG2NUM(RSTRING_LEN(upload_stream));
     if( rb_hash_aref(headers, rb_str_new2("Expect")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
     }
   }
+  else if (NIL_P(data)) {
+    /* Preserve legacy nil handling: configure an upload with no payload. */
+  }
   else {
     rb_raise(rb_eRuntimeError, "PUT data must respond to read or to_s");
   }
   rb_easy_set("headers",headers);
 
+  upload = ruby_curl_upload_new(cCurlUpload);
+  ruby_curl_upload_stream_set(upload, upload_stream);
+
+  curl = rbce->curl;
+  rb_easy_set("upload", upload); /* keep the upload object alive as long as
+                                    the easy handle is active or until the upload
+                                    is complete or terminated... */
+
+  curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
+  curl_easy_setopt(curl, CURLOPT_POST, 0);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDS, NULL);
+  curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
+  curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+  curl_easy_setopt(curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
+#ifdef HAVE_CURLOPT_SEEKFUNCTION
+  curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, (curl_seek_callback)seek_data_handler);
+#endif
+  curl_easy_setopt(curl, CURLOPT_READDATA, rbce);
+#ifdef HAVE_CURLOPT_SEEKDATA
+  curl_easy_setopt(curl, CURLOPT_SEEKDATA, rbce);
+#endif
+
+  if (!NIL_P(infile_size)) {
+    curl_easy_setopt(curl, CURLOPT_INFILESIZE, NUM2LONG(infile_size));
+  }
+
   // if we made it this far, all should be well.
   return data;
 }
@@ -2754,7 +2775,7 @@ static VALUE cb_each_ftp_command(VALUE ftp_command, VALUE wrap, int _c, const VA
   TypedData_Get_Struct(wrap, struct curl_slist *, &curl_slist_ptr_type, list);
 
   ftp_command_string = rb_obj_as_string(ftp_command);
-  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(ftp_command));
+  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(ftp_command_string));
   if (!new_list) {
     rb_raise(rb_eNoMemError, "Failed to append to FTP command list");
   }
@@ -2772,7 +2793,7 @@ static VALUE cb_each_resolve(VALUE resolve, VALUE wrap, int _c, const VALUE *_pt
   TypedData_Get_Struct(wrap, struct curl_slist *, &curl_slist_ptr_type, list);
 
   resolve_string = rb_obj_as_string(resolve);
-  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(resolve));
+  struct curl_slist *new_list = curl_slist_append(*list, StringValuePtr(resolve_string));
   if (!new_list) {
     rb_raise(rb_eNoMemError, "Failed to append to resolve list");
   }
@@ -3153,6 +3174,13 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     if (rb_easy_type_check("resolve", T_ARRAY)) {
       VALUE wrap = TypedData_Wrap_Struct(rb_cObject, &curl_slist_ptr_type, rslv);
       rb_block_call(rb_easy_get("resolve"), rb_intern("each"), 0, NULL, cb_each_resolve, wrap);
+    } else {
+      VALUE resolve_str = rb_obj_as_string(rb_easy_get("resolve"));
+      struct curl_slist *new_list = curl_slist_append(*rslv, StringValuePtr(resolve_str));
+      if (!new_list) {
+        rb_raise(rb_eNoMemError, "Failed to append to resolve list");
+      }
+      *rslv = new_list;
     }
 
     if (*rslv) {
@@ -3209,6 +3237,44 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
   return Qnil;
 }
 
+struct easy_perform_request_restore_args {
+  VALUE self;
+  CURL *curl;
+  ruby_curl_easy *rbce;
+  int clear_customrequest;
+  int clear_nobody;
+  int clear_postfields;
+};
+
+static VALUE perform_with_request_restore_body(VALUE argp) {
+  struct easy_perform_request_restore_args *args = (struct easy_perform_request_restore_args *)argp;
+  return rb_funcall(args->self, rb_intern("perform"), 0);
+}
+
+static VALUE perform_with_request_restore_ensure(VALUE argp) {
+  struct easy_perform_request_restore_args *args = (struct easy_perform_request_restore_args *)argp;
+
+  if (args->curl) {
+    if (args->clear_nobody) {
+      curl_easy_setopt(args->curl, CURLOPT_NOBODY, 0L);
+    }
+    if (args->clear_customrequest) {
+      curl_easy_setopt(args->curl, CURLOPT_CUSTOMREQUEST, NULL);
+    }
+    if (args->clear_postfields) {
+      curl_easy_setopt(args->curl, CURLOPT_POST, 0L);
+      curl_easy_setopt(args->curl, CURLOPT_POSTFIELDS, NULL);
+      curl_easy_setopt(args->curl, CURLOPT_POSTFIELDSIZE, 0L);
+      curl_easy_setopt(args->curl, CURLOPT_HTTPGET, 1L);
+      if (args->rbce && !NIL_P(args->rbce->opts)) {
+        rb_hash_delete(args->rbce->opts, rb_easy_hkey("postdata_buffer"));
+      }
+    }
+  }
+
+  return Qnil;
+}
+
 /*
  * Common implementation of easy.http(verb) and easy.http_delete
  */
@@ -3241,13 +3307,9 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
     curl_easy_setopt(curl, CURLOPT_POST, 0L);
   }
 
-  retval = rb_funcall(self, rb_intern("perform"), 0);
-
-  /* Restore state after request. */
-  if (is_head) {
-    curl_easy_setopt(curl, CURLOPT_NOBODY, 0L);
-  }
-  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
+  struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, is_head, 0 };
+  retval = rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                     perform_with_request_restore_ensure, (VALUE)&restore_args);
 
   return retval;
 }
@@ -3405,7 +3467,9 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
         ruby_curl_easy_post_body_set(self, post_body);
       }
 
-      return rb_funcall(self, rb_intern("perform"), 0);
+      struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, 0, 0 };
+      return rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                       perform_with_request_restore_ensure, (VALUE)&restore_args);
     }
   }
 }
@@ -3459,7 +3523,9 @@ static VALUE ruby_curl_easy_perform_patch(int argc, VALUE *argv, VALUE self) {
       if (rb_easy_nil("postdata_buffer")) {
         ruby_curl_easy_post_body_set(self, patch_body);
       }
-      return rb_funcall(self, rb_intern("perform"), 0);
+      struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, 0, 1 };
+      return rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                       perform_with_request_restore_ensure, (VALUE)&restore_args);
     }
   }
 }
@@ -3510,7 +3576,9 @@ static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
       ruby_curl_easy_put_data_set(self, post_body);
     }
   }
-  return rb_funcall(self, rb_intern("perform"), 0);
+  struct easy_perform_request_restore_args restore_args = { self, curl, rbce, 1, 0, 0 };
+  return rb_ensure(perform_with_request_restore_body, (VALUE)&restore_args,
+                   perform_with_request_restore_ensure, (VALUE)&restore_args);
 }
 
 
@@ -4577,6 +4645,7 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     }
     /* Save the list pointer in the ruby_curl_easy structure for cleanup later */
     rbce->curl_resolve = list;
+    rb_hash_aset(rbce->opts, rb_easy_hkey("resolve"), val);
     curl_easy_setopt(rbce->curl, CURLOPT_RESOLVE, list);
   } break;
 #endif

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;
@@ -1144,18 +1225,32 @@ static void rb_fdset_from_sockmap(st_table *map, rb_fdset_t *rfds, rb_fdset_t *w
   *maxfd_out = a.maxfd;
 }
 
-struct dispatch_args { CURLM *mh; int *running; CURLMcode mrc; rb_fdset_t *r; rb_fdset_t *w; rb_fdset_t *e; };
-static int dispatch_ready_fd_i(st_data_t key, st_data_t val, st_data_t argp) {
+struct ready_fd {
+  int fd;
+  int flags;
+};
+
+struct collect_ready_fd_args {
+  rb_fdset_t *r;
+  rb_fdset_t *w;
+  rb_fdset_t *e;
+  struct ready_fd *fds;
+  int capacity;
+  int count;
+};
+
+static int collect_ready_fd_i(st_data_t key, st_data_t val, st_data_t argp) {
   (void)val;
-  struct dispatch_args *dp = (struct dispatch_args *)argp;
+  struct collect_ready_fd_args *a = (struct collect_ready_fd_args *)argp;
   int fd = (int)key;
   int flags = 0;
-  if (rb_fd_isset(fd, dp->r)) flags |= CURL_CSELECT_IN;
-  if (rb_fd_isset(fd, dp->w)) flags |= CURL_CSELECT_OUT;
-  if (rb_fd_isset(fd, dp->e)) flags |= CURL_CSELECT_ERR;
-  if (flags) {
-    dp->mrc = curl_multi_socket_action(dp->mh, (curl_socket_t)fd, flags, dp->running);
-    if (dp->mrc != CURLM_OK) return ST_STOP;
+  if (rb_fd_isset(fd, a->r)) flags |= CURL_CSELECT_IN;
+  if (rb_fd_isset(fd, a->w)) flags |= CURL_CSELECT_OUT;
+  if (rb_fd_isset(fd, a->e)) flags |= CURL_CSELECT_ERR;
+  if (flags && a->count < a->capacity) {
+    a->fds[a->count].fd = fd;
+    a->fds[a->count].flags = flags;
+    a->count++;
   }
   return ST_CONTINUE;
 }
@@ -1236,6 +1331,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) {
@@ -1254,12 +1350,25 @@ 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) {
-        struct dispatch_args d; d.mh = rbcm->handle; d.running = &rbcm->running; d.mrc = CURLM_OK; d.r = &rfds; d.w = &wfds; d.e = &efds;
-        st_foreach(ctx->sock_map, dispatch_ready_fd_i, (st_data_t)&d);
-        if (d.mrc != CURLM_OK) {
-          rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
-          raise_curl_multi_error_exception(d.mrc);
+        struct ready_fd *ready_fds = ALLOC_N(struct ready_fd, count_tracked);
+        struct collect_ready_fd_args d;
+        int i;
+        d.r = &rfds;
+        d.w = &wfds;
+        d.e = &efds;
+        d.fds = ready_fds;
+        d.capacity = count_tracked;
+        d.count = 0;
+        st_foreach(ctx->sock_map, collect_ready_fd_i, (st_data_t)&d);
+        for (i = 0; i < d.count; i++) {
+          mrc = curl_multi_socket_action(rbcm->handle, (curl_socket_t)d.fds[i].fd, d.fds[i].flags, &rbcm->running);
+          if (mrc != CURLM_OK) {
+            xfree(ready_fds);
+            rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
+            raise_curl_multi_error_exception(mrc);
+          }
         }
+        xfree(ready_fds);
       }
       rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
       handled_wait = 1;
@@ -1270,10 +1379,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 +1411,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 +1435,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 +1444,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 +1468,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 +1490,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];
@@ -1410,12 +1530,16 @@ static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
     c->ctx->sock_map = NULL;
   }
   if (c->ctx) {
+    if (!NIL_P(c->ctx->io_cache)) {
+      rb_hash_clear(c->ctx->io_cache);
+      rb_gc_unregister_address(&c->ctx->io_cache);
+    }
     c->ctx->io_cache = Qnil;
   }
   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);
@@ -1430,6 +1554,7 @@ VALUE ruby_curl_multi_socket_perform(int argc, VALUE *argv, VALUE self) {
   ctx.sock_map = st_init_numtable();
   ctx.timeout_ms = -1;
   ctx.io_cache = rb_hash_new();
+  rb_gc_register_address(&ctx.io_cache);
 
   /* install socket/timer callbacks */
   curl_multi_setopt(rbcm->handle, CURLMOPT_SOCKETFUNCTION, multi_socket_cb);
@@ -1445,7 +1570,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 +1622,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 +1647,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 +1828,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 +1862,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 +1932,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/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
@@ -1376,6 +1420,15 @@ 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
@@ -1507,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"

data/tests/tc_curl_easy_resolve.rb

@@ -1,7 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
 
 class TestCurbCurlEasyResolve < Test::Unit::TestCase
+  include TestServerMethods
+
   def setup
+    server_setup
     @easy = Curl::Easy.new
   end
 
@@ -13,4 +16,33 @@ class TestCurbCurlEasyResolve < Test::Unit::TestCase
   def test_empty_resolve
     assert_equal @easy.resolve, nil
   end
+
+  def test_setopt_resolve_persists_across_performs
+    host = "curb-setopt-resolve.invalid"
+    mapping = "#{host}:#{TestServlet.port}:127.0.0.1"
+
+    @easy.url = "http://#{host}:#{TestServlet.port}#{TestServlet.path}"
+    @easy.dns_cache_timeout = 0
+    @easy.set(:resolve, [mapping])
+
+    @easy.perform
+    assert_match(/GET/, @easy.body_str)
+
+    @easy.perform
+    assert_match(/GET/, @easy.body_str)
+  end
+
+  def test_resolve_entries_can_be_objects_that_convert_to_string
+    host = "curb-resolve-object.invalid"
+    mapping = "#{host}:#{TestServlet.port}:127.0.0.1"
+    entry = Object.new
+    entry.define_singleton_method(:to_s) { mapping }
+
+    @easy.url = "http://#{host}:#{TestServlet.port}#{TestServlet.path}"
+    @easy.dns_cache_timeout = 0
+    @easy.resolve = [entry]
+
+    @easy.perform
+    assert_match(/GET/, @easy.body_str)
+  end
 end

data/tests/tc_curl_multi.rb

@@ -133,6 +133,62 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     Curl::Multi.autoclose = false
   end
 
+  def test_close_inside_completion_callback_is_rejected_without_invalidating_multi
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    easy.on_complete { multi.close }
+    multi.add(easy)
+
+    error = assert_raise(Curl::Err::AbortedByCallbackError) { multi.perform }
+    assert_match(/Cannot close an active Curl::Multi handle/, error.message)
+    assert multi.idle?
+    assert_equal({}, multi.requests)
+
+    easy.on_complete { |_curl| }
+    multi.add(easy)
+    multi.perform
+
+    assert_equal "GET", easy.body_str
+  ensure
+    multi.close if defined?(multi) && multi
+  end
+
+  def test_close_inside_perform_block_is_rejected_without_invalidating_multi
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new(TestServlet.url)
+    multi.add(easy)
+
+    error = assert_raise(RuntimeError) do
+      multi.perform { multi.close }
+    end
+    assert_match(/Cannot close an active Curl::Multi handle/, error.message)
+
+    assert_nothing_raised { multi.close }
+    multi = nil
+  ensure
+    multi.close if defined?(multi) && multi
+  end
+
+  def test_active_easy_cannot_be_added_to_another_multi
+    first_multi = Curl::Multi.new
+    second_multi = Curl::Multi.new
+    easy = Curl::Easy.new(TestServlet.url)
+
+    first_multi.add(easy)
+
+    error = assert_raise(RuntimeError) { second_multi.add(easy) }
+    assert_match(/active Curl::Easy/, error.message)
+    assert_same first_multi, easy.multi
+    assert_equal easy, first_multi.requests[easy.object_id]
+
+    assert_nothing_raised { first_multi.close }
+    first_multi = nil
+  ensure
+    first_multi.close if defined?(first_multi) && first_multi
+    second_multi.close if defined?(second_multi) && second_multi
+  end
+
   def test_close_makes_multi_unusable
     multi = Curl::Multi.new
     multi.close

data/tests/tc_fiber_scheduler.rb

@@ -66,7 +66,7 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
   SERIAL_TIME_WOULD_BE_ABOUT = MIN_S * ITERS
 
   def setup
-    @port = 9993
+    @port = unused_local_port
 
     @response_proc = lambda do |res|
       res['Content-Type'] = 'text/plain'

data/tests/tc_ftp_options.rb

@@ -22,5 +22,18 @@ class TestCurbFtpOptions < Test::Unit::TestCase
     assert_kind_of(Array, c.ftp_commands)
     assert_equal ["PWD", "CWD /"], c.ftp_commands
   end
-end
 
+  def test_ftp_command_entries_can_be_objects_that_convert_to_string
+    command = Object.new
+    command.define_singleton_method(:to_s) { "PWD" }
+
+    c = Curl::Easy.new($TEST_URL)
+    c.ftp_commands = [command]
+    m = Curl::Multi.new
+
+    assert_nothing_raised { m.add(c) }
+  ensure
+    m.remove(c) if defined?(m) && m && m.requests[c.object_id]
+    m.close if defined?(m) && m
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.3.4
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2026-04-23 00:00:00.000000000 Z
+date: 2026-05-12 00:00:00.000000000 Z
 dependencies: []
 description: Curb (probably CUrl-RuBy or something) provides Ruby-language bindings
   for the libcurl(3), a fully-featured client-side URL transfer library. cURL and