curb 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48135be870a425c76338a773b41dc9438883b30cab622cc8c2d81394b860047d
-  data.tar.gz: e7a439c010c1bdbd3ab26b92f2126a4d518a2c7808d7acc6af2e57a03ec07376
+  metadata.gz: 784cff29d3284c08afa7a76364d5643b5d08ecff8802bb7b17e047438074bc37
+  data.tar.gz: 336bff9af874b57b0099da1e9fbde7c9b256e831de819635bc57c947d245c70c
 SHA512:
-  metadata.gz: b5c61d835a10a80211b625dd3ef8cf949fdcf30be9584d2a6793d69e309e3cb283097c2502a8912801ab9ee13679f1e71344034a197c54c88872157e66df74a0
-  data.tar.gz: 20fbde1832dc7338dba7f78c08556eceab4532247f41f0bb1c0c15ba11fc0cd2f07aabeaef62525eba24afc95b5e9854dbb3d71f6d6f493097d614ae913818f8
+  metadata.gz: 02c0c968ada08138391d35a09a85ccc82ab6cf0b17cb9ef71c7a496c6008f74aff97ecacae74bfe10ae958cb6c20907096459c71ab227ad0638a6381e55dd142
+  data.tar.gz: cb575a3ec72ac5b8f1080c7893cd49410ac4285a02044a267335846ff4981a7d3372a087101215413ff2e994ec2f8484787a8b5621a777dd5ca70dd1e8f5c9b3

data/README.md

@@ -105,6 +105,39 @@ puts list.body
 
 If you need a full `LIST` output instead of just names, omit `dirlistonly` and parse the server response accordingly. The key is to let libcurl initiate the data connection (PASV/EPSV) instead of trying to drive it via `ftp_commands`.
 
+#### Full LIST directory listing
+To retrieve the full `LIST` output (permissions, owner, size, timestamp, name), simply do not set `dirlistonly`:
+
+```ruby
+list = Curl::Easy.new('ftp://ftp.example.com/remote/directory/')
+list.username = 'user'
+list.password = 'password'
+
+# Explicitly ensure names+metadata (LIST) rather than NLST
+# list.set(:dirlistonly, 0) # optional; default is LIST for directory URLs
+
+list.perform
+puts list.body # multi-line LIST output
+```
+
+Through an HTTP proxy tunnel, the same considerations apply as the NLST example above — just omit `dirlistonly` and keep the optional EPSV/EPRT/PASV tweaks if needed:
+
+```ruby
+list = Curl::Easy.new('ftp://ftp.example.com/remote/directory/')
+list.username = 'user'
+list.password = 'password'
+list.proxy_url = 'http://proxy.example.com:80'
+list.proxy_tunnel = true
+
+# Optional tweaks if the proxy/server combination struggles
+# list.set(:ftp_use_epsv, 0)
+# list.set(:ftp_use_eprt, 0)
+# list.set(:ftp_skip_pasv_ip, 1)
+
+list.perform
+puts list.body
+```
+
 ### Advanced FTP Usage with Various Options
 ```
 puts "\n=== Advanced FTP Example ==="

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.2.1"
-#define CURB_VER_NUM   1021
+#define CURB_VERSION   "1.2.2"
+#define CURB_VER_NUM   1022
 #define CURB_VER_MAJ   1
 #define CURB_VER_MIN   2
-#define CURB_VER_MIC   1
+#define CURB_VER_MIC   2
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -42,13 +42,34 @@ static VALUE callback_exception(VALUE unused, VALUE exception) {
   return Qfalse;
 }
 
-/* These handle both body and header data */
-static size_t default_data_handler(char *stream,
+/* Default body handler appends to easy.body_data buffer */
+static size_t default_body_handler(char *stream,
                                    size_t size,
                                    size_t nmemb,
-                                   VALUE out) {
-  rb_str_buf_cat(out, stream, size * nmemb);
-  return size * nmemb;
+                                   void *userdata) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)userdata;
+  size_t total = size * nmemb;
+  VALUE out = rb_easy_get("body_data");
+  if (NIL_P(out)) {
+    out = rb_easy_set("body_data", rb_str_buf_new(32768));
+  }
+  rb_str_buf_cat(out, stream, total);
+  return total;
+}
+
+/* Default header handler appends to easy.header_data buffer */
+static size_t default_header_handler(char *stream,
+                                     size_t size,
+                                     size_t nmemb,
+                                     void *userdata) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)userdata;
+  size_t total = size * nmemb;
+  VALUE out = rb_easy_get("header_data");
+  if (NIL_P(out)) {
+    out = rb_easy_set("header_data", rb_str_buf_new(16384));
+  }
+  rb_str_buf_cat(out, stream, total);
+  return total;
 }
 
 // size_t function( void *ptr, size_t size, size_t nmemb, void *stream);
@@ -172,11 +193,16 @@ static VALUE call_progress_handler(VALUE ary) {
                     rb_ary_entry(ary, 4)); // rb_float_new(ulnow));
 }
 
-static int proc_progress_handler(VALUE proc,
+static int proc_progress_handler(void *clientp,
                                  double dltotal,
                                  double dlnow,
                                  double ultotal,
                                  double ulnow) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)clientp;
+  VALUE proc = rb_easy_get("progress_proc");
+  if (proc == Qnil) {
+    return 0;
+  }
   VALUE procret;
   VALUE callargs = rb_ary_new2(5);
 
@@ -205,7 +231,12 @@ static int proc_debug_handler(CURL *curl,
                               curl_infotype type,
                               char *data,
                               size_t data_len,
-                              VALUE proc) {
+                              void *clientp) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)clientp;
+  VALUE proc = rb_easy_get("debug_proc");
+  if (proc == Qnil) {
+    return 0;
+  }
   VALUE callargs = rb_ary_new2(3);
   rb_ary_store(callargs, 0, proc);
   rb_ary_store(callargs, 1, INT2NUM(type));
@@ -238,6 +269,12 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
     if (!NIL_P(multi_val) && RB_TYPE_P(multi_val, T_DATA)) {
       Data_Get_Struct(multi_val, ruby_curl_multi, rbcm);
       if (rbcm) {
+        /* Best-effort: ensure the handle is detached from the multi to
+         * avoid libcurl retaining a dangling pointer to a soon-to-be
+         * cleaned-up easy handle. We cannot raise from GC, so ignore errors. */
+        if (rbcm->handle && rbce->curl) {
+          curl_multi_remove_handle(rbcm->handle, rbce->curl);
+        }
         rb_curl_multi_forget_easy(rbcm, rbce);
       }
     }
@@ -273,6 +310,8 @@ static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
     curl_easy_cleanup(rbce->curl);
     rbce->curl = NULL;
   }
+
+  rbce->self = Qnil;
 }
 
 void curl_easy_free(ruby_curl_easy *rbce) {
@@ -288,6 +327,7 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
 
   memset(rbce->err_buf, 0, CURL_ERROR_SIZE);
 
+  rbce->self = Qnil;
   rbce->curl_headers = NULL;
   rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
@@ -379,13 +419,14 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
   rbce->opts  = Qnil;
 
   ruby_curl_easy_zero(rbce);
+  rbce->self = self;
 
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   rb_easy_set("url", url);
 
   /* set the pointer to the curl handle */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
@@ -450,7 +491,11 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   /* Set the error buffer on the new curl handle using the new err_buf */
   curl_easy_setopt(newrbce->curl, CURLOPT_ERRORBUFFER, newrbce->err_buf);
 
-  return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
+  VALUE clone = Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
+  newrbce->self = clone;
+  curl_easy_setopt(newrbce->curl, CURLOPT_PRIVATE, (void*)newrbce);
+
+  return clone;
 }
 
 /*
@@ -482,9 +527,10 @@ static VALUE ruby_curl_easy_close(VALUE self) {
   rbce->multi = Qnil;
 
   ruby_curl_easy_zero(rbce);
+  rbce->self = self;
 
   /* give the new curl handle a reference back to the ruby object */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
@@ -518,11 +564,12 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
 
   curl_easy_reset(rbce->curl);
   ruby_curl_easy_zero(rbce);
+  rbce->self = self;
 
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   /* reset clobbers the private setting, so reset it to self */
-  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
+  ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
   }
@@ -2389,9 +2436,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     /* clear out the body_data if it was set */
     rb_easy_del("body_data");
   } else {
-    VALUE body_buffer = rb_easy_set("body_data", rb_str_buf_new(32768));
-    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_buffer);
+    rb_easy_set("body_data", rb_str_buf_new(32768));
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, (curl_write_callback)&default_body_handler);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, rbce);
   }
 
   if (!rb_easy_nil("header_proc")) {
@@ -2400,9 +2447,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     /* clear out the header_data if it was set */
     rb_easy_del("header_data");
   } else {
-    VALUE header_buffer = rb_easy_set("header_data", rb_str_buf_new(16384));
-    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_data_handler);
-    curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_buffer);
+    rb_easy_set("header_data", rb_str_buf_new(16384));
+    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, (curl_write_callback)&default_header_handler);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, rbce);
   }
 
   /* encoding */
@@ -2413,20 +2460,21 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
   // progress and debug procs
   if (!rb_easy_nil("progress_proc")) {
     curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, (curl_progress_callback)&proc_progress_handler);
-    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rb_easy_get("progress_proc"));
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce);
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
   } else {
     curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1);
+    curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, rbce);
   }
 
   if (!rb_easy_nil("debug_proc")) {
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, (curl_debug_callback)&proc_debug_handler);
-    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rb_easy_get("debug_proc"));
+    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce);
     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
   } else {
     // have to remove handler to re-enable standard verbosity
     curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, NULL);
-    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, NULL);
+    curl_easy_setopt(curl, CURLOPT_DEBUGDATA, rbce);
     curl_easy_setopt(curl, CURLOPT_VERBOSE, rbce->verbose);
   }
 
@@ -2434,7 +2482,14 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 
   curl_easy_setopt(curl, CURLOPT_HEADER, rbce->header_in_body);
   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, rbce->follow_location);
+#if LIBCURL_VERSION_NUM == 0x081000
+  /* Work around 8.16.0 regression that clamps -1 (infinite) to zero */
+  if (rbce->max_redirs >= 0) {
+    curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+  }
+#else
   curl_easy_setopt(curl, CURLOPT_MAXREDIRS, rbce->max_redirs);
+#endif
 
   curl_easy_setopt(curl, CURLOPT_HTTPPROXYTUNNEL, rbce->proxy_tunnel);
   curl_easy_setopt(curl, CURLOPT_FILETIME, rbce->fetch_file_time);

data/ext/curb_easy.h

@@ -39,6 +39,7 @@ typedef struct {
   /* Buffer for error details from CURLOPT_ERRORBUFFER */
   char err_buf[CURL_ERROR_SIZE];
 
+  VALUE self; /* owning Ruby object */
   VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
   VALUE multi; /* keep a multi handle alive for each easy handle not being used by a multi handle.  This improves easy performance when not within a multi context */
 

data/ext/curb_multi.c

@@ -454,15 +454,56 @@ static void flush_stderr_if_any(ruby_curl_easy *rbce) {
   }
 }
 
+/* Helper to locate the Ruby Easy VALUE from the attached table using the
+ * underlying CURL* handle when CURLINFO_PRIVATE is unavailable or stale. */
+struct find_easy_ctx { CURL *handle; VALUE easy; };
+static int find_easy_by_handle_i(st_data_t key, st_data_t val, st_data_t arg) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)key;
+  struct find_easy_ctx *ctx = (struct find_easy_ctx *)arg;
+  if (rbce && rbce->curl == ctx->handle) {
+    ctx->easy = (VALUE)val;
+    return ST_STOP;
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE find_easy_by_handle(ruby_curl_multi *rbcm, CURL *easy_handle) {
+  if (!rbcm || !rbcm->attached) return Qnil;
+  struct find_easy_ctx ctx; ctx.handle = easy_handle; ctx.easy = Qnil;
+  st_foreach(rbcm->attached, find_easy_by_handle_i, (st_data_t)&ctx);
+  return ctx.easy;
+}
+
 static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int result) {
   long response_code = -1;
-  VALUE easy;
+  VALUE easy = Qnil;
   ruby_curl_easy *rbce = NULL;
   VALUE callargs;
+  ruby_curl_multi *rbcm = NULL;
 
-  CURLcode ecode = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&easy);
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
 
-  Data_Get_Struct(easy, ruby_curl_easy, rbce);
+  /* Try to recover the ruby_curl_easy pointer stored via CURLOPT_PRIVATE. */
+  CURLcode private_rc = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, (char**)&rbce);
+  if (private_rc == CURLE_OK && rbce) {
+    easy = rbce->self;
+  }
+
+  /* If PRIVATE is unavailable or invalid, fall back to scanning attachments. */
+  if (NIL_P(easy) || !RB_TYPE_P(easy, T_DATA)) {
+    easy = find_easy_by_handle(rbcm, easy_handle);
+    if (!NIL_P(easy) && RB_TYPE_P(easy, T_DATA)) {
+      Data_Get_Struct(easy, ruby_curl_easy, rbce);
+    }
+  }
+
+  /* If we still cannot identify the easy handle, remove it and bail. */
+  if (NIL_P(easy) || !RB_TYPE_P(easy, T_DATA) || !rbce) {
+    if (rbcm && rbcm->handle && easy_handle) {
+      curl_multi_remove_handle(rbcm->handle, easy_handle);
+    }
+    return;
+  }
 
   rbce->last_result = result; /* save the last easy result code */
 
@@ -482,10 +523,6 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
   /* Flush again after removal to cover any last buffered data. */
   flush_stderr_if_any(rbce);
 
-  if (ecode != 0) {
-    raise_curl_easy_error_exception(ecode);
-  }
-
   VALUE did_raise = rb_hash_new();
 
   if (!rb_easy_nil("complete_proc")) {

data/tests/tc_curl_easy_request_target.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbCurlEasyRequestTarget < Test::Unit::TestCase
+  include TestServerMethods
+
+  def setup
+    server_setup
+  end
+
+  def test_request_target_absolute_form
+    unless Curl.const_defined?(:CURLOPT_REQUEST_TARGET)
+      omit('libcurl lacks CURLOPT_REQUEST_TARGET support')
+    end
+
+    tmp = Tempfile.new('curb_test_request_target')
+    path = tmp.path
+    fd = IO.sysopen(path, 'w')
+    io = IO.new(fd, 'w')
+    io.sync = true
+
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.verbose = true
+    easy.setopt(Curl::CURLOPT_STDERR, io)
+
+    # Force absolute-form request target, different from the URL host
+    easy.request_target = "http://localhost:#{TestServlet.port}#{TestServlet.path}"
+    easy.headers = { 'Host' => "example.com" }
+
+    easy.perform
+
+    io.flush
+    io.close
+    output = File.read(path)
+
+    assert_match(/GET\s+http:\/\/localhost:#{TestServlet.port}#{Regexp.escape(TestServlet.path)}\s+HTTP\/1\.1/, output)
+    assert_match(/Host:\s+example\.com/, output)
+  ensure
+    tmp.close! if defined?(tmp) && tmp
+  end
+end
+

data/tests/tc_ftp_options.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestCurbFtpOptions < Test::Unit::TestCase
+  # Ensure FTP-related set(:option, ...) mappings are accepted and do not raise
+  # a TypeError (they used to be unsupported in setopt dispatch).
+  def test_can_set_ftp_listing_related_flags
+    c = Curl::Easy.new('ftp://example.com/')
+
+    assert_nothing_raised do
+      c.set(:dirlistonly, true) if Curl.const_defined?(:CURLOPT_DIRLISTONLY)
+      c.set(:ftp_use_epsv, 0)   if Curl.const_defined?(:CURLOPT_FTP_USE_EPSV)
+      # These may not be present on all libcurl builds; guard by constant
+      c.set(:ftp_use_eprt, 0)   if Curl.const_defined?(:CURLOPT_FTP_USE_EPRT)
+      c.set(:ftp_skip_pasv_ip, 1) if Curl.const_defined?(:CURLOPT_FTP_SKIP_PASV_IP)
+    end
+  end
+
+  # Setting ftp_commands remains supported for control-connection commands.
+  def test_can_assign_ftp_commands
+    c = Curl::Easy.new('ftp://example.com/')
+    c.ftp_commands = ["PWD", "CWD /"]
+    assert_kind_of(Array, c.ftp_commands)
+    assert_equal ["PWD", "CWD /"], c.ftp_commands
+  end
+end
+

data/tests/tc_gc_compact.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require File.expand_path('helper', __dir__)
+
+class TestGcCompact < Test::Unit::TestCase
+  ITERATIONS = (ENV['CURB_GC_COMPACT_ITERATIONS'] || 5).to_i
+  EASY_PER_MULTI = 3
+
+  def setup
+    omit('GC.compact unavailable on this Ruby') unless defined?(GC.compact)
+  end
+
+  def test_multi_perform_with_gc_compact
+    ITERATIONS.times do
+      multi = Curl::Multi.new
+      add_easy_handles(multi)
+
+      compact
+      assert_nothing_raised { multi.perform }
+      compact
+    end
+  end
+
+  def test_gc_compact_during_multi_cleanup
+    ITERATIONS.times do
+      multi = Curl::Multi.new
+      add_easy_handles(multi)
+
+      compact
+      multi = nil
+      compact
+    end
+  end
+
+  def test_gc_compact_after_detach
+    multi = Curl::Multi.new
+    handles = add_easy_handles(multi)
+
+    compact
+    assert_nothing_raised { multi.perform }
+
+    handles.each { |easy| multi.remove(easy) }
+    compact
+  end
+
+  private
+
+  def add_easy_handles(multi)
+    Array.new(EASY_PER_MULTI) do
+      Curl::Easy.new($TEST_URL) do |easy|
+        easy.timeout = 5
+        easy.on_complete { |_e| }
+        easy.on_failure { |_e, _code| }
+      end.tap { |easy| multi.add(easy) }
+    end
+  end
+
+  def compact
+    GC.compact
+  end
+end

data/tests/test_basic.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+class TestBasic < Test::Unit::TestCase
+  include TestServerMethods
+  
+  def setup
+    server_setup
+  end
+  
+  def test_basic_request
+    puts "\n=== Testing basic request ==="
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.perform
+    puts "Response code: #{easy.response_code}"
+    puts "Body (first 100 chars): #{easy.body_str[0..100]}"
+    assert_equal 200, easy.response_code
+  end
+  
+  def test_slow_request
+    puts "\n=== Testing slow request ==="
+    url = TestServlet.url_to("/slow?seconds=0.1")
+    puts "URL: #{url}"
+    easy = Curl::Easy.new(url)
+    easy.perform
+    puts "Response code: #{easy.response_code}"
+    puts "Body: #{easy.body_str}"
+    assert_equal 200, easy.response_code
+  end
+end

data/tests/test_fiber_debug.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'async'
+
+class TestFiberDebug < Test::Unit::TestCase
+  include TestServerMethods
+  
+  def setup
+    server_setup
+  end
+  
+  def test_simple_fiber_request
+    puts "\n=== Starting simple fiber request test ==="
+    
+    run_async do |task|
+      puts "Inside Async block"
+      puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+      
+      multi = Curl::Multi.new
+      easy = Curl::Easy.new(TestServlet.url)
+      easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+      
+      multi.add(easy)
+      puts "Added easy handle to multi"
+      
+      # Perform without block first
+      puts "Calling perform..."
+      multi.perform
+      puts "Perform completed"
+    end
+    
+    puts "Test completed"
+  end
+  
+  def test_fiber_with_block
+    puts "\n=== Starting fiber with block test ==="
+    
+    run_async do |task|
+      puts "Inside Async block"
+      
+      multi = Curl::Multi.new
+      easy = Curl::Easy.new(TestServlet.url_to("/slow?seconds=0.1"))
+      easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+      
+      multi.add(easy)
+      
+      block_calls = 0
+      multi.perform do
+        block_calls += 1
+        puts "Block called: #{block_calls}"
+        if block_calls < 5  # Limit iterations to prevent infinite loop
+          Async::Task.yield
+        end
+      end
+      
+      puts "Perform completed, block called #{block_calls} times"
+    end
+    
+    puts "Test completed"
+  end
+
+  private
+  def run_async(&block)
+    if defined?(Async) && Async.respond_to?(:run)
+      Async.run(&block)
+    else
+      Async(&block)
+    end
+  end
+end

data/tests/test_fiber_simple.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+require 'async'
+
+class TestFiberSimple < Test::Unit::TestCase
+  include TestServerMethods
+  
+  def setup
+    server_setup
+  end
+  
+  def test_simple_concurrent
+    puts "\n=== Testing simple concurrent requests ==="
+    
+    results = []
+    
+    if Async.respond_to?(:run)
+      Async.run do |task|
+        puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+        
+        multi = Curl::Multi.new
+        
+        # Add 3 requests
+        3.times do |i|
+          easy = Curl::Easy.new(TestServlet.url_to("/slow?seconds=0.2&id=#{i}"))
+          easy.on_complete { |curl| 
+            results << { id: i, code: curl.response_code }
+            puts "Request #{i} completed"
+          }
+          multi.add(easy)
+        end
+        
+        puts "Starting perform..."
+        start_time = Time.now
+        multi.perform  # No block
+        elapsed = Time.now - start_time
+        puts "Perform completed in #{elapsed.round(2)}s"
+      end
+    else
+      Async do |task|
+      puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+      
+      multi = Curl::Multi.new
+      
+      # Add 3 requests
+      3.times do |i|
+        easy = Curl::Easy.new(TestServlet.url_to("/slow?seconds=0.2&id=#{i}"))
+        easy.on_complete { |curl| 
+          results << { id: i, code: curl.response_code }
+          puts "Request #{i} completed"
+        }
+        multi.add(easy)
+      end
+      
+      puts "Starting perform..."
+      start_time = Time.now
+      multi.perform  # No block
+      elapsed = Time.now - start_time
+      puts "Perform completed in #{elapsed.round(2)}s"
+      end
+    end
+    
+    assert_equal 3, results.size
+    results.each { |r| assert_equal 200, r[:code] }
+  end
+end

data/tests/test_real_url.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/curb'))
+require 'async'
+
+puts "Testing fiber scheduler with real URLs..."
+
+# Test without fiber scheduler
+puts "\n1. Without fiber scheduler:"
+start = Time.now
+multi = Curl::Multi.new
+
+easies = []
+3.times do |i|
+  easy = Curl::Easy.new("https://httpbin.org/delay/1")
+  easy.on_complete { |curl| puts "Request #{i} completed: #{curl.response_code}" }
+  multi.add(easy)
+  easies << easy
+end
+
+multi.perform
+elapsed = Time.now - start
+puts "Total time: #{elapsed.round(2)}s"
+
+# Test with fiber scheduler
+puts "\n2. With fiber scheduler:"
+if Async.respond_to?(:run)
+  Async.run do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    start = Time.now
+    multi = Curl::Multi.new
+    
+    easies = []
+    3.times do |i|
+      easy = Curl::Easy.new("https://httpbin.org/delay/1")
+      easy.on_complete { |curl| puts "Request #{i} completed: #{curl.response_code}" }
+      multi.add(easy)
+      easies << easy
+    end
+    
+    multi.perform
+    elapsed = Time.now - start
+    puts "Total time: #{elapsed.round(2)}s"
+  end
+else
+  Async do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    start = Time.now
+    multi = Curl::Multi.new
+    
+    easies = []
+    3.times do |i|
+      easy = Curl::Easy.new("https://httpbin.org/delay/1")
+      easy.on_complete { |curl| puts "Request #{i} completed: #{curl.response_code}" }
+      multi.add(easy)
+      easies << easy
+    end
+    
+    multi.perform
+    elapsed = Time.now - start
+    puts "Total time: #{elapsed.round(2)}s"
+  end
+end
+
+puts "\nDone!"

data/tests/test_simple_fiber.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/curb'))
+require 'async'
+
+puts "Testing simple fiber scheduler..."
+
+if Async.respond_to?(:run)
+  Async.run do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new("https://httpbin.org/delay/1")
+    easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+    
+    multi.add(easy)
+    puts "Starting perform..."
+    multi.perform
+    puts "Perform completed"
+  end
+else
+  Async do
+    puts "Fiber scheduler available: #{Curl::Multi.fiber_scheduler_available?}"
+    
+    multi = Curl::Multi.new
+    easy = Curl::Easy.new("https://httpbin.org/delay/1")
+    easy.on_complete { |curl| puts "Request completed: #{curl.response_code}" }
+    
+    multi.add(easy)
+    puts "Starting perform..."
+    multi.perform
+    puts "Perform completed"
+  end
+end
+
+puts "Done!"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2025-09-17 00:00:00.000000000 Z
+date: 2025-09-18 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
@@ -69,6 +69,7 @@ files:
 - tests/tc_curl_download.rb
 - tests/tc_curl_easy.rb
 - tests/tc_curl_easy_cookielist.rb
+- tests/tc_curl_easy_request_target.rb
 - tests/tc_curl_easy_resolve.rb
 - tests/tc_curl_easy_setopt.rb
 - tests/tc_curl_maxfilesize.rb
@@ -76,6 +77,13 @@ files:
 - tests/tc_curl_postfield.rb
 - tests/tc_curl_protocols.rb
 - tests/tc_fiber_scheduler.rb
+- tests/tc_ftp_options.rb
+- tests/tc_gc_compact.rb
+- tests/test_basic.rb
+- tests/test_fiber_debug.rb
+- tests/test_fiber_simple.rb
+- tests/test_real_url.rb
+- tests/test_simple_fiber.rb
 - tests/timeout.rb
 - tests/timeout_server.rb
 - tests/unittests.rb
@@ -130,6 +138,7 @@ test_files:
 - tests/tc_curl_download.rb
 - tests/tc_curl_easy.rb
 - tests/tc_curl_easy_cookielist.rb
+- tests/tc_curl_easy_request_target.rb
 - tests/tc_curl_easy_resolve.rb
 - tests/tc_curl_easy_setopt.rb
 - tests/tc_curl_maxfilesize.rb
@@ -137,6 +146,13 @@ test_files:
 - tests/tc_curl_postfield.rb
 - tests/tc_curl_protocols.rb
 - tests/tc_fiber_scheduler.rb
+- tests/tc_ftp_options.rb
+- tests/tc_gc_compact.rb
+- tests/test_basic.rb
+- tests/test_fiber_debug.rb
+- tests/test_fiber_simple.rb
+- tests/test_real_url.rb
+- tests/test_simple_fiber.rb
 - tests/timeout.rb
 - tests/timeout_server.rb
 - tests/unittests.rb