ethon 0.18.0 → 0.19.0

data/lib/ethon/easy/headers_api.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    # Structured access to response headers via curl_easy_header.
+    module HeadersApi
+      # libcurl's request number for the last request in a transfer. Redirects
+      # and multi-state authentication can produce several requests, and the
+      # response the caller sees comes from the last one.
+      LAST_REQUEST = -1
+
+      # Return a parsed response header.
+      #
+      # @param [ String ] name The header name.
+      # @param [ Integer ] index The instance index for repeated headers.
+      # @param [ Integer, Symbol, Array ] origin CURLH_* origin bits.
+      # @param [ Integer ] request The request number, -1 for the last request.
+      #
+      # @return [ Ethon::Curl::Header ] The header.
+      def header(name, index = 0, origin = Curl::HeaderOrigin[:header], request = LAST_REQUEST)
+        unless Curl.respond_to?(:easy_header)
+          raise NotImplementedError, "curl_easy_header is not supported by this libcurl"
+        end
+
+        output = ::FFI::MemoryPointer.new(:pointer)
+        code = Curl.easy_header(handle, name.to_s, index, header_origin(origin), request, output)
+        raise Errors::Header.new(code) unless code == :ok
+
+        Curl::Header.new(Curl::HeaderData.new(output.read_pointer))
+      end
+
+      # Enumerate response headers.
+      #
+      # @param [ Integer, Symbol, Array ] origin CURLH_* origin bits.
+      # @param [ Integer ] request The request number, -1 for the last request.
+      #
+      # @return [ Enumerator, self ] The headers.
+      def each_header(origin = Curl::HeaderOrigin[:header], request = LAST_REQUEST)
+        unless Curl.respond_to?(:easy_nextheader)
+          raise NotImplementedError, "curl_easy_nextheader is not supported by this libcurl"
+        end
+
+        origin = header_origin(origin)
+        return enum_for(:each_header, origin, request) unless block_given?
+
+        previous = nil
+        loop do
+          header = Curl.easy_nextheader(handle, origin, request, previous)
+          break if header.null?
+
+          yield Curl::Header.new(header)
+          previous = header
+        end
+        self
+      end
+      alias headers_list each_header
+
+      private
+
+      def header_origin(origin)
+        case origin
+        when Array
+          origin.inject(0) do |mask, item|
+            value = Curl::HeaderOrigin[item]
+            raise Errors::InvalidValue.new(:header_origin, item) unless value && value != 0
+            mask | value
+          end
+        when Symbol
+          value = Curl::HeaderOrigin[origin]
+          raise Errors::InvalidValue.new(:header_origin, origin) unless value && value != 0
+          value
+        else
+          origin
+        end
+      end
+    end
+
+    include HeadersApi
+  end
+end

data/lib/ethon/easy/http/actionable.rb

@@ -93,6 +93,18 @@ module Ethon
         # @param [ easy ] easy the easy to setup.
         def setup(easy)
           @easy = easy
+          easy.customrequest = nil
+          # A reused handle keeps the previous transfer's method and body
+          # options. Clear them before applying this request so a stale
+          # upload body cannot win over the body configured below.
+          # CURLOPT_POSTFIELDS selects POST even when cleared, so clear it
+          # before the method flags to leave the handle on GET.
+          easy.postfields = nil
+          easy.readfunction = nil
+          Curl.set_option(:upload, false, easy.handle)
+          Curl.set_option(:httpget, false, easy.handle)
+          Curl.set_option(:nobody, false, easy.handle)
+          Curl.set_option(:post, false, easy.handle)
 
           # Order is important, @easy will be used to provide access to options
           # relevant to the following operations (like whether or not to escape
@@ -100,6 +112,12 @@ module Ethon
           easy.set_attributes(options)
 
           set_form(easy) unless form.empty?
+          if form.empty?
+            easy.multipart_form = nil
+            # Clear any MIME body left over from an earlier request (or copied
+            # by Easy#dup) so this request does not inherit it.
+            easy.mime = nil if Ethon::Curl.respond_to?(:mime_init)
+          end
 
           if params.empty?
             easy.url = url
@@ -118,11 +136,15 @@ module Ethon
           params.escape = easy.escape?
           params.params_encoding = params_encoding
 
-          base_url, base_params = url.split('?')
+          url_without_fragment, fragment_separator, fragment = url.partition('#')
+          fragment = fragment_separator.empty? ? nil : "#{fragment_separator}#{fragment}"
+          base_url, query_separator, base_params = url_without_fragment.partition('?')
+
           base_url << '?'
-          base_url << base_params.to_s
-          base_url << '&' if base_params
+          base_url << base_params
+          base_url << '&' if query_separator == '?' && !base_params.empty?
           base_url << params.to_s
+          base_url << fragment.to_s
 
           easy.url = base_url
         end

data/lib/ethon/easy/http/get.rb

@@ -16,7 +16,11 @@ module Ethon
         # @param [ Easy ] easy The easy to setup.
         def setup(easy)
           super
-          easy.customrequest = "GET" unless form.empty?
+          if form.empty?
+            easy.httpget = true
+          else
+            easy.customrequest = "GET"
+          end
         end
       end
     end

data/lib/ethon/easy/http/post.rb

@@ -16,6 +16,7 @@ module Ethon
         def setup(easy)
           super
           if form.empty?
+            easy.multipart_form = nil
             easy.postfieldsize = 0
             easy.copypostfields = ""
           end

data/lib/ethon/easy/http/postable.rb

@@ -18,9 +18,16 @@ module Ethon
           form.params_encoding = params_encoding
           if form.multipart?
             form.escape = false
-            form.materialize
-            easy.httppost = form.first.read_pointer
+            if Ethon::Curl.respond_to?(:mime_init)
+              easy.multipart_form = nil
+              easy.mime = form.mime
+            else
+              form.materialize
+              easy.multipart_form = form
+            end
           else
+            easy.multipart_form = nil
+            easy.mime = nil if Ethon::Curl.respond_to?(:mime_init)
             form.escape = easy.escape?
             easy.postfieldsize = form.to_s.bytesize
             easy.copypostfields = form.to_s

data/lib/ethon/easy/http/putable.rb

@@ -13,11 +13,26 @@ module Ethon
         #
         # @param [ Easy ] easy The easy to setup.
         def set_form(easy)
-          easy.upload = true
-          form.escape = true
+          easy.url ||= url
           form.params_encoding = params_encoding
-          easy.infilesize = form.to_s.bytesize
-          easy.set_read_callback(form.to_s)
+          if form.multipart?
+            form.escape = false
+            if Ethon::Curl.respond_to?(:mime_init)
+              easy.multipart_form = nil
+              easy.mime = form.mime
+            else
+              form.materialize
+              easy.multipart_form = form
+            end
+            easy.customrequest = "PUT"
+          else
+            easy.multipart_form = nil
+            easy.mime = nil if Ethon::Curl.respond_to?(:mime_init)
+            easy.upload = true
+            form.escape = easy.escape?
+            easy.infilesize = form.to_s.bytesize
+            easy.set_read_callback(form.to_s)
+          end
         end
       end
     end

data/lib/ethon/easy/http.rb

@@ -15,6 +15,18 @@ module Ethon
     # This module contains logic about making valid HTTP requests.
     module Http
 
+      # Built-in request actions. Custom verbs must not resolve to helper
+      # modules or classes that happen to live in this namespace.
+      ACTION_CLASSES = {
+        "get" => Get,
+        "head" => Head,
+        "post" => Post,
+        "put" => Put,
+        "delete" => Delete,
+        "patch" => Patch,
+        "options" => Options
+      }.freeze
+
       # Set specified options in order to make a HTTP request.
       # Look at {Ethon::Easy::Options Options} to see what you can
       # provide in the options hash.
@@ -54,12 +66,12 @@ module Ethon
       #
       # @return [ Easy::Ethon::Actionable ] The request instance.
       def fabricate(url, action_name, options)
-        constant_name = action_name.to_s.capitalize
+        action_class = ACTION_CLASSES[action_name.to_s.downcase]
 
-        if Ethon::Easy::Http.const_defined?(constant_name)
-          Ethon::Easy::Http.const_get(constant_name).new(url, options)
+        if action_class
+          action_class.new(url, options)
         else
-          Ethon::Easy::Http::Custom.new(constant_name.upcase, url, options)
+          Ethon::Easy::Http::Custom.new(action_name.to_s.upcase, url, options)
         end
       end
 

data/lib/ethon/easy/informations.rb

@@ -3,13 +3,52 @@ module Ethon
   class Easy
 
     # This module contains the methods to return informations
-    # from the easy handle. See http://curl.haxx.se/libcurl/c/curl_easy_getinfo.html
+    # from the easy handle. See https://curl.se/libcurl/c/curl_easy_getinfo.html
     # for more information.
     module Informations
 
       # Holds available informations and their type, which is needed to
       # request the informations from libcurl.
       AVAILABLE_INFORMATIONS = {
+        # The _T variants use curl_off_t and do not lose precision for large
+        # values or long-running transfers.
+        :size_upload_t => :off_t,
+        :size_download_t => :off_t,
+        :speed_download_t => :off_t,
+        :speed_upload_t => :off_t,
+        :filetime_t => :off_t,
+        :content_length_download_t => :off_t,
+        :content_length_upload_t => :off_t,
+        :total_time_t => :off_t,
+        :namelookup_time_t => :off_t,
+        :connect_time_t => :off_t,
+        :pretransfer_time_t => :off_t,
+        :starttransfer_time_t => :off_t,
+        :redirect_time_t => :off_t,
+        :appconnect_time_t => :off_t,
+        :retry_after => :off_t,
+        :xfer_id => :off_t,
+        :conn_id => :off_t,
+        :queue_time_t => :off_t,
+        :posttransfer_time_t => :off_t,
+        :earlydata_sent_t => :off_t,
+        :size_delivered => :off_t,
+
+        # Connection/request metadata.
+        :http_version => :long,
+        :httpauth_used => :long,
+        :proxyauth_used => :long,
+        :proxy_ssl_verifyresult => :long,
+        :proxy_error => :long,
+        :used_proxy => :long,
+        :scheme => :string,
+        :effective_method => :string,
+        :referer => :string,
+        :cainfo => :string,
+        :capath => :string,
+        :activesocket => :socket,
+        :tls_ssl_ptr => :ptr,
+
         # Return the available HTTP auth methods.
         :httpauth_avail => :long,
 
@@ -95,10 +134,20 @@ module Ethon
         :speed_download => :double
       }
 
+      LIST_INFORMATIONS = [:ssl_engines, :cookielist].freeze
+
       AVAILABLE_INFORMATIONS.each do |name, type|
         eval %Q|def #{name}; Curl.send(:get_info_#{type}, :#{name}, handle); end|
       end
 
+      LIST_INFORMATIONS.each do |name|
+        define_method(name) { Curl.get_info_slist(name, handle) }
+      end
+
+      def certinfo
+        Curl.get_info_certinfo(:certinfo, handle)
+      end
+
       # Returns true if this curl version supports zlib.
       #
       # @example Return wether zlib is supported.
@@ -107,7 +156,7 @@ module Ethon
       # @return [ Boolean ] True if supported, else false.
       # @deprecated Please use the static version instead
       def supports_zlib?
-        Kernel.warn("Ethon: Easy#supports_zlib? is deprecated and will be removed, please use Easy#.")
+        Kernel.warn("Ethon: Easy#supports_zlib? is deprecated and will be removed, please use Easy.supports_zlib? instead.")
         Easy.supports_zlib?
       end
 

data/lib/ethon/easy/mime.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Ethon
+  class Easy
+    module Mime
+      attr_reader :mime
+
+      # Install a MIME structure as the request body.
+      #
+      # @param [ Ethon::Curl::Mime, nil ] mime The MIME structure.
+      #
+      # @raise [ TypeError ] If mime is not a MIME structure.
+      #
+      # @return [ Ethon::Curl::Mime, nil ] The MIME structure.
+      def mime=(mime)
+        unless mime.nil? || mime.is_a?(Curl::Mime)
+          raise TypeError, "expected an Ethon::Curl::Mime, got #{mime.class}"
+        end
+
+        mime.check_pid! if mime
+        Curl.set_option(:mimepost, mime, handle)
+        @mime = mime
+        mime
+      end
+      alias mimepost= mime=
+    end
+
+    include Mime
+  end
+end

data/lib/ethon/easy/mirror.rb

@@ -5,11 +5,20 @@ module Ethon
       attr_reader :options
       alias_method :to_hash, :options
 
-      INFORMATIONS_TO_MIRROR = Informations::AVAILABLE_INFORMATIONS.keys +
-          [:return_code, :response_headers, :response_body, :debug_info]
+      # Raw pointers cannot be marshaled and point into native state that can
+      # go away when the handle is reset. Applications serialize a mirror (for
+      # example as a cached Typhoeus response), so leave them on the Easy.
+      INFORMATIONS_TO_MIRROR = Informations::AVAILABLE_INFORMATIONS.
+          reject { |_, type| type == :ptr }.keys +
+          [:return_code, :response_headers, :response_body, :debug_info, :error_message]
 
       INFORMATIONS_TO_LOG = [:effective_url, :response_code, :return_code, :total_time]
 
+      # Credentials embedded in the URL are not useful in logs and may end up
+      # in a log aggregator. Keep the scheme and host so the line is still
+      # identifiable, but replace the userinfo.
+      URL_CREDENTIALS = %r{\A([a-z][a-z0-9+.-]*://)[^/?#@]*@}i
+
       def self.from_easy(easy)
         options = {}
         INFORMATIONS_TO_MIRROR.each do |info|
@@ -24,12 +33,16 @@ module Ethon
 
       def log_informations
         Hash[*INFORMATIONS_TO_LOG.map do |info|
-          [info, options[info]]
+          value = options[info]
+          if info == :effective_url && value.is_a?(String)
+            value = value.sub(URL_CREDENTIALS, "\\1[REDACTED]@")
+          end
+          [info, value]
         end.flatten]
       end
 
       INFORMATIONS_TO_MIRROR.each do |info|
-        eval %Q|def #{info}; options[#{info}]; end|
+        define_method(info) { options[info] }
       end
     end
   end