curb 1.3.0 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 886abdbc88d51f4d214de43f3a4d12029bfa010bd419ac89e60d0d18a8be3e21
-  data.tar.gz: 0a574a8d8f70daf2e28f4d0900075a67158ce12187ddb10d4da7700e6eea7ecb
+  metadata.gz: 3f62e867480076ceef877a4adcb5c3b4a344769207af06ded4535a3ce1e87375
+  data.tar.gz: 4caa926321d05804edbd4b0470951a617192ffd2504ac741524306edec1fe193
 SHA512:
-  metadata.gz: 10438303d75fb75a75cfc2b42d9ff0bfcb92fa87cf4f1eea893f51556dfeab29639b9d30c635721224898ddc712fd62c2f46ca3d70c6622889da3821de9e2b19
-  data.tar.gz: af1a29be7253c4b0c73e593e238f7e49b1c456994559eedd9ae170678b6ac1ecb9fb80982dce1cd9eb3bba422b282fc5c83336e1bc1a1a48c88b3845cc95c424
+  metadata.gz: 917f5e735b7187b5089896a83442462ed7f7b9311dbf616e58ab2cae3b2dff38e28f51f401e183214779d8f5159da6fa6dc7d842c0b5e21993cd428f61868d1f
+  data.tar.gz: 986d63577872fc80a563a4f2ac29a169888eb549d7ba462ecdef89636f3087be48ad7895e13954824e5af069614601ae30730a0af88cd4b3ad3391997b37c3e3

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.0"
-#define CURB_VER_NUM   1030
+#define CURB_VERSION   "1.3.2"
+#define CURB_VER_NUM   1032
 #define CURB_VER_MAJ   1
 #define CURB_VER_MIN   3
-#define CURB_VER_MIC   0
+#define CURB_VER_MIC   2
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -107,6 +107,11 @@ static VALUE call_stream_to_s(VALUE stream) {
   return rb_funcall(stream, rb_intern("to_s"), 0);
 }
 
+static VALUE call_string_value(VALUE str) {
+  StringValue(str);
+  return str;
+}
+
 struct stream_seek_call_args {
   VALUE stream;
   curl_off_t offset;
@@ -141,6 +146,30 @@ static VALUE call_with_easy_callback_active(VALUE argp) {
   return with_easy_callback_active(args->rbce, args->func, args->arg);
 }
 
+static VALUE rescue_easy_callback(ruby_curl_easy *rbce, VALUE (*func)(VALUE), VALUE arg) {
+  struct easy_callback_dispatch_args dispatch_args;
+  dispatch_args.rbce = rbce;
+  dispatch_args.func = func;
+  dispatch_args.arg = arg;
+  return rb_rescue(call_with_easy_callback_active, (VALUE)&dispatch_args, callback_exception_store_on_easy, (VALUE)rbce);
+}
+
+static size_t curl_read_abort_result(void) {
+#ifdef CURL_READFUNC_ABORT
+  return CURL_READFUNC_ABORT;
+#else
+  return 0;
+#endif
+}
+
+static int curl_seek_fail_result(void) {
+#ifdef CURL_SEEKFUNC_FAIL
+  return CURL_SEEKFUNC_FAIL;
+#else
+  return 1;
+#endif
+}
+
 /* Default body handler appends to easy.body_data buffer */
 static size_t default_body_handler(char *stream,
                                    size_t size,
@@ -178,18 +207,36 @@ static size_t read_data_handler(void *ptr,
                                 ruby_curl_easy *rbce) {
   VALUE upload = rb_easy_get("upload");
   size_t read_bytes = (size*nmemb);
-  VALUE stream = ruby_curl_upload_stream_get(upload);
+  VALUE stream;
+
+  if (NIL_P(upload)) {
+    return curl_read_abort_result();
+  }
+
+  stream = ruby_curl_upload_stream_get(upload);
 
   if (rb_respond_to(stream, rb_intern("read"))) {//if (rb_respond_to(stream, rb_intern("to_s"))) {
     /* copy read_bytes from stream into ptr */
     struct stream_read_call_args args;
     args.stream = stream;
     args.read_bytes = read_bytes;
-    VALUE str = with_easy_callback_active(rbce, call_stream_read, (VALUE)&args);
+    VALUE str = rescue_easy_callback(rbce, call_stream_read, (VALUE)&args);
     if( str != Qnil ) {
-      StringValue(str);
-      memcpy(ptr, RSTRING_PTR(str), RSTRING_LEN(str));
-      return RSTRING_LEN(str);
+      size_t str_len;
+
+      str = rescue_easy_callback(rbce, call_string_value, str);
+      if (str == Qfalse || str == Qnil) {
+        return curl_read_abort_result();
+      }
+
+      str_len = (size_t)RSTRING_LEN(str);
+      if (str_len > read_bytes) {
+        snprintf(rbce->err_buf, CURL_ERROR_SIZE, "read callback returned more data than requested");
+        return curl_read_abort_result();
+      }
+
+      memcpy(ptr, RSTRING_PTR(str), str_len);
+      return str_len;
     }
     else {
       return 0;
@@ -202,9 +249,17 @@ static size_t read_data_handler(void *ptr,
     size_t remaining;
     char *str_ptr;
     TypedData_Get_Struct(upload, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
-    str = with_easy_callback_active(rbce, call_stream_to_s, stream);
-    StringValue(str);
+    str = rescue_easy_callback(rbce, call_stream_to_s, stream);
+    str = rescue_easy_callback(rbce, call_string_value, str);
+    if (str == Qfalse || str == Qnil) {
+      return curl_read_abort_result();
+    }
+
     len = RSTRING_LEN(str);
+    if (rbcu->offset >= len) {
+      return 0;
+    }
+
     remaining = len - rbcu->offset;
     str_ptr = RSTRING_PTR(str);
 
@@ -232,14 +287,23 @@ int seek_data_handler(ruby_curl_easy *rbce,
                       int origin) {
 
   VALUE upload = rb_easy_get("upload");
-  VALUE stream = ruby_curl_upload_stream_get(upload);
+  VALUE stream;
+
+  if (NIL_P(upload)) {
+    return curl_seek_fail_result();
+  }
+
+  stream = ruby_curl_upload_stream_get(upload);
 
   if (rb_respond_to(stream, rb_intern("seek"))) {
     struct stream_seek_call_args args;
     args.stream = stream;
     args.offset = offset;
-    args.origin = SEEK_SET;
-    with_easy_callback_active(rbce, call_stream_seek, (VALUE)&args);
+    args.origin = origin;
+    rescue_easy_callback(rbce, call_stream_seek, (VALUE)&args);
+    if (!NIL_P(rbce->callback_error)) {
+      return curl_seek_fail_result();
+    }
   } else {
     ruby_curl_upload *rbcu;
     TypedData_Get_Struct(upload, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
@@ -725,6 +789,24 @@ static struct curl_slist *duplicate_curl_slist(struct curl_slist *list) {
     return dup;
 }
 
+static VALUE duplicate_upload(VALUE upload) {
+  ruby_curl_upload *rbcu, *newrbcu;
+  VALUE new_upload;
+
+  if (NIL_P(upload)) {
+    return Qnil;
+  }
+
+  TypedData_Get_Struct(upload, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
+
+  new_upload = ruby_curl_upload_new(cCurlUpload);
+  TypedData_Get_Struct(new_upload, ruby_curl_upload, &ruby_curl_upload_data_type, newrbcu);
+  newrbcu->stream = rbcu->stream;
+  newrbcu->offset = rbcu->offset;
+
+  return new_upload;
+}
+
 /*
  * call-seq:
  *   easy.clone                                       => <easy clone>
@@ -763,6 +845,21 @@ 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);
 
+  if (newrbce->opts != Qnil) {
+    VALUE upload = rb_hash_aref(newrbce->opts, rb_easy_hkey("upload"));
+    if (!NIL_P(upload)) {
+      rb_hash_aset(newrbce->opts, rb_easy_hkey("upload"), duplicate_upload(upload));
+      curl_easy_setopt(newrbce->curl, CURLOPT_READFUNCTION, (curl_read_callback)read_data_handler);
+      curl_easy_setopt(newrbce->curl, CURLOPT_READDATA, newrbce);
+#ifdef HAVE_CURLOPT_SEEKFUNCTION
+      curl_easy_setopt(newrbce->curl, CURLOPT_SEEKFUNCTION, (curl_seek_callback)seek_data_handler);
+#endif
+#ifdef HAVE_CURLOPT_SEEKDATA
+      curl_easy_setopt(newrbce->curl, CURLOPT_SEEKDATA, newrbce);
+#endif
+    }
+  }
+
   VALUE clone = TypedData_Wrap_Struct(cCurlEasy, &ruby_curl_easy_data_type, newrbce);
   newrbce->self = clone;
   curl_easy_setopt(newrbce->curl, CURLOPT_PRIVATE, (void*)newrbce);
@@ -801,6 +898,8 @@ static VALUE ruby_curl_easy_close(VALUE self) {
   ruby_curl_easy_zero(rbce);
   rbce->self = self;
 
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, rbce->err_buf);
+
   /* give the new curl handle a reference back to the ruby object */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)rbce);
   if (ecode != CURLE_OK) {
@@ -3095,6 +3194,12 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
     curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
     curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
     curl_easy_setopt(curl, CURLOPT_READDATA, NULL);
+#ifdef HAVE_CURLOPT_SEEKFUNCTION
+    curl_easy_setopt(curl, CURLOPT_SEEKFUNCTION, NULL);
+#endif
+#ifdef HAVE_CURLOPT_SEEKDATA
+    curl_easy_setopt(curl, CURLOPT_SEEKDATA, NULL);
+#endif
     curl_easy_setopt(curl, CURLOPT_INFILESIZE, 0);
   }
 
@@ -3173,19 +3278,68 @@ static VALUE call_easy_perform(VALUE self) {
 }
 
 struct easy_form_perform_args {
+  VALUE self;
   CURL *curl;
+  int argc;
+  VALUE *argv;
   struct curl_httppost *first;
+  struct curl_httppost *last;
+  int clear_customrequest;
+  int form_set_on_curl;
 };
 
+static void append_multipart_form_argument(VALUE arg,
+                                           struct curl_httppost **first,
+                                           struct curl_httppost **last) {
+  if (rb_obj_is_instance_of(arg, cCurlPostField)) {
+    append_to_form(arg, first, last);
+  } else if (rb_type(arg) == T_ARRAY) {
+    long j, argv_len = RARRAY_LEN(arg);
+    for (j = 0; j < argv_len; ++j) {
+      VALUE field = rb_ary_entry(arg, j);
+      if (rb_obj_is_instance_of(field, cCurlPostField)) {
+        append_to_form(field, first, last);
+      } else {
+        rb_raise(eCurlErrInvalidPostField,
+                 "You must use PostFields only with multipart form posts");
+      }
+    }
+  } else {
+    rb_raise(eCurlErrInvalidPostField,
+             "You must use PostFields only with multipart form posts");
+  }
+}
+
+static VALUE build_and_perform_multipart_form(VALUE argp) {
+  struct easy_form_perform_args *args = (struct easy_form_perform_args *)argp;
+  int i;
+
+  for (i = 0; i < args->argc; i++) {
+    append_multipart_form_argument(args->argv[i], &args->first, &args->last);
+  }
+
+  curl_easy_setopt(args->curl, CURLOPT_POST, 0);
+  curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, args->first);
+  args->form_set_on_curl = 1;
+
+  return call_easy_perform(args->self);
+}
+
 static VALUE ensure_free_form_post(VALUE argp) {
   struct easy_form_perform_args *args = (struct easy_form_perform_args *)argp;
   if (args->curl) {
-    curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, NULL);
+    if (args->form_set_on_curl) {
+      curl_easy_setopt(args->curl, CURLOPT_HTTPPOST, NULL);
+    }
+    if (args->clear_customrequest) {
+      curl_easy_setopt(args->curl, CURLOPT_CUSTOMREQUEST, NULL);
+    }
   }
   if (args->first) {
     curl_formfree(args->first);
     args->first = NULL;
   }
+  args->last = NULL;
   return Qnil;
 }
 
@@ -3216,7 +3370,6 @@ static VALUE ensure_free_form_post(VALUE argp) {
 static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   CURL *curl;
-  int i;
   VALUE args_ary;
 
   rb_scan_args(argc, argv, "*", &args_ary);
@@ -3230,33 +3383,8 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 
   if (rbce->multipart_form_post) {
     VALUE ret;
-    struct curl_httppost *first = NULL, *last = NULL;
-
-    // Make the multipart form
-    for (i = 0; i < argc; i++) {
-      if (rb_obj_is_instance_of(argv[i], cCurlPostField)) {
-        append_to_form(argv[i], &first, &last);
-      } else if (rb_type(argv[i]) == T_ARRAY) {
-        // see: https://github.com/rvanlieshout/curb/commit/8bcdefddc0162484681ebd1a92d52a642666a445
-        long c = 0, argv_len = RARRAY_LEN(argv[i]);
-        for (; c < argv_len; ++c) {
-          if (rb_obj_is_instance_of(rb_ary_entry(argv[i],c), cCurlPostField)) {
-            append_to_form(rb_ary_entry(argv[i],c), &first, &last);
-          } else {
-            rb_raise(eCurlErrInvalidPostField, "You must use PostFields only with multipart form posts");
-            return Qnil;
-          }
-        }
-      } else {
-        rb_raise(eCurlErrInvalidPostField, "You must use PostFields only with multipart form posts");
-        return Qnil;
-      }
-    }
-
-    curl_easy_setopt(curl, CURLOPT_POST, 0);
-    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
-    struct easy_form_perform_args perform_args = { curl, first };
-    ret = rb_ensure(call_easy_perform, self, ensure_free_form_post, (VALUE)&perform_args);
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 0, 0 };
+    ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
 
     return ret;
   } else {
@@ -3300,7 +3428,6 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
 static VALUE ruby_curl_easy_perform_patch(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   CURL *curl;
-  int i;
   VALUE args_ary;
 
   rb_scan_args(argc, argv, "*", &args_ary);
@@ -3315,35 +3442,8 @@ static VALUE ruby_curl_easy_perform_patch(int argc, VALUE *argv, VALUE self) {
 
   if (rbce->multipart_form_post) {
     VALUE ret;
-    struct curl_httppost *first = NULL, *last = NULL;
-
-    /* Build the multipart form (same logic as for POST) */
-    for (i = 0; i < argc; i++) {
-      if (rb_obj_is_instance_of(argv[i], cCurlPostField)) {
-        append_to_form(argv[i], &first, &last);
-      } else if (rb_type(argv[i]) == T_ARRAY) {
-        long j, argv_len = RARRAY_LEN(argv[i]);
-        for (j = 0; j < argv_len; ++j) {
-          if (rb_obj_is_instance_of(rb_ary_entry(argv[i], j), cCurlPostField)) {
-            append_to_form(rb_ary_entry(argv[i], j), &first, &last);
-          } else {
-            rb_raise(eCurlErrInvalidPostField,
-                     "You must use PostFields only with multipart form posts");
-            return Qnil;
-          }
-        }
-      } else {
-        rb_raise(eCurlErrInvalidPostField,
-                 "You must use PostFields only with multipart form posts");
-        return Qnil;
-      }
-    }
-    /* Disable the POST flag */
-    curl_easy_setopt(curl, CURLOPT_POST, 0);
-    /* Use the built multipart form as the request body */
-    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
-    struct easy_form_perform_args perform_args = { curl, first };
-    ret = rb_ensure(call_easy_perform, self, ensure_free_form_post, (VALUE)&perform_args);
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0 };
+    ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
     return ret;
   } else {
     /* Join arguments into a raw PATCH body */
@@ -3376,7 +3476,6 @@ static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE args_ary;
-  int i;
 
   rb_scan_args(argc, argv, "*", &args_ary);
   TypedData_Get_Struct(self, ruby_curl_easy, &ruby_curl_easy_data_type, rbce);
@@ -3399,33 +3498,8 @@ static VALUE ruby_curl_easy_perform_put(int argc, VALUE *argv, VALUE self) {
   /* Otherwise, if multipart_form_post is true, use multipart logic */
   else if (rbce->multipart_form_post) {
     VALUE ret;
-    struct curl_httppost *first = NULL, *last = NULL;
-    for (i = 0; i < RARRAY_LEN(args_ary); i++) {
-      VALUE field = rb_ary_entry(args_ary, i);
-      if (rb_obj_is_instance_of(field, cCurlPostField)) {
-        append_to_form(field, &first, &last);
-      } else if (rb_type(field) == T_ARRAY) {
-        long j;
-        for (j = 0; j < RARRAY_LEN(field); j++) {
-          VALUE subfield = rb_ary_entry(field, j);
-          if (rb_obj_is_instance_of(subfield, cCurlPostField)) {
-            append_to_form(subfield, &first, &last);
-          } else {
-            rb_raise(eCurlErrInvalidPostField,
-                     "You must use PostFields only with multipart form posts");
-          }
-        }
-      } else {
-        rb_raise(eCurlErrInvalidPostField,
-                 "You must use PostFields only with multipart form posts");
-      }
-    }
-    curl_easy_setopt(curl, CURLOPT_POST, 0);
-    curl_easy_setopt(curl, CURLOPT_HTTPPOST, first);
-    /* Set the method explicitly to PUT */
-    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
-    struct easy_form_perform_args perform_args = { curl, first };
-    ret = rb_ensure(call_easy_perform, self, ensure_free_form_post, (VALUE)&perform_args);
+    struct easy_form_perform_args perform_args = { self, curl, argc, argv, NULL, NULL, 1, 0 };
+    ret = rb_ensure(build_and_perform_multipart_form, (VALUE)&perform_args, ensure_free_form_post, (VALUE)&perform_args);
     return ret;
   }
   /* Fallback: join all arguments */

data/ext/curb_multi.c

@@ -1695,7 +1695,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
 #elif HAVE_RB_THREAD_BLOCKING_REGION
       rc = rb_thread_blocking_region(curb_select, &fdset_args, RUBY_UBF_IO, 0);
 #else
-      rc = rb_thread_select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
+      rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &tv);
 #endif
 
 #ifdef _WIN32

data/ext/curb_postfield.c

@@ -183,6 +183,7 @@ static void curl_postfield_mark(void *ptr) {
     rb_gc_mark(rbcpf->name);
     rb_gc_mark(rbcpf->content);
     rb_gc_mark(rbcpf->content_type);
+    rb_gc_mark(rbcpf->content_proc);
     rb_gc_mark(rbcpf->local_file);
     rb_gc_mark(rbcpf->remote_file);
     rb_gc_mark(rbcpf->buffer_str);

data/ext/extconf.rb

@@ -685,7 +685,8 @@ test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
 have_func('rb_thread_blocking_region')
 have_header('ruby/thread.h') && have_func('rb_thread_call_without_gvl', 'ruby/thread.h')
 have_header('ruby/io.h')
-have_func('rb_thread_fd_select', 'ruby/io.h')
+# Ruby 4.x exports rb_thread_fd_select without declaring it in ruby/io.h.
+have_func('rb_thread_fd_select')
 have_func('rb_wait_for_single_fd', 'ruby/io.h')
 have_header('ruby/fiber/scheduler.h')
 have_func('rb_fiber_scheduler_current', 'ruby/fiber/scheduler.h')

data/tests/tc_curl_easy.rb

@@ -1301,6 +1301,24 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal "POST\nfoo=bar", curl.body_str
   end
 
+  def test_multipart_patch_build_failure_restores_easy_request_state
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.multipart_form_post = true
+    field = Curl::PostField.content('document_id', '5')
+
+    field.name = nil
+    error = assert_raise(Curl::Err::InvalidPostFieldError) do
+      # The first field allocates native multipart form state before the second field raises.
+      curl.http_patch(Curl::PostField.content('keep', 'allocated'), field)
+    end
+    assert_match(/Cannot post unnamed field/, error.message)
+
+    curl.multipart_form_post = false
+    curl.perform
+
+    assert_equal 'GET', curl.body_str
+  end
+
   def test_delete_remote
     curl = Curl::Easy.new(TestServlet.url)
     curl.http_delete
@@ -1358,6 +1376,35 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_match(/message$/, curl.body_str)
   end
 
+  def test_put_data_read_exception_sets_result_and_releases_callback_state
+    error_class = Class.new(StandardError)
+    reader_class = Class.new do
+      define_method(:read) do |_len|
+        raise error_class, 'upload read failed'
+      end
+
+      def seek(_offset, _whence = SEEK_SET)
+        0
+      end
+
+      def stat
+        Struct.new(:size).new(1)
+      end
+    end
+
+    curl = Curl::Easy.new(TestServlet.url)
+    curl.put_data = reader_class.new
+
+    error = assert_raise(error_class) { curl.perform }
+    assert_equal 'upload read failed', error.message
+    assert_not_equal 0, curl.last_result
+
+    curl.url = TestServlet.url
+    curl.http_get
+
+    assert_equal 'GET', curl.body_str
+  end
+
   # https://github.com/taf2/curb/issues/101
   def test_put_data_null_bytes
     curl = Curl::Easy.new(TestServlet.url)
@@ -1501,6 +1548,18 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     easy.http_get
   end
 
+  def test_easy_close_restores_error_buffer
+    easy = Curl::Easy.new('http://127.0.0.1:1')
+    assert_raise(Curl::Err::ConnectionFailedError) { easy.perform }
+    assert_not_nil easy.last_error
+
+    easy.close
+    easy.url = 'http://127.0.0.1:1'
+    assert_raise(Curl::Err::ConnectionFailedError) { easy.perform }
+
+    assert_not_nil easy.last_error
+  end
+
   def test_easy_reset
     easy = Curl::Easy.new
     easy.url = TestServlet.url + "?query=foo"

data/tests/tc_curl_native_coverage.rb

@@ -90,6 +90,21 @@ class TestCurbCurlNativeCoverage < Test::Unit::TestCase
     easy.close if defined?(easy) && easy
   end
 
+  def test_clone_rebinds_upload_callbacks_to_clone_state
+    easy = Curl::Easy.new(TestServlet.url)
+    easy.put_data = 'clone-data'
+
+    clone = easy.clone
+    easy.put_data = 'other-data'
+
+    clone.perform
+
+    assert_equal "PUT\nclone-data", clone.body_str
+  ensure
+    clone.close if defined?(clone) && clone
+    easy.close if defined?(easy) && easy
+  end
+
   def test_native_accessors_round_trip
     easy = Curl::Easy.new(TestServlet.url)
 

data/tests/tc_curl_postfield.rb

@@ -136,11 +136,26 @@ class TestCurbCurlPostfield < Test::Unit::TestCase
     assert_equal "foo=FOOBAR", pf.to_s
   end
 
+  def test_content_proc_survives_gc
+    pf = postfield_with_only_native_proc_reference
+
+    10.times do
+      GC.start(full_mark: true, immediate_sweep: true)
+      GC.compact if GC.respond_to?(:compact)
+    end
+
+    assert_equal "foo=FOOBAR", pf.to_s
+  end
+
   def test_to_s_04
     pf = Curl::PostField.file('foo.file', 'bar.file')
     assert_nothing_raised { pf.to_s }
     #assert_raise(Curl::Err::InvalidPostFieldError) { pf.to_s }
   end
+
+  def postfield_with_only_native_proc_reference
+    Curl::PostField.content('foo') { |field| field.name.upcase + "BAR" }
+  end
 end
 
 class TestCurbCurlPostfieldNativeCoverage < Test::Unit::TestCase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: curb
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.2
 platform: ruby
 authors:
 - Ross Bamford
 - Todd A. Fisher
 bindir: bin
 cert_chain: []
-date: 2026-04-02 00:00:00.000000000 Z
+date: 2026-04-23 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