curb 1.3.4 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91423579fc22ce296ae84abfa27438de27d2e9bf6da58658ce86939aabecfe86
-  data.tar.gz: 46f1a051e546934eee05283bdbed84635ae1be3f46adaf48625140f260feb27f
+  metadata.gz: a502fb4afad21a24a20302b7522b616b08afbbe3d4b5b2a3eeee46d83b53c50d
+  data.tar.gz: 5e68fd3f3380f2045dfc6d4e8e157ebbb9fc56e4b76601574c92a755665eeef2
 SHA512:
-  metadata.gz: b863797088f6ade8e6a48c3018a7f24b4469fda0daa35cabdacc826452b31c028ba75a2d0fd9bfefeb90817a39421110979d7013b0a573c7b06016f27e7d93fd
-  data.tar.gz: 851be0f60e8e7e53db42f2e6b03742c403c55c7d2242282dd4bab8b77f33c4b0eb206fb221c7f26d26dafa2f6fdddd7a0e84369ca94a0afd038510910cf7d5de
+  metadata.gz: 940f343ad1d926ddcf27b994bca191e131176e766dce3d7f211f9ed5b28917ffb9ebfa5b8f71247ac8ca8a0b916e6565b60fb2ae57a964770b3273d1bd7d5d69
+  data.tar.gz: 77a44dd831eea50e786d4b4871c2f1702e3bee2c74d0484f7b0812a91d19d4bcdd79c12e20dce7cd8ffcbaf0e06ae77cc6cc7734b7c71fa2feabc636af82b0d8

data/Rakefile

@@ -106,7 +106,24 @@ else
   task :alltests => [:unittests, :bugtests]
 end
 
-RubyMemcheck.config(binary_name: 'curb_core')
+ruby_memcheck_config = { binary_name: 'curb_core' }
+
+if RUBY_ENGINE == 'ruby' && RUBY_VERSION == '4.0.4'
+  # Ruby 4.0.4 reports fiber/block-handler VM stack accesses under Valgrind.
+  # Keep reporting errors that originate in curb_core, but filter Ruby-side noise.
+  ruby_memcheck_config[:filter_all_errors] = true
+  if RubyMemcheck::Configuration.instance_method(:initialize).parameters.any? { |type, name|
+       type == :key && name == :use_only_ruby_free_at_exit
+     }
+    ruby_memcheck_config[:use_only_ruby_free_at_exit] = false
+  end
+  ruby_memcheck_config[:skipped_ruby_functions] =
+    RubyMemcheck::Configuration::DEFAULT_SKIPPED_RUBY_FUNCTIONS + [
+      /\Arb_vm_frame_block_handler\z/
+    ]
+end
+
+RubyMemcheck.config(**ruby_memcheck_config)
 namespace :test do
   RubyMemcheck::TestTask.new(valgrind: :compile) do|t|
     t.test_files = FileList['tests/tc_*.rb']

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.4"
-#define CURB_VER_NUM   1034
+#define CURB_VERSION   "1.3.5"
+#define CURB_VER_NUM   1035
 #define CURB_VER_MAJ   1
 #define CURB_VER_MIN   3
-#define CURB_VER_MIC   4
+#define CURB_VER_MIC   5
 #define CURB_VER_PATCH 0
 
 

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,7 @@ extern VALUE mCurl;
 static VALUE idCall;
 static ID id_deferred_exception_ivar;
 static ID id_deferred_exception_source_id_ivar;
+static ID id_socket_io_cache_ivar;
 
 #ifdef RDOC_NEVER_DEFINED
   mCurl = rb_define_module("Curl");
@@ -1070,10 +1075,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 +1141,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 +1225,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 +1244,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,22 +1317,102 @@ 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 */
@@ -1299,17 +1424,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)) {
+      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;
     int wait_what = 0;
@@ -1333,50 +1465,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 +1584,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 +1627,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 +1636,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 +1650,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 +1674,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,7 +1688,7 @@ 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);
     }
 
     if (did_timeout) {
@@ -1516,7 +1723,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 +1739,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 +1761,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 +1773,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 +2066,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 +2190,7 @@ 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_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/extconf.rb

@@ -691,6 +691,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')

data/tests/tc_curl_multi.rb

@@ -249,6 +249,41 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m.close if m
   end
 
+  def test_multi_perform_runs_work_added_from_final_idle_yield
+    with_queue_refill_test_server do |port, hits|
+      previous_autoclose = Curl::Multi.autoclose
+      Curl::Multi.autoclose = true
+
+      multi = Curl::Multi.new
+      slow = Curl::Easy.new("http://127.0.0.1:#{port}/slow")
+      queued = Curl::Easy.new("http://127.0.0.1:#{port}/queued")
+      completions = []
+      empty_yields = 0
+      queued_added = false
+
+      slow.on_complete { completions << :slow }
+      queued.on_complete { completions << :queued }
+
+      multi.add(slow)
+      multi.perform do |performing_multi|
+        empty_yields += 1 if performing_multi.requests.empty?
+        if !queued_added && empty_yields >= 2
+          queued_added = true
+          performing_multi.add(queued)
+        end
+      end
+
+      assert queued_added, "test should add queued work from the final idle yield"
+      assert_equal [:slow, :queued], completions
+      assert_equal 1, hits[:slow]
+      assert_equal 1, hits[:queued]
+      assert_equal 0, multi.requests.length
+    ensure
+      Curl::Multi.autoclose = previous_autoclose if defined?(previous_autoclose)
+      multi.close if defined?(multi) && multi
+    end
+  end
+
   def test_multi_easy_get
     n = 1
     urls = []

data/tests/tc_fiber_scheduler.rb

@@ -15,10 +15,11 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
   include TestServerMethods
 
   class RecordingScheduler
-    attr_reader :io_wait_events
+    attr_reader :io_wait_events, :io_select_calls
 
     def initialize
       @io_wait_events = []
+      @io_select_calls = 0
     end
 
     def fiber(&block)
@@ -31,7 +32,7 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
 
       readers = (events & IO::READABLE) != 0 ? [io] : nil
       writers = (events & IO::WRITABLE) != 0 ? [io] : nil
-      readable, writable = IO.select(readers, writers, nil, timeout)
+      readable, writable = blocking_io { IO.select(readers, writers, nil, timeout) }
 
       ready = 0
       ready |= IO::READABLE if readable && !readable.empty?
@@ -39,6 +40,11 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
       ready.zero? ? false : ready
     end
 
+    def io_select(readers, writers, excepts, timeout = nil)
+      @io_select_calls += 1
+      blocking_io { IO.select(readers, writers, excepts, timeout) }
+    end
+
     def kernel_sleep(duration = nil)
       sleep(duration || 0)
     end
@@ -56,6 +62,16 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
 
     def fiber_interrupt(*)
     end
+
+    private
+
+    def blocking_io(&block)
+      if Fiber.respond_to?(:blocking)
+        Fiber.blocking(&block)
+      else
+        block.call
+      end
+    end
   end
 
   ITERS = 4
@@ -208,9 +224,11 @@ class TestCurbFiberScheduler < Test::Unit::TestCase
     end
 
     assert_equal 200, result
-    assert_operator scheduler.io_wait_events.length, :>=, 1
-    assert scheduler.io_wait_events.all? { |events| events.is_a?(Integer) }
-    assert scheduler.io_wait_events.any? { |events| (events & (IO::READABLE | IO::WRITABLE)) != 0 }
+    assert_operator scheduler.io_wait_events.length + scheduler.io_select_calls, :>=, 1
+    unless scheduler.io_wait_events.empty?
+      assert scheduler.io_wait_events.all? { |events| events.is_a?(Integer) }
+      assert scheduler.io_wait_events.any? { |events| (events & (IO::READABLE | IO::WRITABLE)) != 0 }
+    end
   end
 
   def test_multi_reuse_after_scheduler_perform

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.5
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2026-05-12 00:00:00.000000000 Z
+date: 2026-05-14 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
@@ -107,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Ruby libcurl bindings
 test_files: