curb 1.2.2 → 1.3.1

data/ext/curb_multi.h

@@ -15,13 +15,15 @@ struct st_table;
 typedef struct {
   int active;
   int running;
+  char closed;
   CURLM *handle;
   struct st_table *attached;
 } ruby_curl_multi;
 
 extern VALUE cCurlMulti;
+extern const rb_data_type_t ruby_curl_multi_data_type;
+
 void init_curb_multi();
-VALUE ruby_curl_multi_new(VALUE klass);
 void rb_curl_multi_forget_easy(ruby_curl_multi *rbcm, void *rbce_ptr);
 
 

data/ext/curb_postfield.c

@@ -32,7 +32,7 @@ void append_to_form(VALUE self,
   ruby_curl_postfield *rbcpf;
   CURLFORMcode result = -1;
   
-  Data_Get_Struct(self, ruby_curl_postfield, rbcpf);
+  TypedData_Get_Struct(self, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
   
   if (rbcpf->name == Qnil) {
     rb_raise(eCurlErrInvalidPostField, "Cannot post unnamed field");
@@ -177,19 +177,43 @@ void append_to_form(VALUE self,
 
 
 /* ================== MARK/FREE FUNC ==================*/
-void curl_postfield_mark(ruby_curl_postfield *rbcpf) {
-  rb_gc_mark(rbcpf->name);
-  rb_gc_mark(rbcpf->content);
-  rb_gc_mark(rbcpf->content_type);
-  rb_gc_mark(rbcpf->local_file);
-  rb_gc_mark(rbcpf->remote_file);
-  rb_gc_mark(rbcpf->buffer_str);
+static void curl_postfield_mark(void *ptr) {
+  ruby_curl_postfield *rbcpf = (ruby_curl_postfield *)ptr;
+  if (rbcpf) {
+    rb_gc_mark(rbcpf->name);
+    rb_gc_mark(rbcpf->content);
+    rb_gc_mark(rbcpf->content_type);
+    rb_gc_mark(rbcpf->local_file);
+    rb_gc_mark(rbcpf->remote_file);
+    rb_gc_mark(rbcpf->buffer_str);
+  }
+}
+
+static void curl_postfield_free(void *ptr) {
+  if (ptr) free(ptr);
 }
 
-void curl_postfield_free(ruby_curl_postfield *rbcpf) {
-  free(rbcpf);
+static size_t curl_postfield_memsize(const void *ptr) {
+  (void)ptr;
+  return sizeof(ruby_curl_postfield);
 }
 
+const rb_data_type_t ruby_curl_postfield_data_type = {
+  "Curl::PostField",
+  {
+    curl_postfield_mark,
+    curl_postfield_free,
+    curl_postfield_memsize,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, /* compact */
+#endif
+  },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  NULL, NULL, /* parent, data */
+  RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
 
 /* ================= ALLOC METHODS ====================*/
 
@@ -208,10 +232,11 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
  * data.
  */
 static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass) {
-  ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
-  if (!rbcpf) {
-    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::PostField");
-  }
+  VALUE self;
+  ruby_curl_postfield *rbcpf;
+
+  self = TypedData_Make_Struct(klass, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
+  MEMZERO(rbcpf, ruby_curl_postfield, 1);
  
   // wierdness - we actually require two args, unless a block is provided, but
   // we have to work that out below.
@@ -239,7 +264,7 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
   rbcpf->remote_file = Qnil;
   rbcpf->buffer_str = Qnil;
  
-  return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
+  return self;
 }
 
 /*
@@ -257,10 +282,11 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
  */
 static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
   // TODO needs to handle content-type too
-  ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
-  if (!rbcpf) {
-    rb_raise(rb_eNoMemError, "Failed to allocate memory for Curl::PostField");
-  }
+  VALUE self;
+  ruby_curl_postfield *rbcpf;
+
+  self = TypedData_Make_Struct(klass, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
+  MEMZERO(rbcpf, ruby_curl_postfield, 1);
 
   rb_scan_args(argc, argv, "21&", &rbcpf->name, &rbcpf->local_file, &rbcpf->remote_file, &rbcpf->content_proc);
 
@@ -288,7 +314,7 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
   rbcpf->content_type = Qnil;
   rbcpf->buffer_str = Qnil;
  
-  return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
+  return self;
 }
 
 /* ================= ATTRIBUTES ====================*/
@@ -435,7 +461,7 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
   CURL *curl_handle = NULL;
 #endif
 
-  Data_Get_Struct(self, ruby_curl_postfield, rbcpf);
+  TypedData_Get_Struct(self, ruby_curl_postfield, &ruby_curl_postfield_data_type, rbcpf);
 
   if (rbcpf->name != Qnil) {
     name = rbcpf->name;

data/ext/curb_postfield.h

@@ -30,6 +30,7 @@ typedef struct {
 } ruby_curl_postfield;
 
 extern VALUE cCurlPostField;
+extern const rb_data_type_t ruby_curl_postfield_data_type;
 
 void append_to_form(VALUE self, 
                     struct curl_httppost **first, 

data/ext/curb_upload.c

@@ -10,13 +10,36 @@ VALUE cCurlUpload;
   mCurl = rb_define_module("Curl");
 #endif
 
-static void curl_upload_mark(ruby_curl_upload *rbcu) {
-  if (rbcu->stream && !NIL_P(rbcu->stream)) rb_gc_mark(rbcu->stream);
+static void curl_upload_mark(void *ptr) {
+  ruby_curl_upload *rbcu = (ruby_curl_upload *)ptr;
+  if (rbcu && rbcu->stream && !NIL_P(rbcu->stream)) rb_gc_mark(rbcu->stream);
 }
-static void curl_upload_free(ruby_curl_upload *rbcu) {
-  free(rbcu);
+
+static void curl_upload_free(void *ptr) {
+  if (ptr) free(ptr);
+}
+
+static size_t curl_upload_memsize(const void *ptr) {
+  (void)ptr;
+  return sizeof(ruby_curl_upload);
 }
 
+const rb_data_type_t ruby_curl_upload_data_type = {
+  "Curl::Upload",
+  {
+    curl_upload_mark,
+    curl_upload_free,
+    curl_upload_memsize,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    NULL, /* compact */
+#endif
+  },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  NULL, NULL, /* parent, data */
+  RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
 /*
  * call-seq:
  *   internal class for sending large file uploads
@@ -29,7 +52,7 @@ VALUE ruby_curl_upload_new(VALUE klass) {
   }
   rbcu->stream = Qnil;
   rbcu->offset = 0;
-  upload = Data_Wrap_Struct(klass, curl_upload_mark, curl_upload_free, rbcu);
+  upload = TypedData_Wrap_Struct(klass, &ruby_curl_upload_data_type, rbcu);
   return upload;
 }
 
@@ -39,7 +62,7 @@ VALUE ruby_curl_upload_new(VALUE klass) {
  */
 VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
   rbcu->stream = stream;
   return stream;
 }
@@ -49,7 +72,7 @@ VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
  */
 VALUE ruby_curl_upload_stream_get(VALUE self) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
   return rbcu->stream;
 }
 /*
@@ -58,7 +81,7 @@ VALUE ruby_curl_upload_stream_get(VALUE self) {
  */
 VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
   rbcu->offset = NUM2LONG(offset);
   return offset;
 }
@@ -68,7 +91,7 @@ VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
  */
 VALUE ruby_curl_upload_offset_get(VALUE self) {
   ruby_curl_upload *rbcu;
-  Data_Get_Struct(self, ruby_curl_upload, rbcu);
+  TypedData_Get_Struct(self, ruby_curl_upload, &ruby_curl_upload_data_type, rbcu);
   return LONG2NUM(rbcu->offset);
 }
 

data/ext/curb_upload.h

@@ -19,6 +19,8 @@ typedef struct {
 } ruby_curl_upload;
 
 extern VALUE cCurlUpload;
+extern const rb_data_type_t ruby_curl_upload_data_type;
+
 void init_curb_upload();
 
 VALUE ruby_curl_upload_new(VALUE klass);

data/ext/extconf.rb

@@ -299,6 +299,38 @@ have_constant "curlopt_sockoptdata"
 have_constant "curlopt_opensocketfunction"
 have_constant "curlopt_opensocketdata"
 
+# Deprecated constants (still check for them for backward compat)
+have_constant "curlopt_ioctlfunction"
+have_constant "curlopt_ioctldata"
+have_constant "curlopt_progressfunction"
+have_constant "curlopt_progressdata"
+have_constant "curlopt_conv_to_network_function"
+have_constant "curlopt_conv_from_network_function"
+have_constant "curlopt_conv_from_utf8_function"
+
+# Replacements for deprecated constants
+# CURLOPT_PROGRESSFUNCTION -> CURLOPT_XFERINFOFUNCTION (since 7.32.0)
+have_constant "curlopt_xferinfofunction"
+have_constant "curlopt_xferinfodata"
+
+# CURLOPT_PROTOCOLS -> CURLOPT_PROTOCOLS_STR (since 7.85.0)
+have_constant "curlopt_protocols_str"
+have_constant "curlopt_redir_protocols_str"
+
+# CURLOPT_SOCKS5_GSSAPI_SERVICE -> CURLOPT_PROXY_SERVICE_NAME (since 7.49.0)
+have_constant "curlopt_proxy_service_name"
+
+# CURLOPT_HTTPPOST -> CURLOPT_MIMEPOST (since 7.56.0)
+have_constant "curlopt_mimepost"
+
+# CURLINFO_* -> CURLINFO_*_T (since 7.55.0)
+have_constant "curlinfo_size_upload_t"
+have_constant "curlinfo_size_download_t"
+have_constant "curlinfo_speed_upload_t"
+have_constant "curlinfo_speed_download_t"
+have_constant "curlinfo_content_length_download_t"
+have_constant "curlinfo_content_length_upload_t"
+
 # additional consts
 have_constant "curle_conv_failed"
 have_constant "curle_conv_reqd"
@@ -621,6 +653,14 @@ if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
 
+# Clang-specific warning suppressions (not recognized by GCC)
+# These are used to suppress warnings in Ruby header macros
+%w[-Wno-self-assign -Wno-parentheses-equality -Wno-constant-logical-operand].each do |flag|
+  if try_compile('int main() { return 0; }', flag)
+    $CFLAGS << " #{flag}"
+  end
+end
+
 # do some checking to detect ruby 1.8 hash.c vs ruby 1.9 hash.c
 def test_for(name, const, src)
   checking_for name do
@@ -645,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/lib/curl/easy.rb

@@ -1,7 +1,106 @@
 # frozen_string_literal: true
 module Curl
   class Easy
+    class << self
+      def deferred_multi_close_mutex
+        @deferred_multi_close_mutex ||= Mutex.new
+      end
+
+      def deferred_multi_closes
+        deferred_multi_close_mutex.synchronize do
+          (@deferred_multi_closes ||= []).dup
+        end
+      end
+
+      def release_deferred_multi_close(multi, easy)
+        if easy && multi.requests[easy.object_id]
+          begin
+            multi.remove(easy)
+          rescue StandardError
+            # Deferred cleanup only applies to implicit single-easy multis, so
+            # clear any stale Ruby bookkeeping and continue closing the handle.
+            multi.instance_variable_set(:@requests, {})
+          end
+        else
+          multi.instance_variable_set(:@requests, {})
+        end
+
+        multi.instance_variable_set(:@deferred_close, false)
+        multi._close
+        true
+      rescue StandardError
+        false
+      end
 
+      def defer_multi_close(multi, easy, owner: Thread.current)
+        deferred_multi_close_mutex.synchronize do
+          @deferred_multi_closes ||= []
+          return if @deferred_multi_closes.any? { |entry| entry[:multi].equal?(multi) }
+
+          multi.instance_variable_set(:@deferred_close, true)
+          @deferred_multi_closes << { multi: multi, easy: easy, owner: owner }
+        end
+      end
+
+      def flush_deferred_multi_closes(all_threads: false)
+        pending = deferred_multi_close_mutex.synchronize do
+          @deferred_multi_closes ||= []
+
+          if all_threads
+            @deferred_multi_closes.shift(@deferred_multi_closes.length)
+          else
+            owner = Thread.current
+            remaining = []
+            current = []
+
+            @deferred_multi_closes.each do |entry|
+              if entry[:owner].equal?(owner)
+                current << entry
+              else
+                remaining << entry
+              end
+            end
+
+            @deferred_multi_closes = remaining
+            current
+          end
+        end
+
+        pending.each do |entry|
+          multi = entry[:multi]
+          easy = entry[:easy]
+
+          unless release_deferred_multi_close(multi, easy)
+            defer_multi_close(multi, easy, owner: entry[:owner])
+          end
+        end
+      end
+    end
+
+    at_exit do
+      flush_deferred_multi_closes(all_threads: true)
+    end
+    
+    alias_method :_curb_native_close, :close
+    alias_method :_curb_native_multi_set, :multi=
+    
+    def close
+      previous_multi = self.multi
+      result = _curb_native_close
+      previous_multi.__send__(:__unregister_idle_easy_reference, self) if previous_multi
+      result
+    end
+    
+    def multi=(multi)
+      previous_multi = self.multi
+      return multi if previous_multi.equal?(multi)
+    
+      result = _curb_native_multi_set(multi)
+      previous_multi.__send__(:__unregister_idle_easy_reference, self) if previous_multi
+      multi.__send__(:__register_idle_easy_reference, self) if multi
+      result
+    end
+    
     alias post http_post
     alias put http_put
     alias body body_str
@@ -64,18 +163,55 @@ module Curl
     # the configured HTTP Verb.
     #
     def perform
-      self.multi = Curl::Multi.new if self.multi.nil?
-      self.multi.add self
-      ret = self.multi.perform
-      self.multi.remove self
-
-      if Curl::Multi.autoclose
-        self.multi.close
-        self.multi = nil
+      self.class.flush_deferred_multi_closes
+
+      if Curl.scheduler_active? && self.multi.nil?
+        ret = Curl.perform_with_scheduler(self)
+      else
+        multi = self.multi
+        created_multi = multi.nil?
+        raised = false
+
+        if created_multi
+          multi = Curl::Multi.new
+          self.multi = multi
+        end
+
+        begin
+          multi.add(self)
+          ret = multi.perform
+          multi.remove(self) if self.multi == multi
+        rescue Exception
+          raised = true
+          raise
+        ensure
+          if created_multi
+            if raised
+              unless self.class.release_deferred_multi_close(multi, self)
+                self.class.defer_multi_close(multi, self)
+              end
+              self.multi = nil if self.multi == multi
+            elsif Curl::Multi.autoclose
+              multi.__send__(:_autoclose)
+              self.multi = nil if self.multi == multi
+            else
+              self.multi = multi
+            end
+          elsif Curl::Multi.autoclose
+            multi.__send__(:_autoclose)
+            self.multi = nil if self.multi == multi
+          else
+            self.multi = multi
+          end
+        end
+      end
+
+      if (callback_error = _take_callback_error)
+        raise callback_error
       end
 
       if self.last_result != 0 && self.on_failure.nil?
-        (err_class, err_summary) = Curl::Easy.error(self.last_result)
+        err_class, err_summary = Curl::Easy.error(self.last_result)
         err_detail = self.last_error
         raise err_class.new([err_summary, err_detail].compact.join(": "))
       end
@@ -85,6 +221,7 @@ module Curl
 
     #
     # call-seq:
+
     #
     # easy = Curl::Easy.new
     # easy.nosignal = true
@@ -109,12 +246,16 @@ module Curl
     #
     #  easy = Curl::Easy.new("url")
     #  easy.version = Curl::HTTP_2_0
-    #  easy.version = Curl::HTTP_1_1
-    #  easy.version = Curl::HTTP_1_0
-    #  easy.version = Curl::HTTP_NONE
+    #  easy.http_version = Curl::HTTP_1_1
+    #  easy.http_version = Curl::HTTP_1_0
+    #  easy.http_version = Curl::HTTP_NONE
     #
     def version=(http_version)
-      set :http_version, http_version
+      self.http_version = http_version
+    end
+
+    def version
+      http_version
     end
 
     #

data/lib/curl/multi.rb

@@ -160,16 +160,20 @@ module Curl
           end
         end
 
-        if urls_with_config.empty?
-          m.perform
-        else
-          until urls_with_config.empty?
-            m.perform do
+        begin
+          if urls_with_config.empty?
+            m.perform
+          else
+            until urls_with_config.empty?
+              m.perform do
+                consume_free_handles.call
+              end
               consume_free_handles.call
             end
-            consume_free_handles.call
+            free_handles = nil
           end
-          free_handles = nil
+        ensure
+          m.close
         end
 
       end
@@ -266,10 +270,53 @@ module Curl
       @requests ||= {}
     end
 
+    def __idle_easy_references
+      @__curb_idle_easy_references ||= ObjectSpace::WeakMap.new
+    end
+    
+    def __register_idle_easy_reference(easy)
+      __idle_easy_references[easy] = true
+      self
+    end
+    
+    def __unregister_idle_easy_reference(easy)
+      return self unless instance_variable_defined?(:@__curb_idle_easy_references)
+
+      if @__curb_idle_easy_references.respond_to?(:delete)
+        @__curb_idle_easy_references.delete(easy)
+      else
+        retained_references = ObjectSpace::WeakMap.new
+        @__curb_idle_easy_references.each_key do |tracked_easy|
+          next if tracked_easy.equal?(easy)
+
+          retained_references[tracked_easy] = true
+        end
+        @__curb_idle_easy_references = retained_references
+      end
+
+      self
+    end
+    
+    def __clear_idle_easy_references
+      return unless instance_variable_defined?(:@__curb_idle_easy_references)
+    
+      @__curb_idle_easy_references.keys.each do |easy|
+        easy.multi = nil if easy.multi.equal?(self)
+      end
+      @__curb_idle_easy_references = ObjectSpace::WeakMap.new
+    end
+
+    private :__idle_easy_references, :__register_idle_easy_reference,
+            :__unregister_idle_easy_reference, :__clear_idle_easy_references
+
     def add(easy)
       return self if requests[easy.object_id]
-      requests[easy.object_id] = easy
+      # Once a deferred callback exception is pending, Multi#perform is
+      # draining existing transfers only and must not start replacement work.
+      return self if instance_variable_defined?(:@__curb_deferred_exception)
       _add(easy)
+      __unregister_idle_easy_reference(easy)
+      requests[easy.object_id] = easy
       self
     end
 
@@ -281,14 +328,27 @@ module Curl
     end
 
     def close
+      __close(true)
+    end
+
+    def _autoclose
+      __close(false)
+    end
+
+    private :_autoclose
+
+    private
+
+    def __close(permanent)
       requests.values.each {|easy|
         _remove(easy)
       }
+      __clear_idle_easy_references if permanent
       @requests = {}
       _close
+      _mark_closed if permanent
       self
     end
 
-
   end
 end