ethon 0.18.0 → 0.19.0

data/lib/ethon/curls/options.rb

@@ -1,10 +1,40 @@
 # frozen_string_literal: true
+require 'ethon/easy/util'
 module Ethon
   module Curls
 
     # This module contains logic for setting options on
     # easy or multi interface.
     module Options
+      # libcurl writes these values verbatim into an HTTP request line, a
+      # protocol header, or a protocol command. A carriage return or newline
+      # would let a caller inject another header or command into the request.
+      #
+      # The URL is parsed later, but libcurl only rejects CR/LF at transfer
+      # time. Accepting it here would store an invalid value in Easy#url and
+      # write it to the debug log before the transfer fails.
+      LINE_BASED_OPTIONS = [
+        :accept_encoding,
+        :cookie,
+        :customrequest,
+        :encoding,
+        :ftp_account,
+        :ftp_alternative_to_user,
+        :haproxy_client_ip,
+        :krblevel,
+        :login_options,
+        :mail_auth,
+        :mail_from,
+        :range,
+        :referer,
+        :request_target,
+        :rtsp_session_id,
+        :rtsp_stream_uri,
+        :rtsp_transport,
+        :url,
+        :useragent,
+        :xoauth2_bearer
+      ].freeze
 
       OPTION_STRINGS = { :easy => 'easy_options', :multi => 'multi_options' }.freeze
       FOPTION_STRINGS = { :easy => 'EASY_OPTIONS', :multi => 'MULTI_OPTIONS' }.freeze
@@ -12,19 +42,27 @@ module Ethon
       # Sets appropriate option for easy, depending on value type.
       def set_option(option, value, handle, type = :easy)
         type = type.to_sym unless type.is_a?(Symbol)
-        raise NameError, "Ethon::Curls::Options unknown type #{type}." unless respond_to?(OPTION_STRINGS[type])
+        raise NameError, "Ethon::Curls::Options unknown type #{type}." unless OPTION_STRINGS.key?(type)
         opthash=send(OPTION_STRINGS[type], nil)
         raise Errors::InvalidOption.new(option) unless opthash.include?(option)
 
+        # A freed wrapper still looks like a pointer, but libcurl would keep
+        # the dangling address. Reject it before the option reaches native
+        # state.
+        if defined?(Ethon::Curl::OwnedPointer) && value.is_a?(Ethon::Curl::OwnedPointer)
+          value.check_pid!
+        end
+
         case opthash[option][:type]
         when :none
-          return if value.nil?
+          # These options take no value; false means "do not enable".
+          return unless value
           value=1
           va_type=:long
         when :int
           return if value.nil?
           va_type=:long
-          value=value.to_i
+          value = Ethon::Curls::Options.integer_value(option, value)
         when :bool
           return if value.nil?
           va_type=:long
@@ -32,41 +70,55 @@ module Ethon
         when :time
           return if value.nil?
           va_type=:long
-          value=value.to_i
+          value = Ethon::Curls::Options.integer_value(option, value)
         when :enum
           return if value.nil?
           va_type=:long
-          value = case value
-          when Symbol
-            opthash[option][:opts][value]
-          when String
-            opthash[option][:opts][value.to_sym]
-          else
-            value
-          end.to_i
+          value = named_option_value(option, value, opthash[option][:opts])
         when :bitmask
           return if value.nil?
           va_type=:long
-          value = case value
-          when Symbol
-            opthash[option][:opts][value]
-          when Array
-            value.inject(0) { |res,v| res|opthash[option][:opts][v] }
-          else
-            value
-          end.to_i
+          value = Array(value).inject(0) do |mask, item|
+            mask | named_option_value(option, item, opthash[option][:opts])
+          end
         when :string
           va_type=:string
-          value=value.to_s unless value.nil?
+          unless value.nil?
+            string = value.to_s
+            raise Errors::InvalidValue.new(option, value) if string.include?("\0")
+            if LINE_BASED_OPTIONS.include?(option) &&
+               (string.include?("\r") || string.include?("\n"))
+              raise Errors::InvalidValue.new(option, value)
+            end
+            # libcurl writes CURLOPT_HAPROXY_CLIENT_IP into the
+            # space-separated PROXY protocol line, so whitespace could add
+            # fields or lines to the header.
+            if option == :haproxy_client_ip && string.match?(/[[:space:]]/)
+              raise Errors::InvalidValue.new(option, value)
+            end
+            value = string
+          end
+        when :binary_string
+          # The caller owns the buffer and passes its length separately. Ethon
+          # uses this for CURLOPT_POSTFIELDS, whose custom setter retains the
+          # buffer and sets CURLOPT_POSTFIELDSIZE.
+          va_type=:pointer
+          unless value.nil? || value.is_a?(::FFI::Pointer)
+            raise Errors::InvalidValue.new(option, value)
+          end
         when :string_as_pointer
           va_type = :pointer
-          s = ''
-          s = value.to_s unless value.nil?
-          value = FFI::MemoryPointer.new(:char, s.bytesize)
-          value.put_bytes(0, s)
+          unless value.nil?
+            s = value.to_s
+            # libcurl treats CURLOPT_*POSTFIELDS as a C string unless an
+            # explicit size is set, so reserve and write the terminator.
+            value = FFI::MemoryPointer.new(:char, s.bytesize + 1)
+            value.put_bytes(0, s)
+            value.put_char(s.bytesize, 0)
+          end
         when :string_escape_null
           va_type=:string
-          value=Util.escape_zero_byte(value) unless value.nil?
+          value=Ethon::Easy::Util.escape_zero_byte(value) unless value.nil?
         when :ffipointer
           va_type=:pointer
           raise Errors::InvalidValue.new(option,value) unless value.nil? or value.is_a? FFI::Pointer
@@ -74,9 +126,18 @@ module Ethon
           va_type=:pointer
           raise Errors::InvalidValue.new(option,value) unless value.nil? or value.is_a? FFI::Pointer
         when :buffer
-          raise NotImplementedError, "Ethon::Curls::Options option #{option} buffer type not implemented."
+          va_type=:pointer
+          raise Errors::InvalidValue.new(option,value) unless value.nil? or (value.is_a?(FFI::Pointer) and value.size >= opthash[option][:opts])
+        when :blob
+          va_type=:pointer
+          unless value.nil? || value.is_a?(FFI::Pointer) || value.is_a?(Ethon::Curl::Blob)
+            raise Errors::InvalidValue.new(option,value)
+          end
+          value = value.to_ptr if value.is_a?(Ethon::Curl::Blob)
         when :dontuse_object
           raise NotImplementedError, "Ethon::Curls::Options option #{option} type not implemented."
+        when :dontuse_callback
+          raise NotImplementedError, "Ethon::Curls::Options option #{option} callback type not implemented."
         when :cbdata
           raise NotImplementedError, "Ethon::Curls::Options option #{option} callback data type not implemented. Use Ruby closures."
         when :callback
@@ -94,25 +155,78 @@ module Ethon
         when :progress_callback
           va_type=:progress_callback
           raise Errors::InvalidValue.new(option,value) unless value.nil? or value.is_a? Proc
+        when :xferinfo_callback
+          va_type=:xferinfo_callback
+          raise Errors::InvalidValue.new(option,value) unless value.nil? or value.is_a? Proc
         when :off_t
           return if value.nil?
           va_type=:int64
-          value=value.to_i
+          value = Ethon::Curls::Options.integer_value(option, value)
+        end
+
+        if va_type == :long || va_type == :int64
+          limit = 1 << (FFI.type_size(va_type) * 8 - 1)
+          unless value >= -limit && value < limit
+            raise Errors::InvalidValue.new(option, value)
+          end
+        end
+        result = send(FUNCS[type], handle, opthash[option][:opt], va_type, value)
+
+        # Silently ignored options are a correctness bug: on an older libcurl
+        # the request would run with a different configuration than requested.
+        case result
+        when :ok
+          result
+        when :unknown_option
+          raise Errors::UnsupportedOption.new(option)
+        else
+          raise Errors::SetOption.new(option, result, type)
         end
+      end
+
+      def named_option_value(option, value, values, seen = [])
+        return value if value.is_a?(Integer)
 
-        if va_type==:long or va_type==:int64 then
-            bits=FFI.type_size(va_type)*8
-            tv=((value<0) ? value.abs-1 : value)
-            raise Errors::InvalidValue.new(option,value) unless tv<(1<<bits)
+        name = value.is_a?(String) ? value.to_sym : value
+        raise Errors::InvalidValue.new(option, value) unless name.is_a?(Symbol) && values.key?(name)
+        raise Errors::InvalidValue.new(option, value) if seen.include?(name)
+
+        resolved = values[name]
+        if resolved.is_a?(Array)
+          resolved.inject(0) do |mask, item|
+            mask | named_option_value(option, item, values, seen + [name])
+          end
+        elsif resolved.is_a?(Symbol) || resolved.is_a?(String)
+          named_option_value(option, resolved, values, seen + [name])
+        else
+          resolved
         end
-        send(FUNCS[type], handle, opthash[option][:opt], va_type, value)
+      end
+
+      def self.integer_value(option, value)
+        return value if value.is_a?(Integer)
+        return 1 if value == true
+        return 0 if value == false
+
+        begin
+          integer = Integer(value)
+        rescue ArgumentError, TypeError, RangeError
+          raise Errors::InvalidValue.new(option, value)
+        end
+
+        if value.is_a?(Numeric) && value != integer
+          raise Errors::InvalidValue.new(option, value)
+        end
+
+        integer
       end
 
       OPTION_TYPE_BASE = {
         :long => 0,
         :objectpoint => 10000,
         :functionpoint => 20000,
-        :off_t => 30000
+        :off_t => 30000,
+        :blob => 40000
       }
       OPTION_TYPE_MAP = {
         :none => :long,
@@ -135,19 +249,23 @@ module Ethon
                            #     (See :protocols)
                            # :all defaults to all bits set
         :string => :objectpoint,
+        :binary_string => :objectpoint,
         :string_escape_null => :objectpoint,
         :string_as_pointer => :objectpoint,
         :ffipointer => :objectpoint, # FFI::Pointer
         :curl_slist => :objectpoint,
         :buffer => :objectpoint, # A memory buffer of size defined in the options
-        :dontuse_object => :objectpoint, # An object we don't support (e.g. FILE*)
+        :dontuse_object => :objectpoint, # An object we don't support
         :cbdata => :objectpoint,
         :callback => :functionpoint,
+        :dontuse_callback => :functionpoint,
         :socket_callback => :functionpoint,
         :timer_callback => :functionpoint,
         :debug_callback => :functionpoint,
         :progress_callback => :functionpoint,
+        :xferinfo_callback => :functionpoint,
         :off_t => :off_t,
+        :blob => :blob,
       }
 
       def self.option(ftype,name,type,num,opts=nil)
@@ -202,6 +320,12 @@ module Ethon
         aliases.each { |a| opthash[a]=opthash[name] }
       end
 
+      # Add named enum or bitmask values to an already defined option.
+      def self.option_value_aliases(ftype,name,values)
+        opthash=const_get(FOPTION_STRINGS[ftype])
+        opthash.fetch(name)[:opts].merge!(values)
+      end
+
       def self.option_type(type)
         cname = FOPTION_STRINGS[type]
         const_set(cname, {})
@@ -212,15 +336,15 @@ module Ethon
       end
 
       # Curl multi options, refer
-      # Defined @ https://github.com/bagder/curl/blob/master/include/curl/multi.h
-      # Documentation @ http://curl.haxx.se/libcurl/c/curl_multi_setopt.html
+      # Defined @ https://github.com/curl/curl/blob/master/include/curl/multi.h
+      # Documentation @ https://curl.se/libcurl/c/curl_multi_setopt.html
       option_type :multi
 
       option :multi, :socketfunction, :socket_callback, 1
-      option :multi, :socketdata, :cbdata, 2
+      option :multi, :socketdata, :ffipointer, 2
       option :multi, :pipelining, :int, 3
       option :multi, :timerfunction, :timer_callback, 4
-      option :multi, :timerdata, :cbdata, 5
+      option :multi, :timerdata, :ffipointer, 5
       option :multi, :maxconnects, :int, 6
       option :multi, :max_host_connections, :int, 7
       option :multi, :max_pipeline_length, :int, 8
@@ -228,11 +352,12 @@ module Ethon
       option :multi, :chunk_length_penalty_size, :off_t, 10
       option :multi, :pipelining_site_bl, :dontuse_object, 11
       option :multi, :pipelining_server_bl, :dontuse_object, 12
-      option :multi, :max_total_connections, :int, 3
+      option :multi, :max_total_connections, :int, 13
+      option :multi, :max_concurrent_streams, :int, 16
 
       # Curl easy options
-      # Defined @ https://github.com/bagder/curl/blob/master/include/curl/curl.h
-      # Documentation @ http://curl.haxx.se/libcurl/c/curl_easy_setopt.html
+      # Defined @ https://github.com/curl/curl/blob/master/include/curl/curl.h
+      # Documentation @ https://curl.se/libcurl/c/curl_easy_setopt.html
       ## BEHAVIOR OPTIONS
       option_type :easy
 
@@ -248,15 +373,15 @@ module Ethon
       option :easy, :readfunction, :callback, 12
       option :easy, :infile, :cbdata, 9
       option_alias :easy, :infile, :readdata
-      option :easy, :ioctlfunction, :callback, 130
+      option :easy, :ioctlfunction, :dontuse_callback, 130
       option :easy, :ioctldata, :cbdata, 131
-      option :easy, :seekfunction, :callback, 167
+      option :easy, :seekfunction, :dontuse_callback, 167
       option :easy, :seekdata, :cbdata, 168
-      option :easy, :sockoptfunction, :callback, 148
+      option :easy, :sockoptfunction, :dontuse_callback, 148
       option :easy, :sockoptdata, :cbdata, 149
-      option :easy, :opensocketfunction, :callback, 163
+      option :easy, :opensocketfunction, :dontuse_callback, 163
       option :easy, :opensocketdata, :cbdata, 164
-      option :easy, :closesocketfunction, :callback, 208
+      option :easy, :closesocketfunction, :dontuse_callback, 208
       option :easy, :closesocketdata, :cbdata, 209
       option :easy, :path_as_is, :bool, 234
       option :easy, :progressfunction, :progress_callback, 56
@@ -266,19 +391,19 @@ module Ethon
       option_alias :easy, :writeheader, :headerdata
       option :easy, :debugfunction, :debug_callback, 94
       option :easy, :debugdata, :cbdata, 95
-      option :easy, :ssl_ctx_function, :callback, 108
+      option :easy, :ssl_ctx_function, :dontuse_callback, 108
       option :easy, :ssl_ctx_data, :cbdata, 109
-      option :easy, :conv_to_network_function, :callback, 143
-      option :easy, :conv_from_network_function, :callback, 142
-      option :easy, :conv_from_utf8_function, :callback, 144
+      option :easy, :conv_to_network_function, :dontuse_callback, 143
+      option :easy, :conv_from_network_function, :dontuse_callback, 142
+      option :easy, :conv_from_utf8_function, :dontuse_callback, 144
       option :easy, :interleavefunction, :callback, 196
       option :easy, :interleavedata, :cbdata, 195
-      option :easy, :chunk_bgn_function, :callback, 198
-      option :easy, :chunk_end_function, :callback, 199
+      option :easy, :chunk_bgn_function, :dontuse_callback, 198
+      option :easy, :chunk_end_function, :dontuse_callback, 199
       option :easy, :chunk_data, :cbdata, 201
-      option :easy, :fnmatch_function, :callback, 200
+      option :easy, :fnmatch_function, :dontuse_callback, 200
       option :easy, :fnmatch_data, :cbdata, 202
-      option :easy, :xferinfofunction, :progress_callback, 219
+      option :easy, :xferinfofunction, :xferinfo_callback, 219
       option :easy, :xferinfodata, :cbdata, 57
       ## ERROR OPTIONS
       option :easy, :errorbuffer, :buffer, 10, 256
@@ -286,11 +411,11 @@ module Ethon
       option :easy, :failonerror, :bool, 45
       ## NETWORK OPTIONS
       option :easy, :url, :string, 2
-      option :easy, :protocols, :bitmask, 181, [nil, :http, :https, :ftp, :ftps, :scp, :sftp, :telnet, :ldap, :ldaps, :dict, :file, :tftp, :imap, :imaps, :pop3, :pop3s, :smtp, :smtps, :rtsp, :rtmp, :rtmpt, :rtmpe, :rtmpte, :rtmps, :rtmpts, :gopher]
-      option :easy, :redir_protocols, :bitmask, 182, [nil, :http, :https, :ftp, :ftps, :scp, :sftp, :telnet, :ldap, :ldaps, :dict, :file, :tftp, :imap, :imaps, :pop3, :pop3s, :smtp, :smtps, :rtsp, :rtmp, :rtmpt, :rtmpe, :rtmpte, :rtmps, :rtmpts, :gopher]
+      option :easy, :protocols, :bitmask, 181, [nil, :http, :https, :ftp, :ftps, :scp, :sftp, :telnet, :ldap, :ldaps, :dict, :file, :tftp, :imap, :imaps, :pop3, :pop3s, :smtp, :smtps, :rtsp, :rtmp, :rtmpt, :rtmpe, :rtmpte, :rtmps, :rtmpts, :gopher, :smb, :smbs, :mqtt, :gophers]
+      option :easy, :redir_protocols, :bitmask, 182, [nil, :http, :https, :ftp, :ftps, :scp, :sftp, :telnet, :ldap, :ldaps, :dict, :file, :tftp, :imap, :imaps, :pop3, :pop3s, :smtp, :smtps, :rtsp, :rtmp, :rtmpt, :rtmpe, :rtmpte, :rtmps, :rtmpts, :gopher, :smb, :smbs, :mqtt, :gophers]
       option :easy, :proxy, :string, 4
       option :easy, :proxyport, :int, 59
-      option :easy, :proxytype, :enum, 101, [:http, :http_1_0, :https, nil, :socks4, :socks5, :socks4a, :socks5_hostname]
+      option :easy, :proxytype, :enum, 101, [:http, :http_1_0, :https, :https2, :socks4, :socks5, :socks4a, :socks5_hostname, :https3]
       option :easy, :noproxy, :string, 177
       option :easy, :httpproxytunnel, :bool, 61
       option :easy, :socks5_gssapi_service, :string, 179
@@ -307,7 +432,7 @@ module Ethon
       option :easy, :port, :int, 3
       option :easy, :tcp_nodelay, :bool, 121
       option :easy, :address_scope, :int, 171
-      option :easy, :tcp_fastopen, :bool, 212
+      option :easy, :tcp_fastopen, :bool, 244
       option :easy, :tcp_keepalive, :bool, 213
       option :easy, :tcp_keepidle, :int, 214
       option :easy, :tcp_keepintvl, :int, 215
@@ -320,11 +445,11 @@ module Ethon
       option :easy, :password, :string, 174
       option :easy, :proxyusername, :string, 175
       option :easy, :proxypassword, :string, 176
-      option :easy, :httpauth, :bitmask, 107, [:none, :basic, :digest, :gssnegotiate, :ntlm, :digest_ie, :ntlm_wb, {:only => 1<<31, :any => ~0x10, :anysafe => ~0x11, :auto => 0x1f}]
-      option :easy, :tlsauth_type, :enum, 206, [:none, :srp]
+      option :easy, :httpauth, :bitmask, 107, [:none, :basic, :digest, :gssnegotiate, :ntlm, :digest_ie, :ntlm_wb, {:only => 1<<31, :any => ~0x110, :anysafe => ~0x111, :auto => 0x1f}]
+      option :easy, :tlsauth_type, :string, 206
       option :easy, :tlsauth_username, :string, 204
       option :easy, :tlsauth_password, :string, 205
-      option :easy, :proxyauth, :bitmask, 111, [:none, :basic, :digest, :gssnegotiate, :ntlm, :digest_ie, :ntlm_wb, {:only => 1<<31, :any => ~0x10, :anysafe => ~0x11, :auto => 0x1f}]
+      option :easy, :proxyauth, :bitmask, 111, [:none, :basic, :digest, :gssnegotiate, :ntlm, :digest_ie, :ntlm_wb, {:only => 1<<31, :any => ~0x110, :anysafe => ~0x111, :auto => 0x1f}]
       option :easy, :sasl_ir, :bool, 218
       ## HTTP OPTIONS
       option :easy, :autoreferer, :bool, 58
@@ -338,7 +463,10 @@ module Ethon
       option_alias :easy, :postredir, :post301
       option :easy, :put, :bool, 54
       option :easy, :post, :bool, 47
-      option :easy, :postfields, :string, 15
+      # CURLOPT_POSTFIELDS is paired with CURLOPT_POSTFIELDSIZE, so the body
+      # may contain NUL bytes. The custom #postfields= setter always sets the
+      # length from the retained string.
+      option :easy, :postfields, :binary_string, 15
       option :easy, :postfieldsize, :int, 60
       option :easy, :postfieldsize_large, :off_t, 120
       option :easy, :copypostfields, :string_as_pointer, 165
@@ -353,7 +481,11 @@ module Ethon
       option :easy, :cookiesession, :bool, 96
       option :easy, :cookielist, :string, 135
       option :easy, :httpget, :bool, 80
-      option :easy, :http_version, :enum, 84, [:none, :httpv1_0, :httpv1_1, :httpv2_0, :httpv2_tls, :httpv2_prior_knowledge]
+      option :easy, :http_version, :enum, 84, {
+        :none => 0, :httpv1_0 => 1, :httpv1_1 => 2, :httpv2_0 => 3,
+        :httpv2_tls => 4, :httpv2_prior_knowledge => 5,
+        :httpv3 => 30, :httpv3only => 31
+      }
       option :easy, :ignore_content_length, :bool, 136
       option :easy, :http_content_decoding, :bool, 158
       option :easy, :http_transfer_decoding, :bool, 157
@@ -453,7 +585,7 @@ module Ethon
       option :easy, :egdsocket, :string, 77
       option :easy, :ssl_cipher_list, :string, 83
       option :easy, :ssl_sessionid_cache, :bool, 150
-      option :easy, :ssl_options, :bitmask, 216, [nil, :allow_beast]
+      option :easy, :ssl_options, :bitmask, 216, [nil, :allow_beast, :no_revoke, :no_partialchain, :revoke_best_effort, :native_ca, :auto_client_cert, :earlydata]
       option :easy, :krblevel, :string, 63
       option_alias :easy, :krblevel, :krb4level
       option :easy, :gssapi_delegation, :bitmask, 210, [:none, :policy_flag, :flag]
@@ -467,7 +599,7 @@ module Ethon
       option :easy, :proxy_sslversion, :enum, 250, [:default, :tlsv1, :sslv2, :sslv3, :tlsv1_0, :tlsv1_1, :tlsv1_2, :tlsv1_3]
       option :easy, :proxy_tlsauth_username, :string, 251
       option :easy, :proxy_tlsauth_password, :string, 252
-      option :easy, :proxy_tlsauth_type, :enum, 253, [:none, :srp]
+      option :easy, :proxy_tlsauth_type, :string, 253
       option :easy, :proxy_sslcert, :string, 254
       option :easy, :proxy_sslcerttype, :string, 255
       option :easy, :proxy_sslkey, :string, 256
@@ -477,27 +609,122 @@ module Ethon
       option_alias :easy, :proxy_keypasswd, :proxy_sslkeypasswd
       option :easy, :proxy_ssl_cipher_list, :string, 259
       option :easy, :proxy_crlfile, :string, 260
-      option :easy, :proxy_ssl_options, :bitmask, 261, [nil, :allow_beast]
+      option :easy, :proxy_ssl_options, :bitmask, 261, [nil, :allow_beast, :no_revoke, :no_partialchain, :revoke_best_effort, :native_ca, :auto_client_cert, :earlydata]
       option :easy, :pre_proxy, :string, 262
       option :easy, :proxy_pinnedpublickey, :string, 263
       option_alias :easy, :proxy_pinnedpublickey, :proxy_pinned_public_key
       option :easy, :proxy_issuercert, :string, 296
       ## SSH OPTIONS
-      option :easy, :ssh_auth_types, :bitmask, 151, [:none, :publickey, :password, :host, :keyboard, :agent, {:any => [:all], :default => [:any]}]
+      option :easy, :ssh_auth_types, :bitmask, 151, [:none, :publickey, :password, :host, :keyboard, :agent, :gssapi, {:any => [:all], :default => [:any]}]
       option :easy, :ssh_host_public_key_md5, :string, 162
       option :easy, :ssh_public_keyfile, :string, 152
       option :easy, :ssh_private_keyfile, :string, 153
       option :easy, :ssh_knownhosts, :string, 183
-      option :easy, :ssh_keyfunction, :callback, 184
-      option :easy, :khstat, :enum, -1, [:fine_add_to_file, :fine, :reject, :defer] # Kludge to make this enum available... Access via CurL::EASY_OPTIONS[:khstat][:opt]
+      option :easy, :ssh_keyfunction, :dontuse_callback, 184
       option :easy, :ssh_keydata, :cbdata, 185
       ## OTHER OPTIONS
       option :easy, :private, :cbdata, 103
-      option :easy, :share, :dontuse_object, 100
+      option :easy, :share, :ffipointer, 100
       option :easy, :new_file_perms, :int, 159
       option :easy, :new_directory_perms, :int, 160
+      ## NEWER OPTIONS
+      option :easy, :curlu, :ffipointer, 282
+      option :easy, :abstract_unix_socket, :string, 264
+      option :easy, :altsvc, :string, 287
+      option :easy, :altsvc_ctrl, :bitmask, 286, [nil, nil, nil, :readonlyfile, :h1, :h2, :h3]
+      option :easy, :aws_sigv4, :string, 305
+      option :easy, :ca_cache_timeout, :int, 321
+      option :easy, :cainfo_blob, :blob, 309
+      option :easy, :connect_to, :curl_slist, 243
+      option :easy, :default_protocol, :string, 238
+      option :easy, :disallow_username_in_url, :bool, 278
+      option :easy, :dns_local_ip6, :string, 223
+      option :easy, :doh_ssl_verifyhost, :int, 307
+      option :easy, :doh_ssl_verifypeer, :bool, 306
+      option :easy, :doh_ssl_verifystatus, :bool, 308
+      option :easy, :doh_url, :string, 279
+      option :easy, :ech, :string, 325
+      option :easy, :expect_100_timeout_ms, :int, 227
+      option :easy, :happy_eyeballs_timeout_ms, :int, 271
+      option :easy, :haproxy_client_ip, :string, 323
+      option :easy, :haproxyprotocol, :bool, 274
+      option :easy, :headeropt, :enum, 229, [:unified, :separate]
+      option :easy, :hsts, :string, 300
+      option :easy, :hsts_ctrl, :bitmask, 299, [nil, :enable, :readonlyfile]
+      option :easy, :hstsreaddata, :ffipointer, 302
+      option :easy, :hstsreadfunction, :dontuse_callback, 301
+      option :easy, :hstswritedata, :ffipointer, 304
+      option :easy, :hstswritefunction, :dontuse_callback, 303
+      option :easy, :http09_allowed, :bool, 285
+      option :easy, :httpsig_algorithm, :enum, 329, [:none, :ed25519, :hmac_sha256]
+      option :easy, :httpsig_headers, :string, 332
+      option :easy, :httpsig_key, :string, 330
+      option :easy, :httpsig_keyid, :string, 331
+      option :easy, :issuercert_blob, :blob, 295
+      option :easy, :keep_sending_on_error, :bool, 245
+      option :easy, :login_options, :string, 224
+      option :easy, :mail_rcpt_allowfails, :bool, 290
+      option :easy, :maxage_conn, :int, 288
+      option :easy, :maxlifetime_conn, :int, 314
+      option :easy, :mime_options, :bitmask, 315, [nil, :formescape]
+      option :easy, :mimepost, :ffipointer, 269
+      option :easy, :prereqdata, :ffipointer, 313
+      option :easy, :prereqfunction, :dontuse_callback, 312
+      option :easy, :protocols_str, :string, 318
+      option :easy, :proxy_cainfo_blob, :blob, 310
+      option :easy, :proxy_issuercert_blob, :blob, 297
+      option :easy, :proxy_service_name, :string, 235
+      option :easy, :proxy_sslcert_blob, :blob, 293
+      option :easy, :proxy_sslkey_blob, :blob, 294
+      option :easy, :proxy_tls13_ciphers, :string, 277
+      option :easy, :proxyheader, :curl_slist, 228
+      option :easy, :quick_exit, :bool, 322
+      option :easy, :redir_protocols_str, :string, 319
+      option :easy, :request_target, :string, 266
+      option :easy, :resolver_start_data, :ffipointer, 273
+      option :easy, :resolver_start_function, :dontuse_callback, 272
+      option :easy, :sasl_authzid, :string, 289
+      option :easy, :server_response_timeout_ms, :int, 324
+      option :easy, :service_name, :string, 236
+      option :easy, :socks5_auth, :bitmask, 267, {:none => 0, :basic => 1, :gssapi => 1<<2}
+      option :easy, :ssh_compression, :bool, 268
+      option :easy, :ssh_host_public_key_sha256, :string, 311
+      option :easy, :ssh_hostkeydata, :ffipointer, 317
+      option :easy, :ssh_hostkeyfunction, :dontuse_callback, 316
+      option :easy, :ssl_ec_curves, :string, 298
+      option :easy, :ssl_enable_alpn, :bool, 226
+      option :easy, :ssl_enable_npn, :bool, 225
+      option :easy, :ssl_falsestart, :bool, 233
+      option :easy, :ssl_signature_algorithms, :string, 328
+      option :easy, :ssl_verifystatus, :bool, 232
+      option :easy, :sslcert_blob, :blob, 291
+      option :easy, :sslkey_blob, :blob, 292
+      option :easy, :stream_depends, :ffipointer, 240
+      option :easy, :stream_depends_e, :ffipointer, 241
+      option :easy, :stream_weight, :int, 239
+      option :easy, :suppress_connect_headers, :bool, 265
+      option :easy, :tcp_keepcnt, :int, 326
+      option :easy, :tftp_no_options, :bool, 242
+      option :easy, :timevalue_large, :off_t, 270
+      option :easy, :tls13_ciphers, :string, 276
+      option :easy, :trailerdata, :ffipointer, 284
+      option :easy, :trailerfunction, :dontuse_callback, 283
+      option :easy, :upkeep_interval_ms, :int, 281
+      option :easy, :upload_buffersize, :int, 280
+      option :easy, :upload_flags, :bitmask, 327, [nil, :answered, :deleted, :draft, :flagged, :seen]
+      option :easy, :ws_options, :bitmask, 320, [nil, :raw_mode]
+      option :easy, :xoauth2_bearer, :string, 220
+
       ## TELNET OPTIONS
       option :easy, :telnetoptions, :curl_slist, 70
+
+      ## NAMED VALUE ADDITIONS
+      option_value_aliases :easy, :httpauth,
+        :negotiate => :gssnegotiate, :bearer => 1<<6, :aws_sigv4 => 1<<7,
+        :httpsig => 1<<8
+      option_value_aliases :easy, :proxyauth,
+        :negotiate => :gssnegotiate, :bearer => 1<<6, :aws_sigv4 => 1<<7,
+        :httpsig => 1<<8
     end
   end
 end

data/lib/ethon/curls/settings.rb

@@ -1,12 +1,21 @@
 # frozen_string_literal: true
 module Ethon
   module Curl
+    if Curl.windows?
+      typedef :size_t, :curl_socket_t
+    else
+      typedef :int, :curl_socket_t
+    end
+
     callback :callback, [:pointer, :size_t, :size_t, :pointer], :size_t
-    callback :socket_callback, [:pointer, :int, :poll_action, :pointer, :pointer], :multi_code
+    callback :socket_callback, [:pointer, :curl_socket_t, :poll_action, :pointer, :pointer], :multi_code
     callback :timer_callback, [:pointer, :long, :pointer], :multi_code
     callback :debug_callback, [:pointer, :debug_info_type, :pointer, :size_t, :pointer], :int
-    callback :progress_callback, [:pointer, :long_long, :long_long, :long_long, :long_long], :int
+    # CURLOPT_PROGRESSFUNCTION uses doubles, while CURLOPT_XFERINFOFUNCTION uses
+    # curl_off_t. They are not ABI-compatible on all platforms.
+    callback :progress_callback, [:pointer, :double, :double, :double, :double], :int
+    callback :xferinfo_callback, [:pointer, :long_long, :long_long, :long_long, :long_long], :int
     ffi_lib_flags :now, :global
-    ffi_lib ['libcurl', 'libcurl.so.4']
+    ffi_lib ENV.fetch('ETHON_CURL_LIBS', 'libcurl,libcurl.so.4,libcurl-4,libcurl-x64,libcurl-arm64').split(',')
   end
 end