ory-client 1.22.87 → 1.22.88

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/easy.rb

@@ -12,11 +12,12 @@ require 'ethon/easy/operations'
 require 'ethon/easy/response_callbacks'
 require 'ethon/easy/debug_info'
 require 'ethon/easy/mirror'
+require 'ethon/easy/files'
 
 module Ethon
 
   # This is the class representing the libcurl easy interface
-  # See http://curl.haxx.se/libcurl/c/libcurl-easy.html for more informations.
+  # See https://curl.se/libcurl/c/libcurl-easy.html for more informations.
   #
   # @example You can access the libcurl easy interface through this class, every request is based on it. The simplest setup looks like that:
   #
@@ -41,6 +42,7 @@ module Ethon
     include Ethon::Easy::Http
     include Ethon::Easy::Operations
     include Ethon::Easy::ResponseCallbacks
+    include Ethon::Easy::Files
     extend Ethon::Easy::Features
 
     # Returns the curl return code.
@@ -197,7 +199,7 @@ module Ethon
     #   * :obsolete: These error codes will never be returned. They were used in an old
     #     libcurl version and are currently unused.
     #
-    # @see http://curl.haxx.se/libcurl/c/libcurl-errors.html
+    # @see https://curl.se/libcurl/c/libcurl-errors.html
     attr_accessor :return_code
 
     # Initialize a new Easy.
@@ -214,11 +216,18 @@ module Ethon
     # @return [ Easy ] A new Easy.
     #
     # @see Ethon::Easy::Options
-    # @see http://curl.haxx.se/libcurl/c/curl_easy_setopt.html
+    # @see https://curl.se/libcurl/c/curl_easy_setopt.html
     def initialize(options = {})
       Curl.init
-      set_attributes(options)
+      options = options.dup
+      # Apply a supplied handle before the other options so they are set on
+      # that handle instead of the one Ethon would otherwise create.
+      handle_key = options.keys.find { |key| key.to_s == "handle" }
+      self.handle = options.delete(handle_key) if handle_key
+      # Install Ethon's internal callbacks first so callback options passed to
+      # the constructor override them instead of being overwritten here.
       set_callbacks
+      set_attributes(options)
     end
 
     # Set given options.
@@ -247,31 +256,144 @@ module Ethon
     # @example Reset.
     #   easy.reset
     def reset
+      ensure_not_attached_to_multi!
+      ensure_not_in_transfer!
+      # Check the handle before clearing state so reset is a no-op when the
+      # handle was cleaned up or inherited across a fork.
+      handle
+      # Close the response stream before clearing any state. If closing fails,
+      # leave the handle and its Ruby-side description untouched so the caller
+      # can recover instead of ending up with a half-reset Easy.
+      clear_response_body_io
+
+      @postfields = nil
+      @postfields_pointer = nil
+      @postfield_body_size = nil
+      @postfieldsize_value = nil
       @url = nil
       @escape = nil
-      @hash = nil
+      @multipart = nil
+      @headers = nil
+      @return_code = nil
+      # A reset from on_complete is cleanup for the finished transfer. Keep a
+      # callback error so perform still raises it afterwards.
+      @callback_error = nil unless @completing
       @on_complete = nil
       @on_headers = nil
       @on_body = nil
       @on_progress = nil
+      @progress_source = nil
+      @internal_progress_option = nil
+      @user_debug_callback = nil
+      @noprogress_value = nil
       @procs = nil
+      @blobs = nil
+      @slists = nil
       @mirror = nil
+      @read_callback = nil
+      @request_body = nil
+      @request_body_start = nil
       Curl.easy_reset(handle)
+      # libcurl no longer references these after easy_reset.
+      @header_list = nil
+      handle.error_buffer = nil
+      @error_buffer_enabled = nil
+      @multipart_form = nil
+      @curlu = nil
+      @mime = nil
+      # curl_easy_reset preserves CURLOPT_SHARE, so detach it explicitly.
+      self.share = nil if @share
       set_callbacks
     end
 
     # Clones libcurl session handle. This means that all options that is set in
     #   the current handle will be set on duplicated handle.
+    #
+    # libcurl requires the source handle to be idle while it is cloned, and the
+    # copy can never be part of the same Multi. An Easy that a Multi owns must
+    # therefore be removed first.
+    #
+    # @raise [ Errors::EthonError ] If the Easy is still attached to a Multi.
     def dup
+      ensure_not_performing!
+      ensure_not_attached_to_multi!
+      unless Curl.respond_to?(:easy_duphandle)
+        raise NotImplementedError, "curl_easy_duphandle is not supported by this libcurl"
+      end
+
       e = super
-      e.handle = Curl.easy_duphandle(handle)
+      duplicated_handle = Curl.easy_duphandle(handle)
+      raise NoMemoryError, "curl_easy_duphandle failed" if duplicated_handle.null?
+
+      # The copied callback closures still reference the original Easy. Clear
+      # them before installing callbacks on the duplicate so the new native
+      # handle never points at the original.
       e.instance_variable_set(:@body_write_callback, nil)
       e.instance_variable_set(:@header_write_callback, nil)
       e.instance_variable_set(:@debug_callback, nil)
       e.instance_variable_set(:@progress_callback, nil)
+      e.instance_variable_set(:@user_debug_callback, @user_debug_callback)
+      # Do not share an open response stream with the original. A path
+      # destination stays configured so the copy opens its own stream for the
+      # next transfer; a caller-owned IO is dropped because both handles would
+      # write into the same object.
+      e.instance_variable_set(:@response_body_io, nil)
+      e.instance_variable_set(:@owns_response_body_io, false)
+      e.instance_variable_set(:@multi, nil)
+      # The duplicated native handle already carries the request options, so
+      # keep the Ruby-side request state that describes them.
+      e.send(:assign_handle, Curl::EasyHandle.new(duplicated_handle), false)
+      # curl_easy_duphandle copies the native MIME structure, but there is no
+      # way to wrap that copy. Keeping the original wrapper would make both
+      # handles appear to share a structure they do not actually share.
+      e.instance_variable_set(:@mime, nil)
       e.set_callbacks
+      restore_callbacks_on(e)
+      # curl_easy_duphandle copies the error buffer pointer, give the copy its own
+      e.instance_variable_set(:@error_buffer, nil)
+      e.errorbuffer = true if @error_buffer_enabled
+      # curl_easy_duphandle does not inherit share state, so reattach it.
+      e.share = e.share if e.share
+      # The copy starts a fresh transfer and must not report the original's
+      # result or a callback error from it.
+      e.return_code = nil
+      e.clear_callback_error
       e
     end
+
+    # Install fresh callback closures on a duplicate.
+    #
+    # curl_easy_duphandle copies callback pointers, but those closures still
+    # reference the original Easy. Reinstalling them keeps the duplicate from
+    # calling into the original and from depending on it staying alive.
+    def restore_callbacks_on(copy)
+      if defined?(@request_body) && @request_body
+        copy.set_read_callback(@request_body)
+        # Replay the original body range instead of wherever the shared body
+        # happens to be when the copy is made.
+        copy.instance_variable_set(:@request_body_start, @request_body_start)
+      end
+
+      (@procs || {}).each do |option, callback|
+        next if option == :readfunction && defined?(@request_body) && @request_body
+
+        copy.public_send("#{option}=", callback)
+      end
+
+      # Replay custom progress functions first: on_progress installs its
+      # internal callback on top of them, so it has to win in the same order.
+      if @progress_source == :internal && defined?(@on_progress) && @on_progress && @progress_callback
+        copy.set_progress_callback
+      end
+    end
+    private :restore_callbacks_on
+
+    # Cloning shares the native handle, so route it through #dup instead.
+    def clone(freeze: true)
+      copy = dup
+      copy.freeze if freeze && frozen?
+      copy
+    end
     # Url escapes the value.
     #
     # @example Url escape.
@@ -284,9 +406,13 @@ module Ethon
     # @api private
     def escape(value)
       string_pointer = Curl.easy_escape(handle, value, value.bytesize)
-      returned_string = string_pointer.read_string
-      Curl.free(string_pointer)
-      returned_string
+      raise NoMemoryError, "curl_easy_escape failed" if string_pointer.null?
+
+      begin
+        string_pointer.read_string.force_encoding(value.encoding)
+      ensure
+        Curl.free(string_pointer)
+      end
     end
 
     # Returns the informations available through libcurl as
@@ -299,7 +425,7 @@ module Ethon
     end
 
     def mirror
-      @mirror ||= Mirror.from_easy(self)
+      Mirror.from_easy(self)
     end
 
     # Return pretty log out.
@@ -311,5 +437,54 @@ module Ethon
     def log_inspect
       "EASY #{mirror.log_informations.map{|k, v| "#{k}=#{v}"}.flatten.join(' ')}"
     end
+
+    # Url unescapes the value.
+    #
+    # @example Url unescape.
+    #   easy.unescape("a%20b")
+    #   #=> "a b"
+    #
+    # @param [ String ] value The value to unescape.
+    #
+    # @return [ String ] The unescaped value.
+    def unescape(value)
+      unless Curl.respond_to?(:easy_unescape)
+        raise NotImplementedError, "curl_easy_unescape is not supported by this libcurl"
+      end
+
+      out_length = FFI::MemoryPointer.new(:int)
+      string_pointer = Curl.easy_unescape(handle, value, value.bytesize, out_length)
+      raise NoMemoryError, "curl_easy_unescape failed" if string_pointer.null?
+
+      begin
+        string_pointer.read_string(out_length.read_int).force_encoding(value.encoding)
+      ensure
+        Curl.free(string_pointer)
+      end
+    end
+
+    # Pause or resume a transfer. See Curl::PAUSE_*.
+    #
+    # @param [ Integer ] bitmask The parts to pause.
+    #
+    # @return [ Symbol ] The Curl return code.
+    def pause(bitmask = 0)
+      unless Curl.respond_to?(:easy_pause)
+        raise NotImplementedError, "curl_easy_pause is not supported by this libcurl"
+      end
+
+      Curl.easy_pause(handle, bitmask)
+    end
+
+    # Let libcurl perform connection upkeep tasks.
+    #
+    # @return [ Symbol ] The Curl return code.
+    def upkeep
+      unless Curl.respond_to?(:easy_upkeep)
+        raise NotImplementedError, "curl_easy_upkeep is not supported by this libcurl"
+      end
+
+      Curl.easy_upkeep(handle)
+    end
   end
 end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/fork_safety.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+    class ForkSafety < EthonError
+      def initialize
+        super("Ethon cannot use libcurl initialized before a fork; use fork+exec or initialize libcurl after forking")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/form_add.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when curl_formadd fails.
+    class FormAdd < EthonError
+      def initialize(code)
+        super("An error occurred adding a form field: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/global_init.rb

@@ -5,7 +5,7 @@ module Ethon
     # Raises when global_init failed.
     class GlobalInit < EthonError
       def initialize
-        super("An error occured initializing curl.")
+        super("An error occurred initializing curl.")
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/header.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when curl_easy_header fails.
+    class Header < EthonError
+      def initialize(code)
+        super("An error occurred reading headers: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/invalid_option.rb

@@ -5,7 +5,9 @@ module Ethon
     # Raises when option is invalid.
     class InvalidOption < EthonError
       def initialize(option)
-        super("The option: #{option} is invalid.")
+        # Inspect so control characters in an untrusted option name cannot
+        # inject lines into logs that record the message.
+        super("The option: #{option.inspect} is invalid.")
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/invalid_value.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raises when option is invalid.
+    class InvalidValue < EthonError
+      def initialize(option, value)
+        # Inspect so control characters in a rejected value cannot inject
+        # lines into logs that record the message.
+        super("The value: #{value.inspect} is invalid for option: #{option}.")
+      end
+    end
+  end
+end
+

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/mime.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when a curl MIME API call fails.
+    class Mime < EthonError
+      def initialize(code)
+        message = if Ethon::Curl.respond_to?(:easy_strerror)
+          Ethon::Curl.easy_strerror(code)
+        else
+          code.to_s
+        end
+        super("An error occurred building the MIME form: #{message}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/multi_add.rb

@@ -5,7 +5,7 @@ module Ethon
     # Raises when multi_add_handle failed.
     class MultiAdd < EthonError
       def initialize(code, easy)
-        super("An error occured adding the easy handle: #{easy} to the multi: #{code}")
+        super("An error occurred adding the easy handle: #{easy} to the multi: #{code}")
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/multi_assign.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when curl_multi_assign fails.
+    class MultiAssign < EthonError
+      def initialize(code)
+        super("An error occurred assigning the multi socket: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/multi_fdset.rb

@@ -5,7 +5,7 @@ module Ethon
     # Raises when multi_fdset failed.
     class MultiFdset < EthonError
       def initialize(code)
-        super("An error occured getting the fdset: #{code}")
+        super("An error occurred getting the fdset: #{code}")
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/multi_perform.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raises when multi_perform failed.
+    class MultiPerform < EthonError
+      def initialize(code)
+        super("An error occurred performing the multi: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/multi_poll.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when curl_multi_poll fails.
+    class MultiPoll < EthonError
+      def initialize(code)
+        super("An error occurred polling the multi: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/multi_remove.rb

@@ -5,7 +5,7 @@ module Ethon
     # Raises when multi_remove_handle failed.
     class MultiRemove < EthonError
       def initialize(code, easy)
-        super("An error occured removing the easy handle: #{easy} from the multi: #{code}")
+        super("An error occurred removing the easy handle: #{easy} from the multi: #{code}")
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/multi_timeout.rb

@@ -5,8 +5,8 @@ module Ethon
     # Raised when multi_timeout failed.
     class MultiTimeout < EthonError
       def initialize(code)
-        super("An error occured getting the timeout: #{code}")
-        # "An error occured getting the timeout: #{code}: #{Curl.multi_strerror(code)}"
+        super("An error occurred getting the timeout: #{code}")
+        # "An error occurred getting the timeout: #{code}: #{Curl.multi_strerror(code)}"
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/multi_wait.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when curl_multi_wait fails.
+    class MultiWait < EthonError
+      def initialize(code)
+        super("An error occurred waiting on the multi: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/multi_wakeup.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when curl_multi_wakeup fails.
+    class MultiWakeup < EthonError
+      def initialize(code)
+        super("An error occurred waking up the multi: #{code}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors/select.rb

@@ -5,7 +5,7 @@ module Ethon
     # Raised when select failed.
     class Select < EthonError
       def initialize(errno)
-        super("An error occured on select: #{errno}")
+        super("An error occurred on select: #{errno}")
       end
     end
   end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/set_option.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when libcurl rejects an option value.
+    class SetOption < EthonError
+      def initialize(option, code, type = :easy)
+        message = begin
+          strerror(type, code)
+        rescue StandardError
+          code.to_s
+        end
+        # Inspect so control characters in an untrusted option name cannot
+        # inject lines into logs that record the message.
+        super("libcurl failed to set the option: #{option.inspect}: #{message} (#{code})")
+      end
+
+      private
+
+      # Multi and easy codes overlap, so decode with the matching strerror.
+      def strerror(type, code)
+        func = type == :multi ? :multi_strerror : :easy_strerror
+        Ethon::Curl.respond_to?(func) ? Ethon::Curl.public_send(func, code) : code.to_s
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/share.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when a curl share API call fails.
+    class Share < EthonError
+      def initialize(code)
+        message = if Ethon::Curl.respond_to?(:share_strerror)
+          Ethon::Curl.share_strerror(code)
+        else
+          code.to_s
+        end
+        super("An error occurred handling the share: #{message}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/unsupported_option.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when libcurl does not recognize an option.
+    #
+    # This happens when Ethon knows an option that the loaded libcurl is too
+    # old to support, for example an option added in a newer libcurl release.
+    class UnsupportedOption < EthonError
+      def initialize(option)
+        version = begin
+          Ethon::Curl.version_info[:version]
+        rescue StandardError
+          nil
+        end
+        version = Ethon::Curl.version if version.nil?
+        # Inspect so control characters in an untrusted option name cannot
+        # inject lines into logs that record the message.
+        super("libcurl #{version} does not support the option: #{option.inspect}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/errors/url.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module Ethon
+  module Errors
+
+    # Raised when a curl URL API call fails.
+    class Url < EthonError
+      def initialize(code)
+        message = if Ethon::Curl.respond_to?(:url_strerror)
+          Ethon::Curl.url_strerror(code)
+        else
+          code.to_s
+        end
+        super("An error occurred handling the URL: #{message}")
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/errors.rb

@@ -1,13 +1,26 @@
 # frozen_string_literal: true
 require 'ethon/errors/ethon_error'
+require 'ethon/errors/url'
 require 'ethon/errors/global_init'
+require 'ethon/errors/form_add'
 require 'ethon/errors/multi_timeout'
+require 'ethon/errors/multi_assign'
 require 'ethon/errors/multi_fdset'
+require 'ethon/errors/share'
 require 'ethon/errors/multi_add'
 require 'ethon/errors/multi_remove'
+require 'ethon/errors/header'
+require 'ethon/errors/multi_perform'
 require 'ethon/errors/select'
 require 'ethon/errors/invalid_option'
 require 'ethon/errors/invalid_value'
+require 'ethon/errors/set_option'
+require 'ethon/errors/unsupported_option'
+require 'ethon/errors/mime'
+require 'ethon/errors/fork_safety'
+require 'ethon/errors/multi_wait'
+require 'ethon/errors/multi_poll'
+require 'ethon/errors/multi_wakeup'
 
 module Ethon
 

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/libc.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'etc'
+
+module Ethon
+
+  # FFI Wrapper module for Libc.
+  #
+  # @api private
+  module Libc
+    extend FFI::Library
+    ffi_lib 'c'
+
+    # :nodoc:
+    def self.windows?
+      Gem.win_platform?
+    end
+
+    def self.open_max
+      value = Etc.sysconf(Etc::SC_OPEN_MAX)
+      return value if value && value > 0
+
+      Process.getrlimit(:NOFILE).first
+    rescue NameError, NotImplementedError
+      Process.getrlimit(:NOFILE).first
+    end
+
+    # Size of the native fd_set, rounded up to whole longs. An unaligned
+    # ETHON_FD_SIZE would make select write past the Ruby-side struct.
+    def self.fd_size(value = ENV['ETHON_FD_SIZE'])
+      value = value.to_s
+      size = if value.empty?
+        [open_max, 65_536].min
+      else
+        begin
+          Integer(value, 10)
+        rescue ArgumentError, TypeError
+          raise ArgumentError, "ETHON_FD_SIZE must be a positive integer"
+        end
+      end
+      raise ArgumentError, "ETHON_FD_SIZE must be a positive integer" unless size > 0
+
+      word = FFI::Type::LONG.size
+      ((size + word - 1) / word) * word
+    end
+
+    unless windows?
+      attach_function :free, [:pointer], :void
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/{ethon-0.18.0 → ethon-0.19.1}/lib/ethon/loggable.rb

@@ -14,7 +14,7 @@ module Ethon
     #
     # @return [ Logger ] The logger.
     def logger
-      return @logger if defined?(@logger)
+      return @logger if defined?(@logger) && @logger
       @logger = rails_logger || default_logger
     end