curb 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 832660904f4d95f97b0795a4e39850f2fca2c70e521a0bb795a9c551f6fdf9f3
-  data.tar.gz: 903cb16a9a77396e90ea9ab2f33fb94a84d6a811525d23506af43195ab49fec2
+  metadata.gz: 48135be870a425c76338a773b41dc9438883b30cab622cc8c2d81394b860047d
+  data.tar.gz: e7a439c010c1bdbd3ab26b92f2126a4d518a2c7808d7acc6af2e57a03ec07376
 SHA512:
-  metadata.gz: bf99199469304444421b00adbaa2b64707c7eddcdaff9a3c662531ebf5f2220a1b6555145fa516422921ac0980c851e7ce234ff88391d608ca6783211f364ddf
-  data.tar.gz: 41aec998852a8458ed9f5508f37374ac72fb170c4235a7279e4f9864d2af143281cd81e1dec6099c80765d97b2263d1ee34bebd2b193701b9a4175a024ca5991
+  metadata.gz: b5c61d835a10a80211b625dd3ef8cf949fdcf30be9584d2a6793d69e309e3cb283097c2502a8912801ab9ee13679f1e71344034a197c54c88872157e66df74a0
+  data.tar.gz: 20fbde1832dc7338dba7f78c08556eceab4532247f41f0bb1c0c15ba11fc0cd2f07aabeaef62525eba24afc95b5e9854dbb3d71f6d6f493097d614ae913818f8

data/README.md

@@ -74,11 +74,37 @@ 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`.
+
 ### Advanced FTP Usage with Various Options
 ```
 puts "\n=== Advanced FTP Example ==="
@@ -327,6 +353,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 +367,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 +459,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.1"
+#define CURB_VER_NUM   1021
 #define CURB_VER_MAJ   1
 #define CURB_VER_MIN   2
-#define CURB_VER_MIC   0
+#define CURB_VER_MIC   1
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -225,6 +225,24 @@ 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) {
+        rb_curl_multi_forget_easy(rbcm, rbce);
+      }
+    }
+  }
+
   if (rbce->curl_headers) {
     curl_slist_free_all(rbce->curl_headers);
   }
@@ -310,6 +328,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;
@@ -664,7 +683,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 +702,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 +713,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 +1014,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 +1931,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)
 {
@@ -2486,9 +2529,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 +2541,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 +3640,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 +3707,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 +3866,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 +4009,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

@@ -77,6 +77,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
@@ -1158,11 +1250,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_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")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2025-08-31 00:00:00.000000000 Z
+date: 2025-09-17 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
@@ -76,11 +76,6 @@ files:
 - tests/tc_curl_postfield.rb
 - tests/tc_curl_protocols.rb
 - tests/tc_fiber_scheduler.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
@@ -142,11 +137,6 @@ test_files:
 - tests/tc_curl_postfield.rb
 - tests/tc_curl_protocols.rb
 - tests/tc_fiber_scheduler.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

data/tests/test_basic.rb

@@ -1,29 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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!"