curb 1.3.4 → 1.3.6

data/ext/curb_multi.c

@@ -28,6 +28,10 @@
 
 #include <errno.h>
 #include <fcntl.h>
+#ifndef _WIN32
+#include <sys/time.h>
+#include <time.h>
+#endif
 #include <stdint.h>
 #include <stdarg.h>
 
@@ -70,6 +74,8 @@ extern VALUE mCurl;
 static VALUE idCall;
 static ID id_deferred_exception_ivar;
 static ID id_deferred_exception_source_id_ivar;
+static ID id_native_safety_signatures_ivar;
+static ID id_socket_io_cache_ivar;
 
 #ifdef RDOC_NEVER_DEFINED
   mCurl = rb_define_module("Curl");
@@ -281,6 +287,33 @@ void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr) {
   st_delete(rbcm->attached, &key, NULL);
 }
 
+CURLMcode rb_curl_multi_detach_easy(ruby_curl_multi *rbcm, void *rbce_ptr) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)rbce_ptr;
+  st_data_t key;
+
+  if (!rbcm || !rbce || !rbcm->attached) {
+    return CURLM_OK;
+  }
+
+  key = (st_data_t)rbce;
+  if (!st_delete(rbcm->attached, &key, NULL)) {
+    return CURLM_OK;
+  }
+
+  if (rbcm->handle && rbce->curl) {
+    CURLMcode result = curl_multi_remove_handle(rbcm->handle, rbce->curl);
+    if (result != CURLM_OK) {
+      return result;
+    }
+  }
+
+  if (rbcm->active > 0) {
+    rbcm->active--;
+  }
+
+  return CURLM_OK;
+}
+
 static void rb_curl_multi_detach_all(ruby_curl_multi *rbcm) {
   if (!rbcm || !rbcm->attached) {
     return;
@@ -309,6 +342,8 @@ static int rb_curl_multi_has_easy(ruby_curl_multi *rbcm, ruby_curl_easy *rbce) {
 
 static void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy) {
   VALUE requests;
+  VALUE object_id;
+  VALUE safety_signatures;
 
   if (NIL_P(self) || NIL_P(easy)) {
     return;
@@ -319,7 +354,17 @@ static void rb_curl_multi_remove_request_reference(VALUE self, VALUE easy) {
     return;
   }
 
-  rb_hash_delete(requests, rb_obj_id(easy));
+  object_id = rb_obj_id(easy);
+  rb_hash_delete(requests, object_id);
+
+  if (!rb_ivar_defined(self, id_native_safety_signatures_ivar)) {
+    return;
+  }
+
+  safety_signatures = rb_ivar_get(self, id_native_safety_signatures_ivar);
+  if (RB_TYPE_P(safety_signatures, T_HASH)) {
+    rb_hash_delete(safety_signatures, object_id);
+  }
 }
 
 /* TypedData-compatible free function */
@@ -1070,10 +1115,28 @@ static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_runnin
 /* ---- socket-action implementation (scheduler-friendly) ---- */
 typedef struct {
   st_table *sock_map;     /* key: int fd, value: int 'what' (CURL_POLL_*) */
-  long timeout_ms;        /* last timeout set by libcurl timer callback */
+  long long timeout_deadline_ms; /* absolute deadline for CURL_SOCKET_TIMEOUT */
   VALUE io_cache;         /* fd -> IO wrapper for fiber-scheduler waits */
 } multi_socket_ctx;
 
+static long long multi_socket_current_time_ms(void) {
+#if defined(CLOCK_MONOTONIC)
+  struct timespec ts;
+  if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
+    return ((long long)ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
+  }
+#endif
+
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  return ((long long)tv.tv_sec * 1000) + (tv.tv_usec / 1000);
+}
+
+static int multi_socket_timer_due(multi_socket_ctx *ctx) {
+  return ctx && ctx->timeout_deadline_ms >= 0 &&
+    multi_socket_current_time_ms() >= ctx->timeout_deadline_ms;
+}
+
 #if CURB_SOCKET_DEBUG
 static void curb_debugf(const char *fmt, ...) {
   va_list ap;
@@ -1118,6 +1181,21 @@ static VALUE fiber_io_wait_protected(VALUE argp) {
 }
 #endif
 
+#if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
+struct fiber_io_select_args {
+  VALUE scheduler;
+  VALUE readables;
+  VALUE writables;
+  VALUE exceptables;
+  VALUE timeout;
+};
+
+static VALUE fiber_io_select_protected(VALUE argp) {
+  struct fiber_io_select_args *a = (struct fiber_io_select_args *)argp;
+  return rb_fiber_scheduler_io_select(a->scheduler, a->readables, a->writables, a->exceptables, a->timeout);
+}
+#endif
+
 #if defined(RB_INTEGER_TYPE_P)
 #define CURB_INTEGER_P(value) RB_INTEGER_TYPE_P(value)
 #else
@@ -1187,6 +1265,11 @@ static int multi_socket_cb(CURL *easy, curl_socket_t s, int what, void *userp, v
 #endif
   } else {
     /* store current interest mask for this fd */
+    st_data_t key = (st_data_t)fd;
+    st_data_t old_what;
+    if (st_lookup(ctx->sock_map, key, &old_what) && (int)old_what != what && !NIL_P(ctx->io_cache)) {
+      rb_hash_delete(ctx->io_cache, INT2NUM(fd));
+    }
     st_insert(ctx->sock_map, (st_data_t)fd, (st_data_t)what);
 #if CURB_SOCKET_DEBUG
     {
@@ -1201,7 +1284,9 @@ static int multi_socket_cb(CURL *easy, curl_socket_t s, int what, void *userp, v
 static int multi_timer_cb(CURLM *multi, long timeout_ms, void *userp) {
   (void)multi;
   multi_socket_ctx *ctx = (multi_socket_ctx *)userp;
-  if (ctx) ctx->timeout_ms = timeout_ms;
+  if (ctx) {
+    ctx->timeout_deadline_ms = timeout_ms < 0 ? -1 : multi_socket_current_time_ms() + timeout_ms;
+  }
   curb_debugf("[curb.socket] timer_cb timeout_ms=%ld", timeout_ms);
   return 0;
 }
@@ -1272,23 +1357,103 @@ static int st_count_i(st_data_t k, st_data_t v, st_data_t argp) {
   return ST_CONTINUE;
 }
 
-static VALUE multi_socket_io_for_fd(multi_socket_ctx *ctx, int fd) {
+static const char *multi_socket_io_mode_for_curl_poll(int what) {
+  if (what == CURL_POLL_IN) return "r";
+  if (what == CURL_POLL_OUT) return "w";
+  return "r+";
+}
+
+static VALUE multi_socket_io_for_fd(multi_socket_ctx *ctx, int fd, int what) {
   VALUE key = INT2NUM(fd);
   VALUE io = rb_hash_aref(ctx->io_cache, key);
   if (NIL_P(io)) {
-    io = rb_funcall(rb_cIO, rb_intern("for_fd"), 2, key, rb_str_new_cstr("r+"));
+    io = rb_funcall(rb_cIO, rb_intern("for_fd"), 2, key, rb_str_new_cstr(multi_socket_io_mode_for_curl_poll(what)));
     rb_funcall(io, rb_intern("autoclose="), 1, Qfalse);
     rb_hash_aset(ctx->io_cache, key, io);
   }
   return io;
 }
 
-struct io_for_fd_args { multi_socket_ctx *ctx; int fd; };
+struct io_for_fd_args { multi_socket_ctx *ctx; int fd; int what; };
 static VALUE multi_socket_io_for_fd_protected(VALUE argp) {
   struct io_for_fd_args *a = (struct io_for_fd_args *)argp;
-  return multi_socket_io_for_fd(a->ctx, a->fd);
+  return multi_socket_io_for_fd(a->ctx, a->fd, a->what);
 }
 
+#if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
+struct build_io_select_arrays_args {
+  multi_socket_ctx *ctx;
+  VALUE readables;
+  VALUE writables;
+  VALUE exceptables;
+  int failed;
+};
+
+static int build_io_select_arrays_i(st_data_t key, st_data_t val, st_data_t argp) {
+  struct build_io_select_arrays_args *a = (struct build_io_select_arrays_args *)argp;
+  int fd = (int)key;
+  int what = (int)val;
+  struct io_for_fd_args io_args = { a->ctx, fd, what };
+  int io_state = 0;
+  VALUE io;
+
+  if (!multi_socket_fd_valid_p(fd)) {
+    a->failed = 1;
+    return ST_STOP;
+  }
+
+  io = rb_protect(multi_socket_io_for_fd_protected, (VALUE)&io_args, &io_state);
+  if (io_state || NIL_P(io)) {
+    if (io_state) {
+#if CURB_SOCKET_DEBUG
+      VALUE err = rb_errinfo();
+      VALUE msg = rb_obj_as_string(err);
+      curb_debugf("[curb.socket] IO.for_fd failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
+#endif
+      rb_set_errinfo(Qnil);
+    }
+    a->failed = 1;
+    return ST_STOP;
+  }
+
+  if (what == CURL_POLL_IN || what == CURL_POLL_INOUT) rb_ary_push(a->readables, io);
+  if (what == CURL_POLL_OUT || what == CURL_POLL_INOUT) rb_ary_push(a->writables, io);
+  rb_ary_push(a->exceptables, io);
+
+  return ST_CONTINUE;
+}
+
+struct collect_io_select_ready_args {
+  multi_socket_ctx *ctx;
+  VALUE readables;
+  VALUE writables;
+  VALUE exceptables;
+  struct ready_fd *fds;
+  int capacity;
+  int count;
+};
+
+static int collect_io_select_ready_i(st_data_t key, st_data_t val, st_data_t argp) {
+  (void)val;
+  struct collect_io_select_ready_args *a = (struct collect_io_select_ready_args *)argp;
+  VALUE io = rb_hash_aref(a->ctx->io_cache, INT2NUM((int)key));
+  int flags = 0;
+
+  if (NIL_P(io)) return ST_CONTINUE;
+  if (RTEST(rb_ary_includes(a->readables, io))) flags |= CURL_CSELECT_IN;
+  if (RTEST(rb_ary_includes(a->writables, io))) flags |= CURL_CSELECT_OUT;
+  if (RTEST(rb_ary_includes(a->exceptables, io))) flags |= CURL_CSELECT_ERR;
+
+  if (flags && a->count < a->capacity) {
+    a->fds[a->count].fd = (int)key;
+    a->fds[a->count].flags = flags;
+    a->count++;
+  }
+
+  return ST_CONTINUE;
+}
+#endif
+
 static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_socket_ctx *ctx, VALUE block) {
   /* prime the state: let libcurl act on timeouts to setup sockets */
   CURLMcode mrc = curl_multi_socket_action(rbcm->handle, CURL_SOCKET_TIMEOUT, 0, &rbcm->running);
@@ -1299,16 +1464,24 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 
   while (rbcm->running) {
     struct timeval tv = {0, 0};
-    if (ctx->timeout_ms < 0) {
-      tv.tv_sec = cCurlMutiDefaulttimeout / 1000;
-      tv.tv_usec = (cCurlMutiDefaulttimeout % 1000) * 1000;
-    } else {
-      long t = ctx->timeout_ms;
-      if (t > cCurlMutiDefaulttimeout) t = cCurlMutiDefaulttimeout;
-      if (t < 0) t = 0;
-      tv.tv_sec = t / 1000;
-      tv.tv_usec = (t % 1000) * 1000;
+    long wait_ms = cCurlMutiDefaulttimeout;
+
+    if (multi_socket_timer_due(ctx)) {
+      ctx->timeout_deadline_ms = -1;
+      mrc = curl_multi_socket_action(rbcm->handle, CURL_SOCKET_TIMEOUT, 0, &rbcm->running);
+      curb_debugf("[curb.socket] socket_action timeout(due) -> mrc=%d running=%d", mrc, rbcm->running);
+      if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
+      rb_curl_multi_read_info(self, rbcm->handle);
+      rb_curl_multi_yield_if_given(self, block);
+      continue;
+    }
+
+    if (ctx->timeout_deadline_ms >= 0) {
+      long long remaining_ms = ctx->timeout_deadline_ms - multi_socket_current_time_ms();
+      if (remaining_ms < wait_ms) wait_ms = remaining_ms < 0 ? 0 : (long)remaining_ms;
     }
+    tv.tv_sec = wait_ms / 1000;
+    tv.tv_usec = (wait_ms % 1000) * 1000;
 
     /* Find a representative fd to wait on (if any). */
     int wait_fd = -1;
@@ -1333,50 +1506,113 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
     int any_ready = 0;
     int ready_flags = 0;
 
-    int handled_wait = 0;
-    if (count_tracked > 1) {
-      /* Multi-fd wait using scheduler-aware rb_thread_fd_select. */
-      rb_fdset_t rfds, wfds, efds;
-      rb_fd_init(&rfds); rb_fd_init(&wfds); rb_fd_init(&efds);
-      int maxfd = -1;
-      rb_fdset_from_sockmap(ctx->sock_map, &rfds, &wfds, &efds, &maxfd);
-      int rc = rb_thread_fd_select(maxfd + 1, &rfds, &wfds, &efds, &tv);
-      curb_debugf("[curb.socket] rb_thread_fd_select(multi) rc=%d maxfd=%d", rc, maxfd);
-      if (rc < 0) {
-        rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
-        if (errno != EINTR) rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
-        continue;
-      }
-      any_ready = (rc > 0);
-      did_timeout = (rc == 0);
-      if (any_ready) {
-        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;
-    } else if (count_tracked == 1) {
+	    int handled_wait = 0;
+	    if (count_tracked > 1) {
+#if defined(HAVE_RB_FIBER_SCHEDULER_IO_SELECT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
+	      {
+	        VALUE scheduler = rb_fiber_scheduler_current();
+	        if (scheduler != Qnil) {
+	          VALUE readables = rb_ary_new();
+	          VALUE writables = rb_ary_new();
+	          VALUE exceptables = rb_ary_new();
+	          struct build_io_select_arrays_args build_args = { ctx, readables, writables, exceptables, 0 };
+	          st_foreach(ctx->sock_map, build_io_select_arrays_i, (st_data_t)&build_args);
+	          if (!build_args.failed) {
+	            double timeout_s = (double)tv.tv_sec + ((double)tv.tv_usec / 1e6);
+	            VALUE timeout = rb_float_new(timeout_s);
+	            struct fiber_io_select_args select_args = { scheduler, readables, writables, exceptables, timeout };
+	            int state = 0;
+	            VALUE ready = rb_protect(fiber_io_select_protected, (VALUE)&select_args, &state);
+	            if (state) {
+#if CURB_SOCKET_DEBUG
+	              VALUE err = rb_errinfo();
+	              VALUE msg = rb_obj_as_string(err);
+	              curb_debugf("[curb.socket] scheduler io_select failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
+#endif
+	              rb_set_errinfo(Qnil);
+	            } else {
+	              handled_wait = 1;
+	              any_ready = RB_TYPE_P(ready, T_ARRAY);
+	              did_timeout = !any_ready && multi_socket_timer_due(ctx);
+	              if (any_ready) {
+	                VALUE ready_readables = rb_ary_entry(ready, 0);
+	                VALUE ready_writables = rb_ary_entry(ready, 1);
+	                VALUE ready_exceptables = rb_ary_entry(ready, 2);
+	                struct ready_fd *ready_fds = ALLOC_N(struct ready_fd, count_tracked);
+	                struct collect_io_select_ready_args d;
+	                int i;
+	                if (!RB_TYPE_P(ready_readables, T_ARRAY)) ready_readables = rb_ary_new();
+	                if (!RB_TYPE_P(ready_writables, T_ARRAY)) ready_writables = rb_ary_new();
+	                if (!RB_TYPE_P(ready_exceptables, T_ARRAY)) ready_exceptables = rb_ary_new();
+	                d.ctx = ctx;
+	                d.readables = ready_readables;
+	                d.writables = ready_writables;
+	                d.exceptables = ready_exceptables;
+	                d.fds = ready_fds;
+	                d.capacity = count_tracked;
+	                d.count = 0;
+	                st_foreach(ctx->sock_map, collect_io_select_ready_i, (st_data_t)&d);
+	                any_ready = (d.count > 0);
+	                did_timeout = !any_ready && multi_socket_timer_due(ctx);
+	                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);
+	                    raise_curl_multi_error_exception(mrc);
+	                  }
+	                }
+	                xfree(ready_fds);
+	              }
+	            }
+	          }
+	        }
+	      }
+#endif
+	      if (!handled_wait) {
+	        /* Multi-fd wait using scheduler-aware rb_thread_fd_select. */
+	        rb_fdset_t rfds, wfds, efds;
+	        rb_fd_init(&rfds); rb_fd_init(&wfds); rb_fd_init(&efds);
+	        int maxfd = -1;
+	        rb_fdset_from_sockmap(ctx->sock_map, &rfds, &wfds, &efds, &maxfd);
+	        int rc = rb_thread_fd_select(maxfd + 1, &rfds, &wfds, &efds, &tv);
+	        curb_debugf("[curb.socket] rb_thread_fd_select(multi) rc=%d maxfd=%d", rc, maxfd);
+	        if (rc < 0) {
+	          rb_fd_term(&rfds); rb_fd_term(&wfds); rb_fd_term(&efds);
+	          if (errno != EINTR) rb_raise(rb_eRuntimeError, "select(): %s", strerror(errno));
+	          continue;
+	        }
+	        any_ready = (rc > 0);
+	        did_timeout = (rc == 0 && multi_socket_timer_due(ctx));
+	        if (any_ready) {
+	          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;
+	      }
+	    } else if (count_tracked == 1) {
 #if defined(HAVE_RB_FIBER_SCHEDULER_IO_WAIT) && defined(HAVE_RB_FIBER_SCHEDULER_CURRENT)
       {
         VALUE scheduler = rb_fiber_scheduler_current();
         if (scheduler != Qnil) {
+          int scheduler_wait_handled = 0;
           int events = 0;
           if (wait_fd >= 0) {
             events = multi_socket_wait_events_for_curl_poll(wait_what);
@@ -1389,30 +1625,42 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 #else
             rb_thread_wait_for(tv);
 #endif
-            did_timeout = 1;
+            did_timeout = multi_socket_timer_due(ctx);
+            scheduler_wait_handled = 1;
           } else if (!multi_socket_fd_valid_p(wait_fd)) {
             multi_socket_forget_fd(ctx, wait_fd);
             did_timeout = 1;
+            scheduler_wait_handled = 1;
           } else {
-            struct io_for_fd_args io_args = { ctx, wait_fd };
+            struct io_for_fd_args io_args = { ctx, wait_fd, wait_what };
             int io_state = 0;
             VALUE io = rb_protect(multi_socket_io_for_fd_protected, (VALUE)&io_args, &io_state);
             if (io_state || NIL_P(io)) {
-              if (io_state) rb_set_errinfo(Qnil);
-              multi_socket_forget_fd(ctx, wait_fd);
-              did_timeout = 1;
+              if (io_state) {
+#if CURB_SOCKET_DEBUG
+                VALUE err = rb_errinfo();
+                VALUE msg = rb_obj_as_string(err);
+                curb_debugf("[curb.socket] IO.for_fd failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
+#endif
+                rb_set_errinfo(Qnil);
+              }
               any_ready = 0;
             } else {
               struct fiber_io_wait_args args = { scheduler, io, INT2NUM(events), timeout };
               int state = 0;
               VALUE ready = rb_protect(fiber_io_wait_protected, (VALUE)&args, &state);
               if (state) {
+#if CURB_SOCKET_DEBUG
+                VALUE err = rb_errinfo();
+                VALUE msg = rb_obj_as_string(err);
+                curb_debugf("[curb.socket] scheduler io_wait failed: %s: %s", rb_obj_classname(err), StringValueCStr(msg));
+#endif
                 rb_set_errinfo(Qnil);
-                did_timeout = 1;
                 any_ready = 0;
               } else {
+                scheduler_wait_handled = 1;
                 any_ready = (ready != Qfalse && !NIL_P(ready));
-                did_timeout = !any_ready;
+                did_timeout = !any_ready && multi_socket_timer_due(ctx);
                 if (any_ready) {
                   if (ready == Qtrue) {
                     ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
@@ -1420,7 +1668,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
                     ready_flags = multi_socket_cselect_flags_for_wait_events(NUM2INT(ready));
                     if (ready_flags == 0) {
                       any_ready = 0;
-                      did_timeout = 1;
+                      did_timeout = multi_socket_timer_due(ctx);
                     }
                   } else {
                     ready_flags = multi_socket_cselect_flags_for_curl_poll(wait_what);
@@ -1429,7 +1677,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
               }
             }
           }
-          handled_wait = 1;
+          if (scheduler_wait_handled) handled_wait = 1;
         }
       }
 #endif
@@ -1443,7 +1691,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
           continue;
         }
         any_ready = (rc != 0);
-        did_timeout = (rc == 0);
+        did_timeout = (rc == 0 && multi_socket_timer_due(ctx));
         if (any_ready) ready_flags = multi_socket_cselect_flags_for_wait_events(rc);
         handled_wait = 1;
       }
@@ -1467,7 +1715,7 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
           continue;
         }
         any_ready = (rc > 0);
-        did_timeout = (rc == 0);
+        did_timeout = (rc == 0 && multi_socket_timer_due(ctx));
         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;
@@ -1481,10 +1729,14 @@ static void rb_curl_multi_socket_drive(VALUE self, ruby_curl_multi *rbcm, multi_
 #else
       rb_thread_wait_for(tv);
 #endif
+      /* libcurl can report active work without a socket callback or deadline;
+       * drive the timeout socket after the scheduler-aware sleep so the state
+       * machine does not stall indefinitely. */
       did_timeout = 1;
     }
 
     if (did_timeout) {
+      ctx->timeout_deadline_ms = -1;
       mrc = curl_multi_socket_action(rbcm->handle, CURL_SOCKET_TIMEOUT, 0, &rbcm->running);
       curb_debugf("[curb.socket] socket_action timeout -> mrc=%d running=%d", mrc, rbcm->running);
       if (mrc != CURLM_OK) raise_curl_multi_error_exception(mrc);
@@ -1516,7 +1768,7 @@ static VALUE ruby_curl_multi_socket_drive_body(VALUE argp) {
   rb_curl_multi_socket_drive(a->self, a->rbcm, a->ctx, a->block);
   return Qtrue;
 }
-struct socket_cleanup_args { ruby_curl_multi *rbcm; multi_socket_ctx *ctx; };
+struct socket_cleanup_args { VALUE self; ruby_curl_multi *rbcm; multi_socket_ctx *ctx; };
 static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
   struct socket_cleanup_args *c = (struct socket_cleanup_args *)argp;
   if (c->rbcm && c->rbcm->handle) {
@@ -1532,10 +1784,12 @@ static VALUE ruby_curl_multi_socket_drive_ensure(VALUE argp) {
   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;
   }
+  if (!NIL_P(c->self) && rb_ivar_defined(c->self, id_socket_io_cache_ivar)) {
+    rb_funcall(c->self, rb_intern("remove_instance_variable"), 1, ID2SYM(id_socket_io_cache_ivar));
+  }
   return Qnil;
 }
 
@@ -1552,9 +1806,9 @@ static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE se
 
   multi_socket_ctx ctx;
   ctx.sock_map = st_init_numtable();
-  ctx.timeout_ms = -1;
+  ctx.timeout_deadline_ms = -1;
   ctx.io_cache = rb_hash_new();
-  rb_gc_register_address(&ctx.io_cache);
+  rb_ivar_set(self, id_socket_io_cache_ivar, ctx.io_cache);
 
   /* install socket/timer callbacks */
   curl_multi_setopt(rbcm->handle, CURLMOPT_SOCKETFUNCTION, multi_socket_cb);
@@ -1564,7 +1818,7 @@ static VALUE ruby_curl_multi_socket_perform_impl(int argc, VALUE *argv, VALUE se
 
   /* run using socket action loop with ensure-cleanup */
   struct socket_drive_args body_args = { self, rbcm, &ctx, block };
-  struct socket_cleanup_args ensure_args = { rbcm, &ctx };
+  struct socket_cleanup_args ensure_args = { self, rbcm, &ctx };
   rb_ensure(ruby_curl_multi_socket_drive_body, (VALUE)&body_args, ruby_curl_multi_socket_drive_ensure, (VALUE)&ensure_args);
 
   /* finalize */
@@ -1857,10 +2111,10 @@ static VALUE ruby_curl_multi_perform_impl(int argc, VALUE *argv, VALUE self) {
 #endif /* disabled curl_multi_wait: use fdsets */
     }
 
+    rb_curl_multi_read_info( self, rbcm->handle );
+    rb_curl_multi_yield_if_given(self, block);
   } while( rbcm->running );
 
-  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);
@@ -1981,6 +2235,8 @@ void init_curb_multi() {
   idCall = rb_intern("call");
   id_deferred_exception_ivar = rb_intern("@__curb_deferred_exception");
   id_deferred_exception_source_id_ivar = rb_intern("@__curb_deferred_exception_source_id");
+  id_native_safety_signatures_ivar = rb_intern("@__curb_native_safety_signatures");
+  id_socket_io_cache_ivar = rb_intern("@__curb_socket_io_cache");
   cCurlMulti = rb_define_class_under(mCurl, "Multi", rb_cObject);
 
   rb_define_alloc_func(cCurlMulti, ruby_curl_multi_alloc);

data/ext/curb_multi.h

@@ -28,6 +28,7 @@ extern const rb_data_type_t ruby_curl_multi_data_type;
 
 void init_curb_multi();
 void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
+CURLMcode rb_curl_multi_detach_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 
 
 #endif

data/ext/extconf.rb

@@ -298,6 +298,8 @@ have_constant "curlopt_sockoptfunction"
 have_constant "curlopt_sockoptdata"
 have_constant "curlopt_opensocketfunction"
 have_constant "curlopt_opensocketdata"
+have_constant "curlopt_prereqfunction"
+have_constant "curlopt_prereqdata"
 
 # Deprecated constants (still check for them for backward compat)
 have_constant "curlopt_ioctlfunction"
@@ -391,6 +393,7 @@ have_constant "curlopt_socks5_gssapi_nec"
 have_constant "curlopt_interface"
 have_constant "curlopt_localport"
 have_constant "curlopt_dns_cache_timeout"
+have_constant "curlopt_dns_servers"
 have_constant "curlopt_dns_use_global_cache"
 have_constant "curlopt_buffersize"
 have_constant "curlopt_port"
@@ -531,6 +534,7 @@ have_constant "curlusessl_none"
 have_constant "curlusessl_try"
 have_constant "curlusessl_control"
 have_constant "curlusessl_all"
+have_constant "curlopt_connect_to"
 have_constant "curlopt_resolve"
 have_constant "curlopt_request_target"
 have_constant "curlopt_sslcert"
@@ -558,6 +562,10 @@ have_constant :CURL_SSLVERSION_TLSv1_2
 have_constant :CURL_SSLVERSION_TLSv1_3
 
 have_constant "curlopt_ssl_verifypeer"
+have_constant "curlopt_doh_url"
+have_constant "curlopt_doh_ssl_verifypeer"
+have_constant "curlopt_doh_ssl_verifyhost"
+have_constant "curlopt_doh_ssl_verifystatus"
 have_constant "curlopt_cainfo"
 have_constant "curlopt_issuercert"
 have_constant "curlopt_capath"
@@ -691,6 +699,7 @@ have_func('rb_wait_for_single_fd', 'ruby/io.h')
 have_header('ruby/fiber/scheduler.h')
 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_io_stdio_file')
 have_func('curl_multi_wait')
 have_func('curl_multi_socket_action')