curb 1.3.6 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11348a158e7da3d3406acd021be1a15f881ce2c607ff04e60b522a3bd92cd828
-  data.tar.gz: 0c524ce914df77b109a2aad85289386b2bf54028733fcf4ec5657a84abf511b8
+  metadata.gz: 9f3088ba29db67ea56c9587898267648a704c8acbcb9e95cb58318c3464deb12
+  data.tar.gz: 40134cd41f0704c2aaa3b65ca6507987f6e8bc755c4530c9361ccd25f4831c17
 SHA512:
-  metadata.gz: b4ebd6b04943bfc099a6593ede1c70298555ed1a6613958e8628cde43c30b8c7f8b86990d91c7a350481589495fe7d5dc4ad1ac3c313823bb7fb21e483e8910c
-  data.tar.gz: 0a78bc41496259eae9989d25e4a47c57a9a9aed6f79b00e77efae691b487a730e71e6cdf8081ae35d33893a84b033219ae24c40cf47effd8e3d1b0ca3591f222
+  metadata.gz: 29ffbf5bb4301db5729aff433a938251622c8483a29f5fa0f5344b52573048964c9863d00d254b42d01ff172291a1b469ea10f1fa9757b58fe4743a66c7078a5
+  data.tar.gz: d2e21e48891f398af31a7b2dd8d99a2465f82bb97d9caecda8ac4cb69fb599e894c3172bc56a6106a28d7761b03743fc78ee80701b3051ac673b7b6f1ed27ea9

data/README.md

@@ -1,10 +1,9 @@
 # Curb - Libcurl bindings for Ruby
 
-[![CI](https://github.com/taf2/curb/actions/workflows/ci.yml/badge.svg)](https://github.com/taf2/curb/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/taf2/curb/branch/master/graph/badge.svg)](https://codecov.io/gh/taf2/curb)
+[![CI](https://github.com/taf2/curb/actions/workflows/CI.yml/badge.svg)](https://github.com/taf2/curb/actions/workflows/CI.yml)
 [![Gem Version](https://badge.fury.io/rb/curb.svg)](https://badge.fury.io/rb/curb)
 
-* [CI Build Status](https://github.com/taf2/curb/actions/workflows/ci.yml)
+* [CI Build Status](https://github.com/taf2/curb/actions/workflows/CI.yml)
 * [rubydoc rdoc](http://www.rubydoc.info/github/taf2/curb/)
 * [github project](http://github.com/taf2/curb/tree/master)
 
@@ -23,8 +22,8 @@ Ruby license. See the LICENSE file for the gory details.
 
 ## Easy mode
 
-GET request
-```
+### GET request
+```ruby
   res = Curl.get("https://www.google.com/") {|http|
     http.timeout = 10 # raise exception if request/response not handled within 10 seconds
   }
@@ -33,8 +32,8 @@ GET request
   puts res.body
 ```
 
-POST request
-```
+### POST request
+```ruby
   res = Curl.post("https://your-server.com/endpoint", {post: "this"}.to_json) {|http|
     http.headers["Content-Type"] = "application/json"
   }
@@ -45,7 +44,9 @@ POST request
 
 ## FTP Support
 
+```ruby
 require 'curb'
+```
 
 ### Basic FTP Download
 ```ruby
@@ -139,7 +140,7 @@ puts list.body
 ```
 
 ### Advanced FTP Usage with Various Options
-```
+```ruby
 puts "\n=== Advanced FTP Example ==="
 advanced = Curl::Easy.new do |curl|
   curl.url = 'ftp://ftp.example.com/remote/file.txt'
@@ -175,7 +176,7 @@ advanced.perform
 ```
 
 ### Parallel FTP Downloads
-```
+```ruby
 puts "\n=== Parallel FTP Downloads Example ==="
 urls = [
   'ftp://ftp.example.com/file1.txt',
@@ -185,7 +186,7 @@ urls = [
 ```
 
 ### Common options for all connections
-```
+```ruby
 options = {
   :username => 'user',
   :password => 'password',
@@ -204,7 +205,7 @@ end
 `curb` is a libcurl binding and intentionally supports protocols beyond HTTP.
 Do not pass untrusted URLs to `Curl.get`, `Curl::Easy.new`, or related raw
 helpers without application-level validation. For user-supplied URLs, enable the
-process-wide safety policy before making requests:
+safety policy for the current Ractor before making requests:
 
 ```ruby
 Curl.safe! do |config|
@@ -256,11 +257,47 @@ configured. For untrusted or large responses, use `on_body`, `download`, and/or
 `max_body_bytes` is enforced for downloads as well as buffered responses and
 custom body callbacks.
 
+## Ractor support
+
+On Ruby 3.0+, curb can perform requests from multiple Ractors when it is built
+against a libcurl that reports the `CURL_VERSION_THREADSAFE` capability
+(libcurl 7.84.0 or newer). Check `Curl::RACTOR_SAFE` at runtime. Builds that do
+not meet those requirements continue to work in the main Ractor but do not
+advertise native Ractor safety.
+
+Create `Curl::Easy` and `Curl::Multi` handles inside the Ractor that uses them;
+do not operate on the same native handle concurrently from different Ractors.
+Safety configuration, `Curl::Multi.default_timeout`, `Curl::Multi.autoclose`,
+and deferred cleanup queues are isolated per Ractor. Call `Curl.safe!` in each
+Ractor that needs the safety policy:
+
+```ruby
+raise "this curb build is not Ractor-safe" unless Curl::RACTOR_SAFE
+
+workers = 4.times.map do
+  Ractor.new do
+    Curl.safe! { |config| config.protocols = [:http, :https] }
+    easy = Curl::Easy.new("https://example.com/")
+    easy.perform
+    easy.response_code
+  end
+end
+
+# Ruby 4.0 uses Ractor#value; earlier Ractor releases use Ractor#take.
+statuses = workers.map do |worker|
+  worker.respond_to?(:value) ? worker.value : worker.take
+end
+```
+
+Curb enables `CURLOPT_NOSIGNAL` on newly initialized and reset Easy handles by
+default so separate handles can be used safely from parallel Ruby execution.
+Applications can still override the option explicitly when required.
+
 ## You will need
 
 * A working Ruby installation (`2.0.0+` will work but `2.1+` preferred) (it's possible it still works with 1.8.7 but you'd have to tell me if not...)
 * A working libcurl development installation
-(Ideally one of the versions listed in the compatibility chart below that maps to your `curb` version)
+  (Ideally one of the versions listed in the compatibility chart below that maps to your `curb` version)
 * A sane build environment (e.g. gcc, make)
 
 ## Version Compatibility chart
@@ -269,8 +306,28 @@ A **non-exhaustive** set of compatibility versions of the libcurl library
 with this gem are as follows. (Note that these are only the ones that have been
 tested and reported to work across a variety of platforms / rubies)
 
+The upper bounds for recent releases reflect the compatibility work documented
+in the changelog, including the libcurl 8.16.0 regression workaround in 1.2.2
+and the libcurl 8.20.0 scheduler fixes in 1.3.5. The 1.3.7 upper bound also
+includes expected compatibility with libcurl 8.21.0; this version is not yet
+an explicit CI target.
+
 | Gem Version | Release Date   | libcurl versions  |
 | ----------- | -------------- | ----------------- |
+| 1.4.0       | Sep 27, 2026   | 7.58 – 8.21.0     |
+| 1.3.7       | Jul 10, 2026   | 7.58 – 8.21.0     |
+| 1.3.6       | Jun 17, 2026   | 7.58 – 8.20.0     |
+| 1.3.5       | May 14, 2026   | 7.58 – 8.20.0     |
+| 1.3.4       | May 12, 2026   | 7.58 – 8.16.0     |
+| 1.3.3       | May 11, 2026   | 7.58 – 8.16.0     |
+| 1.3.2       | Apr 23, 2026   | 7.58 – 8.16.0     |
+| 1.3.1       | Apr 05, 2026   | 7.58 – 8.16.0     |
+| 1.3.0       | Apr 02, 2026   | 7.58 – 8.16.0     |
+| 1.2.2       | Sep 18, 2025   | 7.58 – 8.16.0     |
+| 1.2.1       | Sep 17, 2025   | 7.58 – 8.12.1     |
+| 1.2.0       | Aug 31, 2025   | 7.58 – 8.12.1     |
+| 1.1.0       | Jul 24, 2025   | 7.58 – 8.12.1     |
+| 1.0.9       | Feb 15, 2025   | 7.58 – 8.12.1     |
 | 1.0.8       | Feb 10, 2025   | 7.58 – 8.12.1     |
 | 1.0.7       | Feb 09, 2025   | 7.58 – 8.12.1     |
 | 1.0.6       | Aug 23, 2024   | 7.58 – 8.12.1     |
@@ -287,7 +344,7 @@ tested and reported to work across a variety of platforms / rubies)
 | 0.9.4       | Aug 2017       | 7.41 – 7.58       |
 | 0.9.3       | Apr 2016       | 7.26 – 7.58       |
 
-  ```*avoid using these version are known to have issues with segmentation faults```
+*Avoid using these versions; they are known to have issues with segmentation faults.*
 
 ## Installation...
 
@@ -457,6 +514,7 @@ 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
 
@@ -470,7 +528,6 @@ c.perform
 ```
 
 For HTTPS, prefer `easy.resolve = ["host:443:IP"]` to keep Host/SNI/certificates aligned.
-```
 
 ### Using HTTP/2
 

data/Rakefile

@@ -126,7 +126,18 @@ end
 
 RubyMemcheck.config(**ruby_memcheck_config)
 namespace :test do
-  RubyMemcheck::TestTask.new(valgrind: :compile) do|t|
+  # Ruby pools fiber stacks next to each other, about 1MB apart. Valgrind
+  # treats a stack-pointer jump smaller than --max-stackframe (2MB) as an
+  # ordinary call or return rather than a switch to another stack, and marks
+  # the memory in between, which can hold another fiber's stack, as
+  # inaccessible. Later reads of that fiber's stack (turning a block into a
+  # Proc, GC marking suspended fibers) are then reported as invalid. Spacing
+  # fiber stacks wider than that lets valgrind recognize every fiber switch.
+  task :valgrind_env do
+    ENV['RUBY_FIBER_MACHINE_STACK_SIZE'] ||= (4 * 1024 * 1024).to_s
+  end
+
+  RubyMemcheck::TestTask.new(valgrind: [:compile, :valgrind_env]) do|t|
     t.test_files = FileList['tests/tc_*.rb']
     t.verbose = false
   end

data/ext/curb.c

@@ -243,25 +243,38 @@ static void finalize_curb_core(VALUE data) {
 
 void Init_curb_core() {
   curl_version_info_data *ver;
-  VALUE curlver, curllongver, curlvernum;
+  VALUE curbver, curlver, curllongver, curlvernum;
+  int ractor_safe = 0;
 
   curl_global_init(CURL_GLOBAL_ALL);
   rb_set_end_proc(finalize_curb_core, Qnil);
   ver = curl_version_info(CURLVERSION_NOW);
 
+#if defined(HAVE_RB_EXT_RACTOR_SAFE) && defined(HAVE_CURL_VERSION_THREADSAFE)
+  /* Ractors execute native methods in parallel. Only opt in when both Ruby
+   * provides the safety marker and libcurl advertises thread-safe global
+   * initialization. Individual Curl handles remain Ractor-owned. */
+  if (ver && (ver->features & CURL_VERSION_THREADSAFE)) {
+    rb_ext_ractor_safe(1);
+    ractor_safe = 1;
+  }
+#endif
+
   mCurl = rb_define_module("Curl");
 
-  curlver = rb_str_new2(ver->version);
-  curllongver = rb_str_new2(curl_version());
+  curbver = rb_obj_freeze(rb_str_new2(CURB_VERSION));
+  curlver = rb_obj_freeze(rb_str_new2(ver->version));
+  curllongver = rb_obj_freeze(rb_str_new2(curl_version()));
   curlvernum = LONG2NUM(LIBCURL_VERSION_NUM);
 
-  rb_define_const(mCurl, "CURB_VERSION", rb_str_new2(CURB_VERSION));
+  rb_define_const(mCurl, "CURB_VERSION", curbver);
   rb_define_const(mCurl, "VERSION", curlver);
   rb_define_const(mCurl, "CURL_VERSION", curlver);
   rb_define_const(mCurl, "VERNUM", curlvernum);
   rb_define_const(mCurl, "CURL_VERNUM", curlvernum);
   rb_define_const(mCurl, "LONG_VERSION", curllongver);
   rb_define_const(mCurl, "CURL_LONG_VERSION", curllongver);
+  rb_define_const(mCurl, "RACTOR_SAFE", ractor_safe ? Qtrue : Qfalse);
 
   /* Passed to on_debug handler to indicate that the data is informational text. */
   rb_define_const(mCurl, "CURLINFO_TEXT", LONG2NUM(CURLINFO_TEXT));
@@ -748,6 +761,15 @@ void Init_curb_core() {
 #ifdef HAVE_CURLOPT_FTP_CREATE_MISSING_DIRS
   CURB_DEFINE(CURLOPT_FTP_CREATE_MISSING_DIRS);
 #endif
+#ifdef HAVE_CURLFTP_CREATE_DIR_NONE
+  CURB_DEFINE(CURLFTP_CREATE_DIR_NONE);
+#endif
+#ifdef HAVE_CURLFTP_CREATE_DIR
+  CURB_DEFINE(CURLFTP_CREATE_DIR);
+#endif
+#ifdef HAVE_CURLFTP_CREATE_DIR_RETRY
+  CURB_DEFINE(CURLFTP_CREATE_DIR_RETRY);
+#endif
 #ifdef HAVE_CURLOPT_FTP_RESPONSE_TIMEOUT
   CURB_DEFINE(CURLOPT_FTP_RESPONSE_TIMEOUT);
 #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.3.6"
-#define CURB_VER_NUM   1036
+#define CURB_VERSION   "1.4.0"
+#define CURB_VER_NUM   1040
 #define CURB_VER_MAJ   1
-#define CURB_VER_MIN   3
-#define CURB_VER_MIC   6
+#define CURB_VER_MIN   4
+#define CURB_VER_MIC   0
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -66,6 +66,17 @@ static struct curl_slist *duplicate_curl_slist(struct curl_slist *list);
 static size_t proc_data_handler(char *stream, size_t size, size_t nmemb, VALUE proc);
 static int curb_array_includes_string(VALUE list, VALUE value);
 
+static void curb_easy_apply_thread_defaults(ruby_curl_easy *rbce) {
+#ifdef HAVE_CURLOPT_NOSIGNAL
+  CURLcode ecode = curl_easy_setopt(rbce->curl, CURLOPT_NOSIGNAL, 1L);
+  if (ecode != CURLE_OK) {
+    raise_curl_easy_error_exception(ecode);
+  }
+#else
+  (void)rbce;
+#endif
+}
+
 /* ================== CURL HANDLER FUNCS ==============*/
 
 static int curb_ipv4_is_unsafe_destination(const unsigned char *ip) {
@@ -1187,6 +1198,7 @@ static int proc_debug_handler(CURL *curl,
 static void curl_easy_mark(void *ptr) {
   ruby_curl_easy *rbce = (ruby_curl_easy *)ptr;
   if (rbce) {
+    if (!NIL_P(rbce->self)) { rb_gc_mark(rbce->self); }
     if (!NIL_P(rbce->opts)) { rb_gc_mark(rbce->opts); }
     if (!NIL_P(rbce->multi)) { rb_gc_mark(rbce->multi); }
     if (!NIL_P(rbce->callback_error)) { rb_gc_mark(rbce->callback_error); }
@@ -1500,6 +1512,7 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curb_easy_apply_thread_defaults(rbce);
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   rb_easy_set("url", url);
@@ -1658,6 +1671,7 @@ static VALUE ruby_curl_easy_close(VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curb_easy_apply_thread_defaults(rbce);
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, rbce->err_buf);
 
   /* give the new curl handle a reference back to the ruby object */
@@ -1702,6 +1716,7 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curb_easy_apply_thread_defaults(rbce);
   curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
   /* reset clobbers the private setting, so reset it to self */
@@ -2551,6 +2566,41 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
   (!strncmp("anysafe",node,7)) ? CURLAUTH_ANYSAFE : \
   (!strncmp("any",node,3)) ? CURLAUTH_ANY : 0
 #endif
+/*
+ * Convert the arguments to http_auth_types= / proxy_auth_types= into a
+ * CURLAUTH bitmask. Accepts nil, an Integer mask, or one or more auth type
+ * names (symbols/strings), either as separate args or as a single Array.
+ */
+static long ruby_curl_easy_auth_types_to_mask(VALUE args_ary) {
+  long i, len;
+  char* node = NULL;
+  long mask = 0;
+  VALUE first;
+
+  /* easy.http_auth_types = [:basic, :digest] arrives as a single Array arg */
+  if (RARRAY_LEN(args_ary) == 1 && RB_TYPE_P(rb_ary_entry(args_ary,0), T_ARRAY)) {
+    args_ary = rb_ary_entry(args_ary,0);
+  }
+
+  len = RARRAY_LEN(args_ary);
+  first = rb_ary_entry(args_ary,0);
+
+  if (len == 1 && (first == Qnil || TYPE(first) == T_FIXNUM || TYPE(first) == T_BIGNUM)) {
+    return first == Qnil ? 0 : NUM2LONG(first);
+  }
+
+  // we could have multiple values, but they should be symbols
+  // rb_obj_as_string always yields a String, even if to_s misbehaves;
+  // RSTRING_PTR on a raw rb_funcall result would crash if #to_s returned
+  // a non-String (e.g. a Fixnum, whose VALUE isn't a real pointer).
+  for( i = 0; i < len; ++i ) {
+    VALUE node_str = rb_obj_as_string(rb_ary_entry(args_ary,i));
+    node = StringValuePtr(node_str);
+    mask |= CURL_HTTPAUTH_STR_TO_NUM(node);
+  }
+  return mask;
+}
+
 /*
  * call-seq:
  *   easy.http_auth_types = fixnum or nil             => fixnum or nil
@@ -2560,37 +2610,14 @@ static VALUE ruby_curl_easy_proxy_type_get(VALUE self) {
  * +perform+ calls. This is a bitmap made by ORing together the
  * Curl::CURLAUTH constants.
  */
-static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {//VALUE self, VALUE http_auth_types) {
+static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   VALUE args_ary;
-  long i, len;
-  char* node = NULL;
-  long mask = 0;
 
   rb_scan_args(argc, argv, "*", &args_ary);
   TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  len = RARRAY_LEN(args_ary);
-
-  if (len == 1 && (rb_ary_entry(args_ary,0) == Qnil || TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM ||
-        TYPE(rb_ary_entry(args_ary,0)) == T_BIGNUM)) {
-    if (rb_ary_entry(args_ary,0) == Qnil) {
-      rbce->http_auth_types = 0;
-    }
-    else {
-      rbce->http_auth_types = NUM2LONG(rb_ary_entry(args_ary,0));
-    }
-  }
-  else {
-    // we could have multiple values, but they should be symbols
-    node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,0),rb_intern("to_s"),0));
-    mask = CURL_HTTPAUTH_STR_TO_NUM(node);
-    for( i = 1; i < len; ++i ) {
-      node = RSTRING_PTR(rb_funcall(rb_ary_entry(args_ary,i),rb_intern("to_s"),0));
-      mask |= CURL_HTTPAUTH_STR_TO_NUM(node);
-    }
-    rbce->http_auth_types = mask;
-  }
+  rbce->http_auth_types = ruby_curl_easy_auth_types_to_mask(args_ary);
   return LONG2NUM(rbce->http_auth_types);
 }
 
@@ -2608,13 +2635,21 @@ static VALUE ruby_curl_easy_http_auth_types_get(VALUE self) {
 /*
  * call-seq:
  *   easy.proxy_auth_types = fixnum or nil            => fixnum or nil
+ *   easy.proxy_auth_types = [:basic,:digest,:digest_ie,:gssnegotiate, :ntlm, :any, :anysafe]
  *
  * Set the proxy authentication types that may be used for the following
  * +perform+ calls. This is a bitmap made by ORing together the
  * Curl::CURLAUTH constants.
  */
-static VALUE ruby_curl_easy_proxy_auth_types_set(VALUE self, VALUE proxy_auth_types) {
-  CURB_IMMED_SETTER(ruby_curl_easy, proxy_auth_types, 0);
+static VALUE ruby_curl_easy_proxy_auth_types_set(int argc, VALUE *argv, VALUE self) {
+  ruby_curl_easy *rbce;
+  VALUE args_ary;
+
+  rb_scan_args(argc, argv, "*", &args_ary);
+  TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
+
+  rbce->proxy_auth_types = ruby_curl_easy_auth_types_to_mask(args_ary);
+  return LONG2NUM(rbce->proxy_auth_types);
 }
 
 /*
@@ -5581,6 +5616,17 @@ static VALUE ruby_curl_easy_last_error(VALUE self) {
  * @note Some options - like url or cookie - aren't set directly throught +curl_easy_setopt+, but stored in the Ruby object state.
  * @note When +curl_easy_setopt+ is called, return value is not checked here.
  */
+static long ruby_curl_easy_option_to_long(VALUE value) {
+  if (value == Qtrue) {
+    return 1L;
+  }
+  if (value == Qfalse) {
+    return 0L;
+  }
+
+  return NUM2LONG(rb_funcall(value, rb_intern("to_i"), 0));
+}
+
 static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   ruby_curl_easy *rbce;
   long option = NUM2LONG(opt);
@@ -5696,59 +5742,76 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   /* FTP-specific toggles */
 #ifdef 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));
+    curl_easy_setopt(rbce->curl, CURLOPT_DIRLISTONLY, ruby_curl_easy_option_to_long(val));
     } break;
 #endif
+#ifdef HAVE_CURLOPT_FTPPORT
+  case CURLOPT_FTPPORT:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTPPORT, NIL_P(val) ? NULL : StringValueCStr(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_APPEND
+  case CURLOPT_APPEND:
+    curl_easy_setopt(rbce->curl, CURLOPT_APPEND, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
 #ifdef 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;
+  case CURLOPT_FTP_USE_EPSV:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_EPSV, ruby_curl_easy_option_to_long(val));
+    break;
 #endif
 #ifdef 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;
+  case CURLOPT_FTP_USE_EPRT:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_EPRT, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_USE_PRET
+  case CURLOPT_FTP_USE_PRET:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_USE_PRET, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_CREATE_MISSING_DIRS
+  case CURLOPT_FTP_CREATE_MISSING_DIRS:
+    rb_easy_set("ftp_create_missing_dirs", val);
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_CREATE_MISSING_DIRS, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_RESPONSE_TIMEOUT
+  case CURLOPT_FTP_RESPONSE_TIMEOUT:
+    rbce->ftp_response_timeout = ruby_curl_easy_option_to_long(val);
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_RESPONSE_TIMEOUT, rbce->ftp_response_timeout);
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_ALTERNATIVE_TO_USER
+  case CURLOPT_FTP_ALTERNATIVE_TO_USER:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_ALTERNATIVE_TO_USER, NIL_P(val) ? NULL : StringValueCStr(val));
+    break;
 #endif
 #ifdef 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;
+  case CURLOPT_FTP_SKIP_PASV_IP:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_SKIP_PASV_IP, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTPSSLAUTH
+  case CURLOPT_FTPSSLAUTH:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTPSSLAUTH, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_SSL_CCC
+  case CURLOPT_FTP_SSL_CCC:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_SSL_CCC, ruby_curl_easy_option_to_long(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_ACCOUNT
+  case CURLOPT_FTP_ACCOUNT:
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_ACCOUNT, NIL_P(val) ? NULL : StringValueCStr(val));
+    break;
+#endif
+#ifdef HAVE_CURLOPT_FTP_FILEMETHOD
+  case CURLOPT_FTP_FILEMETHOD:
+    rbce->ftp_filemethod = ruby_curl_easy_option_to_long(val);
+    curl_easy_setopt(rbce->curl, CURLOPT_FTP_FILEMETHOD, rbce->ftp_filemethod);
+    break;
 #endif
   case CURLOPT_RANGE: {
     curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
@@ -5955,6 +6018,34 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   return val;
 }
 
+#ifdef HAVE_CURLOPT_FTP_CREATE_MISSING_DIRS
+/*
+ * call-seq:
+ *   easy.ftp_create_missing_dirs = boolean_or_mode  => boolean_or_mode
+ *
+ * Configure whether libcurl creates missing directories for an FTP or SFTP
+ * transfer. In addition to true and false, this accepts the
+ * Curl::CURLFTP_CREATE_DIR_* mode constants when provided by libcurl.
+ */
+static VALUE ruby_curl_easy_ftp_create_missing_dirs_set(VALUE self, VALUE value) {
+  return ruby_curl_easy_set_opt(
+    self,
+    LONG2NUM(CURLOPT_FTP_CREATE_MISSING_DIRS),
+    value
+  );
+}
+
+/*
+ * call-seq:
+ *   easy.ftp_create_missing_dirs  => boolean, number, or nil
+ *
+ * Return the configured missing-directory creation mode.
+ */
+static VALUE ruby_curl_easy_ftp_create_missing_dirs_get(VALUE self) {
+  CURB_OBJECT_HGETTER(ruby_curl_easy, ftp_create_missing_dirs);
+}
+#endif
+
 /*
  * call-seq:
  *   easy.getinfo(opt) => nil
@@ -6010,8 +6101,9 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
 
   TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
-  /* NOTE: make sure the value is a string, if not call to_s */
-  if( rb_type(str) != T_STRING ) { str = rb_funcall(str,rb_intern("to_s"),0); }
+  /* NOTE: make sure the value is a string; rb_obj_as_string always yields a
+   * String, even if the object's to_s misbehaves and returns a non-String. */
+  if( rb_type(str) != T_STRING ) { str = rb_obj_as_string(str); }
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str));
@@ -6041,6 +6133,11 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
 
   TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
 
+  /* Coerce as its own statement before use below - StringValuePtr and
+   * RSTRING_LEN are sibling args to the same call and C does not guarantee
+   * left-to-right evaluation order between them. */
+  StringValue(str);
+
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
   result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
 #else
@@ -6075,7 +6172,7 @@ void init_curb_easy() {
   idNetworkPolicyNone = rb_intern("none");
   idNetworkPolicyPublic = rb_intern("public");
 
-  rbstrAmp = rb_str_new2("&");
+  rbstrAmp = rb_obj_freeze(rb_str_new2("&"));
   rb_global_variable(&rbstrAmp);
 
   cCurlEasy = rb_define_class_under(mCurl, "Easy", rb_cObject);
@@ -6146,7 +6243,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "proxy_type", ruby_curl_easy_proxy_type_get, 0);
   rb_define_method(cCurlEasy, "http_auth_types=", ruby_curl_easy_http_auth_types_set, -1);
   rb_define_method(cCurlEasy, "http_auth_types", ruby_curl_easy_http_auth_types_get, 0);
-  rb_define_method(cCurlEasy, "proxy_auth_types=", ruby_curl_easy_proxy_auth_types_set, 1);
+  rb_define_method(cCurlEasy, "proxy_auth_types=", ruby_curl_easy_proxy_auth_types_set, -1);
   rb_define_method(cCurlEasy, "proxy_auth_types", ruby_curl_easy_proxy_auth_types_get, 0);
   rb_define_method(cCurlEasy, "max_redirects=", ruby_curl_easy_max_redirects_set, 1);
   rb_define_method(cCurlEasy, "max_redirects", ruby_curl_easy_max_redirects_get, 0);
@@ -6162,6 +6259,10 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "dns_cache_timeout", ruby_curl_easy_dns_cache_timeout_get, 0);
   rb_define_method(cCurlEasy, "ftp_response_timeout=", ruby_curl_easy_ftp_response_timeout_set, 1);
   rb_define_method(cCurlEasy, "ftp_response_timeout", ruby_curl_easy_ftp_response_timeout_get, 0);
+#ifdef HAVE_CURLOPT_FTP_CREATE_MISSING_DIRS
+  rb_define_method(cCurlEasy, "ftp_create_missing_dirs=", ruby_curl_easy_ftp_create_missing_dirs_set, 1);
+  rb_define_method(cCurlEasy, "ftp_create_missing_dirs", ruby_curl_easy_ftp_create_missing_dirs_get, 0);
+#endif
   rb_define_method(cCurlEasy, "low_speed_limit=", ruby_curl_easy_low_speed_limit_set, 1);
   rb_define_method(cCurlEasy, "low_speed_limit", ruby_curl_easy_low_speed_limit_get, 0);
   rb_define_method(cCurlEasy, "low_speed_time=", ruby_curl_easy_low_speed_time_set, 1);

data/ext/curb_easy.h

@@ -112,6 +112,7 @@ typedef struct {
   curb_cidr_rule *network_allowed_cidr_rules;
   char **network_allowed_hosts;
 
+  /* attachment_sequence of the multi at the time this easy was last added. */
   unsigned long multi_attachment_generation;
   curl_off_t downloaded_body_bytes;
   size_t network_allowed_cidr_rule_count;