curb 1.2.0 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 832660904f4d95f97b0795a4e39850f2fca2c70e521a0bb795a9c551f6fdf9f3
-  data.tar.gz: 903cb16a9a77396e90ea9ab2f33fb94a84d6a811525d23506af43195ab49fec2
+  metadata.gz: 784cff29d3284c08afa7a76364d5643b5d08ecff8802bb7b17e047438074bc37
+  data.tar.gz: 336bff9af874b57b0099da1e9fbde7c9b256e831de819635bc57c947d245c70c
 SHA512:
-  metadata.gz: bf99199469304444421b00adbaa2b64707c7eddcdaff9a3c662531ebf5f2220a1b6555145fa516422921ac0980c851e7ce234ff88391d608ca6783211f364ddf
-  data.tar.gz: 41aec998852a8458ed9f5508f37374ac72fb170c4235a7279e4f9864d2af143281cd81e1dec6099c80765d97b2263d1ee34bebd2b193701b9a4175a024ca5991
+  metadata.gz: 02c0c968ada08138391d35a09a85ccc82ab6cf0b17cb9ef71c7a496c6008f74aff97ecacae74bfe10ae958cb6c20907096459c71ab227ad0638a6381e55dd142
+  data.tar.gz: cb575a3ec72ac5b8f1080c7893cd49410ac4285a02044a267335846ff4981a7d3372a087101215413ff2e994ec2f8484787a8b5621a777dd5ca70dd1e8f5c9b3

data/README.md

@@ -74,7 +74,66 @@ puts "\n=== FTP Directory Listing Example ==="
 list = Curl::Easy.new('ftp://ftp.example.com/remote/directory/')
 list.username = 'user'
 list.password = 'password'
-list.dirlistonly = true
+list.set(:dirlistonly, 1)
+list.perform
+puts list.body
+```
+
+### FTP over HTTP proxy tunnel (NLST/LIST)
+When listing directories through an HTTP proxy with `proxy_tunnel` (CONNECT), let libcurl manage the passive data connection. Do not send `PASV`/`EPSV` or `NLST` via `easy.ftp_commands` — QUOTE commands run on the control connection and libcurl will not open the data connection, resulting in 425 errors.
+
+To get NLST-like output safely:
+
+```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
+
+# Ask libcurl to perform a listing (names only)
+list.set(:dirlistonly, 1)
+
+# If the proxy or server has trouble with EPSV/EPRT, you can adjust:
+# list.set(:ftp_use_epsv, 0)       # disable EPSV
+# list.set(:ftp_use_eprt, 0)       # disable EPRT (stick to IPv4 PASV)
+# list.set(:ftp_skip_pasv_ip, 1)   # ignore PASV host, reuse control host
+
+list.perform
+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
 ```
@@ -327,6 +386,8 @@ end
 
 ### HTTP POST form:
 
+Note: Instance methods like `easy.http_post(...)` do not accept a URL argument. Set the URL first (for example, `Curl::Easy.new(url)` or `easy.url = url`) and then call `easy.http_post(...)`. If you want to pass the URL directly to the call, use the class/module helpers such as `Curl::Easy.http_post(url, ...)` or `Curl.post(url, ...)`.
+
 ```ruby
 c = Curl::Easy.http_post("http://my.rails.box/thing/create",
                          Curl::PostField.content('thing[name]', 'box'),
@@ -339,6 +400,19 @@ c = Curl::Easy.http_post("http://my.rails.box/thing/create",
 c = Curl::Easy.new("http://my.rails.box/files/upload")
 c.multipart_form_post = true
 c.http_post(Curl::PostField.file('thing[file]', 'myfile.rb'))
+
+### Custom request target
+
+Some advanced scenarios need a request-target that differs from the URL host/path (for example, absolute-form targets or special values like `*`). If your libcurl supports `CURLOPT_REQUEST_TARGET` (libcurl ≥ 7.55), you can override it:
+
+```ruby
+c = Curl::Easy.new("http://127.0.0.1:9129/methods")
+c.request_target = "http://localhost:9129/methods"  # absolute-form target
+c.headers = { 'Host' => 'example.com' }              # override Host header if needed
+c.perform
+```
+
+For HTTPS, prefer `easy.resolve = ["host:443:IP"]` to keep Host/SNI/certificates aligned.
 ```
 
 ### Using HTTP/2
@@ -418,3 +492,31 @@ end
 * `on_missing` is called when the response code is 4xx
 * `on_failure` is called when the response code is 5xx
 * `on_complete` is called in all cases.
+
+### Cookies
+
+- Manual cookies: Set the outgoing `Cookie` header via `easy.cookies = "name=value; other=val"`. This only affects the request header and does not modify libcurl's internal cookie engine.
+- Cookie engine: Enable with `easy.enable_cookies = true`. Optionally set `easy.cookiefile` (to load) and/or `easy.cookiejar` (to persist). Cookies received via `Set-Cookie` go into this engine.
+- Inspect engine cookies: `easy.cookielist` returns an array of strings (Netscape or Set-Cookie format).
+- Modify engine cookies: use `easy.cookielist = ...` or `easy.set(:cookielist, ...)` with either a `Set-Cookie` style string, Netscape cookie lines, or special commands: `"ALL"` (clear), `"SESS"` (remove session cookies), `"FLUSH"` (write to jar), `"RELOAD"` (reload from file).
+- Clearing manual cookies: assign an empty string (`easy.cookies = ''`). Assigning `nil` has no effect in current versions.
+
+Examples:
+
+```ruby
+easy = Curl::Easy.new("https://example.com")
+
+# Use the cookie engine and persist cookies
+easy.enable_cookies = true
+easy.cookiejar = "/tmp/cookies.txt"
+easy.perform
+
+# Later: inspect and tweak engine cookies
+p easy.cookielist
+easy.cookielist = 'ALL' # clear stored cookies
+
+# Send custom Cookie header for a single request
+easy.cookies = "flag=1; session_override=abc"
+easy.perform
+easy.cookies = ''  # clear manual Cookie header
+```

data/ext/curb.c

@@ -616,6 +616,11 @@ void Init_curb_core() {
 #if HAVE_CURLOPT_PROXYHEADER
   CURB_DEFINE(CURLOPT_PROXYHEADER);
 #endif
+#if HAVE_CURLOPT_REQUEST_TARGET
+  /* Allows overriding the Request-URI target used in the request line.
+   * Useful for absolute-form requests or special targets like "*". */
+  CURB_DEFINE(CURLOPT_REQUEST_TARGET);
+#endif
 #if HAVE_CURLOPT_HTTP200ALIASES
   CURB_DEFINE(CURLOPT_HTTP200ALIASES);
 #endif

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.0"
-#define CURB_VER_NUM   1020
+#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   0
+#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));
@@ -225,6 +256,30 @@ void curl_easy_mark(ruby_curl_easy *rbce) {
 }
 
 static void ruby_curl_easy_free(ruby_curl_easy *rbce) {
+  if (!rbce) {
+    return;
+  }
+
+  if (!NIL_P(rbce->multi)) {
+    VALUE multi_val = rbce->multi;
+    ruby_curl_multi *rbcm = NULL;
+
+    rbce->multi = Qnil;
+
+    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);
+      }
+    }
+  }
+
   if (rbce->curl_headers) {
     curl_slist_free_all(rbce->curl_headers);
   }
@@ -255,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) {
@@ -270,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;
@@ -310,6 +368,7 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
+  rbce->cookielist_engine_enabled = 0;
   rbce->ignore_content_length = 0;
   rbce->callback_active = 0;
   rbce->last_result = 0;
@@ -360,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);
   }
@@ -431,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;
 }
 
 /*
@@ -463,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);
   }
@@ -499,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);
   }
@@ -664,7 +730,16 @@ static VALUE ruby_curl_easy_proxypwd_get(VALUE self) {
  * call-seq:
  *   easy.cookies                                     => "name1=content1; name2=content2;"
  *
- * Obtain the cookies for this Curl::Easy instance.
+ * Obtain the manually set Cookie header string for this Curl::Easy instance.
+ *
+ * Notes:
+ * - This corresponds to libcurl's CURLOPT_COOKIE and only affects the outgoing
+ *   Cookie request header. It does NOT modify the internal libcurl cookie engine
+ *   that stores cookies received via Set-Cookie.
+ * - To inspect or modify cookies stored in the cookie engine, use
+ *   +easy.cookielist+ (getter) and +easy.cookielist=+ or +easy.set(:cookielist, ...)+ (setter).
+ * - To clear a previously set manual Cookie header, assign an empty string.
+ *   Assigning +nil+ currently has no effect.
  */
 static VALUE ruby_curl_easy_cookies_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, cookies);
@@ -674,7 +749,8 @@ static VALUE ruby_curl_easy_cookies_get(VALUE self) {
  * call-seq:
  *   easy.cookiefile                                  => string
  *
- * Obtain the cookiefile file for this Curl::Easy instance.
+ * Obtain the cookiefile path for this Curl::Easy instance (used to load cookies when the
+ * cookie engine is enabled).
  */
 static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, cookiefile);
@@ -684,7 +760,8 @@ static VALUE ruby_curl_easy_cookiefile_get(VALUE self) {
  * call-seq:
  *   easy.cookiejar                                   => string
  *
- * Obtain the cookiejar file to use for this Curl::Easy instance.
+ * Obtain the cookiejar path for this Curl::Easy instance (used to persist cookies when the
+ * cookie engine is enabled).
  */
 static VALUE ruby_curl_easy_cookiejar_get(VALUE self) {
   CURB_OBJECT_HGETTER(ruby_curl_easy, cookiejar);
@@ -984,7 +1061,15 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
  * call-seq:
  *   easy.ftp_commands = ["CWD /", "MKD directory"]   => ["CWD /", ...]
  *
- * Explicitly sets the list of commands to execute on the FTP server when calling perform
+ * Explicitly sets the list of commands to execute on the FTP server when calling perform.
+ *
+ * NOTE:
+ * - This maps to libcurl CURLOPT_QUOTE; it sends commands on the control connection.
+ * - Do not include data-transfer commands like LIST/NLST/RETR/STOR here. libcurl does not
+ *   parse PASV/EPSV replies from QUOTE commands and will not establish the required data
+ *   connection. For directory listings, set CURLOPT_DIRLISTONLY (via `easy.set(:dirlistonly, true)`)
+ *   and request an FTP directory URL (e.g. "ftp://host/path/") so libcurl manages PASV/EPSV
+ *   and the data connection for you.
  */
 static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
   CURB_OBJECT_HSETTER(ruby_curl_easy, ftp_commands);
@@ -1893,7 +1978,12 @@ static VALUE ruby_curl_easy_multipart_form_post_q(VALUE self) {
  *   easy.enable_cookies = boolean                    => boolean
  *
  * Configure whether the libcurl cookie engine is enabled for this Curl::Easy
- * instance.
+ * instance. When enabled, cookies received via Set-Cookie are stored by libcurl
+ * and automatically sent on subsequent matching requests. Use +easy.cookiefile+
+ * to load cookies and +easy.cookiejar+ to persist them.
+ *
+ * This setting is independent from the manual Cookie header set via +easy.cookies+.
+ * The manual header is additive and can be cleared by assigning an empty string.
  */
 static VALUE ruby_curl_easy_enable_cookies_set(VALUE self, VALUE enable_cookies)
 {
@@ -2346,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")) {
@@ -2357,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 */
@@ -2370,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);
   }
 
@@ -2391,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);
@@ -2486,9 +2584,8 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
 #endif
   }
 
-  /* Set up HTTP cookie handling if necessary
-     FIXME this may not get disabled if it's enabled, the disabled again from ruby.
-     */
+  /* Set up HTTP cookie handling if necessary */
+  /* Enable/attach cookie engine if requested, or implicitly via COOKIELIST usage */
   if (rbce->enable_cookies) {
     if (!rb_easy_nil("cookiejar")) {
       curl_easy_setopt(curl, CURLOPT_COOKIEJAR, rb_easy_get_str("cookiejar"));
@@ -2499,6 +2596,9 @@ VALUE ruby_curl_easy_setup(ruby_curl_easy *rbce) {
     } else {
       curl_easy_setopt(curl, CURLOPT_COOKIEFILE, ""); /* "" = magic to just enable */
     }
+  } else if (rbce->cookielist_engine_enabled) {
+    /* Ensure cookie engine is enabled even if enable_cookies? is false. */
+    curl_easy_setopt(curl, CURLOPT_COOKIEFILE, "");
   }
 
   if (!rb_easy_nil("cookies")) {
@@ -3595,6 +3695,12 @@ static VALUE ruby_curl_easy_num_connects_get(VALUE self) {
  * Returned strings are in Netscape cookiejar format or in Set-Cookie format.
  * Since 7.43.0 cookies in the Set-Cookie format without a domain name are not exported.
  *
+ * To modify the cookie engine (add/replace/remove), use +easy.cookielist= string+
+ * or +easy.set(:cookielist, string)+ with one of the following accepted inputs:
+ * - A Set-Cookie style header string: "Set-Cookie: name=value; Domain=example.com; Path=/; Expires=..."
+ * - One or more lines in Netscape cookie file format (tab-separated fields)
+ * - Special commands: "ALL" (clear all), "SESS" (remove session cookies), "FLUSH" (write to jar), "RELOAD" (reload from file)
+ *
  * @see https://curl.se/libcurl/c/CURLINFO_COOKIELIST.html option <code>CURLINFO_COOKIELIST</code> of 
  *   <code>curl_easy_getopt(3)</code> to see how libcurl behaves.
  * @note requires libcurl 7.14.1 or higher, otherwise +-1+ is always returned
@@ -3656,7 +3762,7 @@ static VALUE ruby_curl_easy_ftp_entry_path_get(VALUE self) {
     return Qnil;
   }
 #else
-  rb_warn("Installed libcurl is too old to support num_connects");
+  rb_warn("Installed libcurl is too old to support ftp_entry_path");
   return Qnil;
 #endif
 }
@@ -3815,9 +3921,72 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     VALUE cookiejar = val;
     CURB_OBJECT_HSETTER(ruby_curl_easy, cookiejar);
     } break;
+#if HAVE_CURLOPT_REQUEST_TARGET
+  case CURLOPT_REQUEST_TARGET: {
+    /* Forward request-target directly to libcurl as a string. */
+    curl_easy_setopt(rbce->curl, CURLOPT_REQUEST_TARGET, NIL_P(val) ? NULL : StringValueCStr(val));
+    } break;
+#endif
   case CURLOPT_TCP_NODELAY: {
     curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
     } break;
+  /* FTP-specific toggles */
+#if HAVE_CURLOPT_DIRLISTONLY
+  case CURLOPT_DIRLISTONLY: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_DIRLISTONLY, NUM2LONG(value));
+    } break;
+#endif
+#if HAVE_CURLOPT_FTP_USE_EPSV
+  case CURLOPT_FTP_USE_EPSV: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_EPSV, NUM2LONG(value));
+    } break;
+#endif
+#if HAVE_CURLOPT_FTP_USE_EPRT
+  case CURLOPT_FTP_USE_EPRT: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_EPRT, NUM2LONG(value));
+    } break;
+#endif
+#if HAVE_CURLOPT_FTP_SKIP_PASV_IP
+  case CURLOPT_FTP_SKIP_PASV_IP: {
+    int type = rb_type(val);
+    VALUE value;
+    if (type == T_TRUE) {
+      value = rb_int_new(1);
+    } else if (type == T_FALSE) {
+      value = rb_int_new(0);
+    } else {
+      value = rb_funcall(val, rb_intern("to_i"), 0);
+    }
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_SKIP_PASV_IP, NUM2LONG(value));
+    } break;
+#endif
   case CURLOPT_RANGE: {
     curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
     } break;
@@ -3895,8 +4064,23 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
 #endif
 #if HAVE_CURLOPT_COOKIELIST
   case CURLOPT_COOKIELIST: {
+	/* Forward to libcurl */
 	curl_easy_setopt(rbce->curl, CURLOPT_COOKIELIST, StringValueCStr(val));
-    } break;
+	/* Track whether the cookie engine should be enabled for requests.
+	 * According to libcurl docs, CURLOPT_COOKIELIST also enables the cookie engine
+	 * when provided with a non-command string. Some environments may still require
+	 * an explicit "enable" via CURLOPT_COOKIEFILE="" to send cookies on requests.
+	 * We do that in the perform setup when this flag is set.
+	 */
+	if (RB_TYPE_P(val, T_STRING)) {
+	  const char *s = StringValueCStr(val);
+	  if (!(strcmp(s, "ALL") == 0 || strcmp(s, "SESS") == 0 || strcmp(s, "FLUSH") == 0 || strcmp(s, "RELOAD") == 0)) {
+	    rbce->cookielist_engine_enabled = 1;
+	  }
+	} else {
+	  /* Non-string values are unexpected; be conservative and do not enable. */
+	}
+  } break;
 #endif
 #if HAVE_CURLOPT_PROXY_SSL_VERIFYHOST
   case CURLOPT_PROXY_SSL_VERIFYHOST:

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 */
 
@@ -77,6 +78,7 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
+  char cookielist_engine_enabled; /* track if CURLOPT_COOKIELIST was used with a non-command to enable engine */
   char ignore_content_length;
   char callback_active;
 

data/ext/curb_multi.c

@@ -76,6 +76,10 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy);
 static void rb_curl_multi_read_info(VALUE self, CURLM *mptr);
 static void rb_curl_multi_run(VALUE self, CURLM *multi_handle, int *still_running);
 
+static int detach_easy_entry(st_data_t key, st_data_t val, st_data_t arg);
+static void rb_curl_multi_detach_all(ruby_curl_multi *rbcm);
+static void curl_multi_mark(void *ptr);
+
 static VALUE callback_exception(VALUE did_raise, VALUE exception) {
   // TODO: we could have an option to enable exception reporting
 /*  VALUE ret = rb_funcall(exception, rb_intern("message"), 0);
@@ -97,8 +101,67 @@ static VALUE callback_exception(VALUE did_raise, VALUE exception) {
   return exception;
 }
 
+static int detach_easy_entry(st_data_t key, st_data_t val, st_data_t arg) {
+  ruby_curl_multi *rbcm = (ruby_curl_multi *)arg;
+  VALUE easy = (VALUE)val;
+  ruby_curl_easy *rbce = NULL;
+
+  if (RB_TYPE_P(easy, T_DATA)) {
+    Data_Get_Struct(easy, ruby_curl_easy, rbce);
+  }
+
+  if (!rbce) {
+    return ST_CONTINUE;
+  }
+
+  if (rbcm && rbcm->handle && rbce->curl) {
+    curl_multi_remove_handle(rbcm->handle, rbce->curl);
+  }
+
+  rbce->multi = Qnil;
+
+  return ST_CONTINUE;
+}
+
+void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr) {
+  ruby_curl_easy *rbce = (ruby_curl_easy *)rbce_ptr;
+
+  if (!rbcm || !rbce || !rbcm->attached) {
+    return;
+  }
+
+  st_data_t key = (st_data_t)rbce;
+  st_delete(rbcm->attached, &key, NULL);
+}
+
+static void rb_curl_multi_detach_all(ruby_curl_multi *rbcm) {
+  if (!rbcm || !rbcm->attached) {
+    return;
+  }
+
+  st_table *attached = rbcm->attached;
+  rbcm->attached = NULL;
+
+  st_foreach(attached, detach_easy_entry, (st_data_t)rbcm);
+
+  st_free_table(attached);
+
+  rbcm->active = 0;
+  rbcm->running = 0;
+}
+
 void curl_multi_free(ruby_curl_multi *rbcm) {
-  curl_multi_cleanup(rbcm->handle);
+  if (!rbcm) {
+    return;
+  }
+
+  rb_curl_multi_detach_all(rbcm);
+
+  if (rbcm->handle) {
+    curl_multi_cleanup(rbcm->handle);
+    rbcm->handle = NULL;
+  }
+
   free(rbcm);
 }
 
@@ -110,6 +173,18 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
 
   rbcm->active = 0;
   rbcm->running = 0;
+
+  if (rbcm->attached) {
+    st_free_table(rbcm->attached);
+    rbcm->attached = NULL;
+  }
+
+  rbcm->attached = st_init_numtable();
+  if (!rbcm->attached) {
+    curl_multi_cleanup(rbcm->handle);
+    rbcm->handle = NULL;
+    rb_raise(rb_eNoMemError, "Failed to allocate multi attachment table");
+  }
 }
 
 /*
@@ -124,6 +199,8 @@ VALUE ruby_curl_multi_new(VALUE klass) {
     rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::Multi");
   }
 
+  MEMZERO(rbcm, ruby_curl_multi, 1);
+
   ruby_curl_multi_init(rbcm);
 
   /*
@@ -131,8 +208,8 @@ VALUE ruby_curl_multi_new(VALUE klass) {
    * If your structure references other Ruby objects, then your mark function needs to
    * identify these objects using rb_gc_mark(value). If the structure doesn't reference
    * other Ruby objects, you can simply pass 0 as a function pointer.
-  */
-  return Data_Wrap_Struct(klass, 0, curl_multi_free, rbcm);
+   */
+  return Data_Wrap_Struct(klass, curl_multi_mark, curl_multi_free, rbcm);
 }
 
 /*
@@ -292,6 +369,17 @@ VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
    * If this number is not correct, the next call to curl_multi_perform will correct it. */
   rbcm->running++;
 
+  if (!rbcm->attached) {
+    rbcm->attached = st_init_numtable();
+    if (!rbcm->attached) {
+      curl_multi_remove_handle(rbcm->handle, rbce->curl);
+      ruby_curl_easy_cleanup(easy, rbce);
+      rb_raise(rb_eNoMemError, "Failed to allocate multi attachment table");
+    }
+  }
+
+  st_insert(rbcm->attached, (st_data_t)rbce, (st_data_t)easy);
+
   /* track a reference to associated multi handle */
   rbce->multi = self;
 
@@ -332,9 +420,13 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
     raise_curl_multi_error_exception(result);
   }
 
-  rbcm->active--;
+  if (rbcm->active > 0) {
+    rbcm->active--;
+  }
 
   ruby_curl_easy_cleanup( easy, rbce );
+
+  rb_curl_multi_forget_easy(rbcm, rbce);
 }
 
 // on_success, on_failure, on_complete
@@ -362,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 */
 
@@ -390,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")) {
@@ -1158,11 +1287,32 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 VALUE ruby_curl_multi_close(VALUE self) {
   ruby_curl_multi *rbcm;
   Data_Get_Struct(self, ruby_curl_multi, rbcm);
-  curl_multi_cleanup(rbcm->handle);
+  rb_curl_multi_detach_all(rbcm);
+
+  if (rbcm->handle) {
+    curl_multi_cleanup(rbcm->handle);
+    rbcm->handle = NULL;
+  }
+
   ruby_curl_multi_init(rbcm);
   return self;
 }
 
+/* GC mark: keep attached easy VALUEs alive while associated. */
+static int mark_attached_i(st_data_t key, st_data_t val, st_data_t arg) {
+  VALUE easy = (VALUE)val;
+  if (!NIL_P(easy)) rb_gc_mark(easy);
+  return ST_CONTINUE;
+}
+
+static void curl_multi_mark(void *ptr) {
+  ruby_curl_multi *rbcm = (ruby_curl_multi *)ptr;
+  if (!rbcm) return;
+  if (rbcm->attached) {
+    st_foreach(rbcm->attached, mark_attached_i, (st_data_t)0);
+  }
+}
+
 
 /* =================== INIT LIB =====================*/
 void init_curb_multi() {

data/ext/curb_multi.h

@@ -8,18 +8,21 @@
 #define __CURB_MULTI_H
 
 #include "curb.h"
-#include "curb_easy.h"
 #include <curl/multi.h>
 
+struct st_table;
+
 typedef struct {
   int active;
   int running;
   CURLM *handle;
+  struct st_table *attached;
 } ruby_curl_multi;
 
 extern VALUE cCurlMulti;
 void init_curb_multi();
 VALUE ruby_curl_multi_new(VALUE klass);
+void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 
 
 #endif

data/ext/extconf.rb

@@ -500,6 +500,7 @@ have_constant "curlusessl_try"
 have_constant "curlusessl_control"
 have_constant "curlusessl_all"
 have_constant "curlopt_resolve"
+have_constant "curlopt_request_target"
 have_constant "curlopt_sslcert"
 have_constant "curlopt_sslcerttype"
 have_constant "curlopt_sslkey"

data/lib/curl/easy.rb

@@ -158,6 +158,22 @@ module Curl
       set :proxy, url
     end
 
+    #
+    # call-seq:
+    #   easy.request_target = string                    => string
+    #
+    # Set the request-target used in the HTTP request line (libcurl CURLOPT_REQUEST_TARGET).
+    # Useful for absolute-form request targets (e.g., when speaking to proxies) or
+    # special targets like "*" (OPTIONS *). Requires libcurl with CURLOPT_REQUEST_TARGET support.
+    #
+    def request_target=(value)
+      if Curl.const_defined?(:CURLOPT_REQUEST_TARGET)
+        set :request_target, value
+      else
+        raise NotImplementedError, "CURLOPT_REQUEST_TARGET is not supported by this libcurl"
+      end
+    end
+
     def ssl_verify_host=(value)
       value = 1 if value.class == TrueClass
       value = 0 if value.class == FalseClass
@@ -216,9 +232,18 @@ module Curl
     # call-seq:
     #   easy.cookies = "name1=content1; name2=content2;" => string
     #
-    # Set cookies to be sent by this Curl::Easy instance. The format of the string should
-    # be NAME=CONTENTS, where NAME is the cookie name and CONTENTS is what the cookie should contain.
-    # Set multiple cookies in one string like this: "name1=content1; name2=content2;" etc.
+    # Set the manual Cookie request header for this Curl::Easy instance.
+    # The format of the string should be NAME=CONTENTS, where NAME is the cookie name and
+    # CONTENTS is what the cookie should contain. Set multiple cookies in one string like this:
+    # "name1=content1; name2=content2;".
+    #
+    # Notes:
+    # - This only affects the outgoing Cookie header (libcurl CURLOPT_COOKIE) and does NOT
+    #   alter the internal libcurl cookie engine (which stores cookies from Set-Cookie).
+    # - To change cookies stored in the engine, use {#cookielist} / {#cookielist=} or
+    #   {#set} with :cookielist.
+    # - To clear a previously set manual Cookie header, assign an empty string ('').
+    #   Assigning +nil+ has no effect in current curb versions.
     #
     def cookies=(value)
       set :cookie, value
@@ -233,6 +258,8 @@ module Curl
     # *Note* that you must set enable_cookies true to enable the cookie
     # engine, or this option will be ignored.
     #
+    # Note: assigning +nil+ has no effect; pass a path string to use a cookie file.
+    #
     def cookiefile=(value)
       set :cookiefile, value
     end
@@ -241,16 +268,40 @@ module Curl
     # call-seq:
     #   easy.cookiejar = string                          => string
     #
-    # Set a cookiejar file to use for this Curl::Easy instance.
-    # Cookies from the response will be written into this file.
+    # Set a cookiejar file to use for this Curl::Easy instance. Cookies from the response
+    # will be written into this file.
     #
     # *Note* that you must set enable_cookies true to enable the cookie
     # engine, or this option will be ignored.
     #
+    # Note: assigning +nil+ has no effect; pass a path string to persist cookies to a file.
+    #
     def cookiejar=(value)
       set :cookiejar, value
     end
 
+    #
+    # call-seq:
+    #   easy.cookielist = string                         => string
+    #
+    # Modify cookies in libcurl's internal cookie engine (CURLOPT_COOKIELIST).
+    # Accepts a Set-Cookie style string, one or more lines in Netscape cookie file format,
+    # or one of the special commands: "ALL" (clear), "SESS" (remove session cookies),
+    # "FLUSH" (write to jar), "RELOAD" (reload from file).
+    #
+    # Examples:
+    #   easy.cookielist = "Set-Cookie: session=42; Domain=example.com; Path=/;"
+    #   easy.cookielist = [
+    #     ['.example.com', 'TRUE', '/', 'FALSE', 0, 'c1', 'v1'].join("\t"),
+    #     ['.example.com', 'TRUE', '/', 'FALSE', 0, 'c2', 'v2'].join("\t"),
+    #     ''
+    #   ].join("\n")
+    #   easy.cookielist = 'ALL'   # clear all cookies in the engine
+    #
+    def cookielist=(value)
+      set :cookielist, value
+    end
+
     #
     # call-seq:
     #  easy = Curl::Easy.new("url") do|c|

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_curl_multi.rb

@@ -573,6 +573,35 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     end
   end
 
+  # Regression test for issue #267 (2015): ensure that when reusing
+  # easy handles with constrained concurrency, the callback receives
+  # the correct URL for each completed request rather than repeating
+  # the first URL.
+  def test_multi_easy_http_urls_unique_across_max_connects
+    urls = [
+      { :url => TestServlet.url + '?q=1', :method => :get },
+      { :url => TestServlet.url + '?q=2', :method => :get },
+      { :url => TestServlet.url + '?q=3', :method => :get }
+    ]
+
+    [1, 2, 3].each do |max|
+      results = []
+      Curl::Multi.http(urls.dup, {:pipeline => true, :max_connects => max}) do |easy, code, method|
+        assert_equal 200, code
+        assert_equal :get, method
+        results << easy.last_effective_url
+      end
+
+      # Ensure we saw one completion per input URL
+      assert_equal urls.size, results.size, "expected #{urls.size} results with max_connects=#{max}"
+
+      # And that each URL completed exactly once (no accidental reuse/mis-reporting)
+      expected_urls = urls.map { |u| u[:url] }
+      assert_equal expected_urls.to_set, results.to_set, "unexpected URLs for max_connects=#{max}: #{results.inspect}"
+      assert_equal expected_urls.size, results.uniq.size, "duplicate URLs seen for max_connects=#{max}: #{results.inspect}"
+    end
+  end
+
   def test_multi_recieves_500
     m = Curl::Multi.new
     e = Curl::Easy.new("http://127.0.0.1:9129/methods")

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2025-08-31 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,8 @@ 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
@@ -135,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
@@ -142,6 +146,8 @@ 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