httpx 0.3.1 → 0.4.0

data/lib/httpx/plugins/proxy/http.rb

@@ -6,53 +6,56 @@ module HTTPX
   module Plugins
     module Proxy
       module HTTP
-        class HTTPProxyChannel < ProxyChannel
+        module ConnectionMethods
           private
 
-          def proxy_connect
-            req, _ = @pending.first
-            # if the first request after CONNECT is to an https address, it is assumed that
-            # all requests in the queue are not only ALL HTTPS, but they also share the certificate,
-            # and therefore, will share the connection.
-            #
-            if req.uri.scheme == "https"
-              connect_request = ConnectRequest.new(req.uri)
-              if @parameters.authenticated?
-                connect_request.headers["proxy-authentication"] = "Basic #{@parameters.token_authentication}"
-              end
-              parser.send(connect_request)
-            else
-              transition(:connected)
-            end
-          end
-
           def transition(nextstate)
+            return super unless @options.proxy && @options.proxy.uri.scheme == "http"
+
             case nextstate
             when :connecting
               return unless @state == :idle
+
               @io.connect
               return unless @io.connected?
+
               @parser = ConnectProxyParser.new(@write_buffer, @options.merge(max_concurrent_requests: 1))
-              @parser.once(:response, &method(:on_connect))
+              @parser.once(:response, &method(:__http_on_connect))
               @parser.on(:close) { transition(:closing) }
-              proxy_connect
+              __http_proxy_connect
               return if @state == :connected
             when :connected
               return unless @state == :idle || @state == :connecting
+
               case @state
               when :connecting
                 @parser.close
                 @parser = nil
               when :idle
                 @parser = ProxyParser.new(@write_buffer, @options)
-                @parser.inherit_callbacks(self)
+                set_parser_callbacks(@parser)
                 @parser.on(:close) { transition(:closing) }
               end
             end
             super
           end
 
-          def on_connect(_request, response)
+          def __http_proxy_connect
+            req, _ = @pending.first
+            # if the first request after CONNECT is to an https address, it is assumed that
+            # all requests in the queue are not only ALL HTTPS, but they also share the certificate,
+            # and therefore, will share the connection.
+            #
+            if req.uri.scheme == "https"
+              connect_request = ConnectRequest.new(req.uri, @options)
+
+              parser.send(connect_request)
+            else
+              transition(:connected)
+            end
+          end
+
+          def __http_on_connect(_request, response)
             if response.status == 200
               req, _ = @pending.first
               request_uri = req.uri
@@ -68,7 +71,7 @@ module HTTPX
           end
         end
 
-        class ProxyParser < Channel::HTTP1
+        class ProxyParser < Connection::HTTP1
           def headline_uri(request)
             request.uri.to_s
           end
@@ -85,6 +88,7 @@ module HTTPX
 
           def headline_uri(request)
             return super unless request.verb == :connect
+
             uri = request.uri
             tunnel = "#{uri.hostname}:#{uri.port}"
             log { "establishing HTTP proxy tunnel to #{tunnel}" }
@@ -98,8 +102,10 @@ module HTTPX
         end
 
         class ConnectRequest < Request
-          def initialize(uri, options = {})
-            super(:connect, uri, options)
+          def initialize(uri, options)
+            super(:connect, uri, {})
+            proxy_params = options.proxy
+            @headers["proxy-authentication"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?
             @headers.delete("accept")
           end
 
@@ -107,8 +113,6 @@ module HTTPX
             "#{@uri.hostname}:#{@uri.port}"
           end
         end
-
-        Parameters.register("http", HTTPProxyChannel)
       end
     end
     register_plugin :"proxy/http", Proxy::HTTP

data/lib/httpx/plugins/proxy/socks4.rb

@@ -10,58 +10,63 @@ module HTTPX
         VERSION = 4
         CONNECT = 1
         GRANTED = 90
+        PROTOCOLS = %w[socks4 socks4a].freeze
 
         Error = Class.new(Error)
 
-        class Socks4ProxyChannel < ProxyChannel
+        module ConnectionMethods
           private
 
-          def proxy_connect
-            @parser = SocksParser.new(@write_buffer, @options)
-            @parser.once(:packet, &method(:on_packet))
-          end
-
-          def on_packet(packet)
-            _version, status, _port, _ip = packet.unpack("CCnN")
-            if status == GRANTED
-              req, _ = @pending.first
-              request_uri = req.uri
-              @io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
-              transition(:connected)
-              throw(:called)
-            else
-              on_socks_error("socks error: #{status}")
-            end
-          end
-
           def transition(nextstate)
+            return super unless @options.proxy && PROTOCOLS.include?(@options.proxy.uri.scheme)
+
             case nextstate
             when :connecting
               return unless @state == :idle
+
               @io.connect
               return unless @io.connected?
+
               req, _ = @pending.first
               return unless req
+
               request_uri = req.uri
-              @write_buffer << Packet.connect(@parameters, request_uri)
-              proxy_connect
+              @write_buffer << Packet.connect(@options.proxy, request_uri)
+              __socks4_proxy_connect
             when :connected
               return unless @state == :connecting
+
               @parser = nil
             end
             log(level: 1, label: "SOCKS4: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
             super
           end
 
-          def on_socks_error(message)
+          def __socks4_proxy_connect
+            @parser = SocksParser.new(@write_buffer, @options)
+            @parser.once(:packet, &method(:__socks4_on_packet))
+          end
+
+          def __socks4_on_packet(packet)
+            _version, status, _port, _ip = packet.unpack("CCnN")
+            if status == GRANTED
+              req, _ = @pending.first
+              request_uri = req.uri
+              @io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
+              transition(:connected)
+              throw(:called)
+            else
+              on_socks4_error("socks error: #{status}")
+            end
+          end
+
+          def on_socks4_error(message)
             ex = Error.new(message)
             ex.set_backtrace(caller)
             on_error(ex)
             throw(:called)
           end
         end
-        Parameters.register("socks4", Socks4ProxyChannel)
-        Parameters.register("socks4a", Socks4ProxyChannel)
 
         class SocksParser
           include Callbacks
@@ -92,6 +97,7 @@ module HTTPX
             begin
               ip = IPAddr.new(uri.host)
               raise Error, "Socks4 connection to #{ip} not supported" unless ip.ipv4?
+
               packet << [ip.to_i].pack("N")
             rescue IPAddr::InvalidAddressError
               if parameters.uri.scheme == "socks4"

data/lib/httpx/plugins/proxy/socks5.rb

@@ -16,9 +16,12 @@ module HTTPX
 
         Error = Class.new(Error)
 
-        class Socks5ProxyChannel < ProxyChannel
+        module ConnectionMethods
           def call
             super
+
+            return unless @options.proxy && @options.proxy.uri.scheme == "socks5"
+
             case @state
             when :connecting,
                  :negotiating,
@@ -29,35 +32,67 @@ module HTTPX
 
           private
 
-          def proxy_connect
+          def transition(nextstate)
+            return super unless @options.proxy && @options.proxy.uri.scheme == "socks5"
+
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+
+              @io.connect
+              return unless @io.connected?
+
+              @write_buffer << Packet.negotiate(@options.proxy)
+              __socks5_proxy_connect
+            when :authenticating
+              return unless @state == :connecting
+
+              @write_buffer << Packet.authenticate(@options.proxy)
+            when :negotiating
+              return unless @state == :connecting || @state == :authenticating
+
+              req, _ = @pending.first
+              request_uri = req.uri
+              @write_buffer << Packet.connect(request_uri)
+            when :connected
+              return unless @state == :negotiating
+
+              @parser = nil
+            end
+            log(level: 1, label: "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
+            super
+          end
+
+          def __socks5_proxy_connect
             @parser = SocksParser.new(@write_buffer, @options)
-            @parser.on(:packet, &method(:on_packet))
+            @parser.on(:packet, &method(:__socks5_on_packet))
             transition(:negotiating)
           end
 
-          def on_packet(packet)
+          def __socks5_on_packet(packet)
             case @state
             when :connecting
               version, method = packet.unpack("CC")
-              check_version(version)
+              __socks5_check_version(version)
               case method
               when PASSWD
                 transition(:authenticating)
                 return
               when NONE
-                on_socks_error("no supported authorization methods")
+                __on_socks5_error("no supported authorization methods")
               else
                 transition(:negotiating)
               end
             when :authenticating
               version, status = packet.unpack("CC")
-              check_version(version)
+              __socks5_check_version(version)
               return transition(:negotiating) if status == SUCCESS
-              on_socks_error("socks authentication error: #{status}")
+
+              __on_socks5_error("socks authentication error: #{status}")
             when :negotiating
               version, reply, = packet.unpack("CC")
-              check_version(version)
-              on_socks_error("socks5 negotiation error: #{reply}") unless reply == SUCCESS
+              __socks5_check_version(version)
+              __on_socks5_error("socks5 negotiation error: #{reply}") unless reply == SUCCESS
               req, _ = @pending.first
               request_uri = req.uri
               @io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
@@ -66,35 +101,11 @@ module HTTPX
             end
           end
 
-          def transition(nextstate)
-            case nextstate
-            when :connecting
-              return unless @state == :idle
-              @io.connect
-              return unless @io.connected?
-              @write_buffer << Packet.negotiate(@parameters)
-              proxy_connect
-            when :authenticating
-              return unless @state == :connecting
-              @write_buffer << Packet.authenticate(@parameters)
-            when :negotiating
-              return unless @state == :connecting || @state == :authenticating
-              req, _ = @pending.first
-              request_uri = req.uri
-              @write_buffer << Packet.connect(request_uri)
-            when :connected
-              return unless @state == :negotiating
-              @parser = nil
-            end
-            log(level: 1, label: "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
-            super
-          end
-
-          def check_version(version)
-            on_socks_error("invalid SOCKS version (#{version})") if version != 5
+          def __socks5_check_version(version)
+            __on_socks5_error("invalid SOCKS version (#{version})") if version != 5
           end
 
-          def on_socks_error(message)
+          def __on_socks5_error(message)
             ex = Error.new(message)
             ex.set_backtrace(caller)
             on_error(ex)
@@ -102,8 +113,6 @@ module HTTPX
           end
         end
 
-        Parameters.register("socks5", Socks5ProxyChannel)
-
         class SocksParser
           include Callbacks
 
@@ -147,6 +156,7 @@ module HTTPX
             begin
               ip = IPAddr.new(uri.host)
               raise Error, "Socks4 connection to #{ip} not supported" unless ip.ipv4?
+
               packet << [IPV4, ip.to_i].pack("CN")
             rescue IPAddr::InvalidAddressError
               packet << [DOMAIN, uri.host.bytesize, uri.host].pack("CCA*")

data/lib/httpx/plugins/proxy/ssh.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "httpx/plugins/proxy"
+
+module HTTPX
+  module Plugins
+    module Proxy
+      module SSH
+        def self.load_dependencies(_klass, *)
+          # klass.plugin(:proxy)
+          require "net/ssh/gateway"
+        end
+
+        def self.extra_options(options)
+          Class.new(options.class) do
+            def_option(:proxy) do |pr|
+              Hash[pr]
+            end
+          end.new(options)
+        end
+
+        module InstanceMethods
+          def with_proxy(*args)
+            branch(default_options.with_proxy(*args))
+          end
+
+          private
+
+          def send_requests(*requests, options)
+            request_options = @options.merge(options)
+
+            return super unless request_options.proxy
+
+            ssh_options = request_options.proxy
+            ssh_uris = ssh_options.delete(:uri)
+            ssh_uri = URI.parse(ssh_uris.shift)
+
+            return super unless ssh_uri.scheme == "ssh"
+
+            ssh_username = ssh_options.delete(:username)
+            ssh_options[:port] ||= ssh_uri.port || 22
+            if request_options.debug
+              ssh_options[:verbose] = request_options.debug_level == 2 ? :debug : :info
+            end
+            request_uri = URI(requests.first.uri)
+            @_gateway = Net::SSH::Gateway.new(ssh_uri.host, ssh_username, ssh_options)
+            begin
+              @_gateway.open(request_uri.host, request_uri.port) do |local_port|
+                io = build_gateway_socket(local_port, request_uri, request_options)
+                super(*requests, options.merge(io: io))
+              end
+            ensure
+              @_gateway.shutdown!
+            end
+          end
+
+          def build_gateway_socket(port, request_uri, options)
+            case request_uri.scheme
+            when "https"
+              ctx = OpenSSL::SSL::SSLContext.new
+              ctx_options = SSL::TLS_OPTIONS.merge(options.ssl)
+              ctx.set_params(ctx_options) unless ctx_options.empty?
+              sock = TCPSocket.open("localhost", port)
+              io = OpenSSL::SSL::SSLSocket.new(sock, ctx)
+              io.hostname = request_uri.host
+              io.sync_close = true
+              io.connect
+              io.post_connection_check(request_uri.host) if ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
+              io
+            when "http"
+              TCPSocket.open("localhost", port)
+            else
+              raise Error, "unexpected scheme: #{request_uri.scheme}"
+            end
+          end
+        end
+      end
+    end
+    register_plugin :"proxy/ssh", Proxy::SSH
+  end
+end

data/lib/httpx/plugins/push_promise.rb

@@ -2,9 +2,17 @@
 
 module HTTPX
   module Plugins
+    #
+    # This plugin adds support for HTTP/2 Push responses.
+    #
+    # In order to benefit from this, requests are sent one at a time, so that
+    # no push responses are received after corresponding request has been sent.
+    #
     module PushPromise
-      PUSH_OPTIONS = { http2_settings: { settings_enable_push: 1 },
-                       max_concurrent_requests: 1 }.freeze
+      def self.extra_options(options)
+        options.merge(http2_settings: { settings_enable_push: 1 },
+                      max_concurrent_requests: 1)
+      end
 
       module ResponseMethods
         def pushed?
@@ -17,13 +25,12 @@ module HTTPX
       end
 
       module InstanceMethods
-        def initialize(opts = {})
-          super(PUSH_OPTIONS.merge(opts))
-          @promise_headers = {}
-        end
-
         private
 
+        def promise_headers
+          @promise_headers ||= {}
+        end
+
         def on_promise(parser, stream)
           stream.on(:promise_headers) do |h|
             __on_promise_request(parser, stream, h)
@@ -40,10 +47,11 @@ module HTTPX
           headers = @options.headers_class.new(h)
           path = headers[":path"]
           authority = headers[":authority"]
+
           request = parser.pending.find { |r| r.authority == authority && r.path == path }
           if request
             request.merge_headers(headers)
-            @promise_headers[stream] = request
+            promise_headers[stream] = request
             parser.pending.delete(request)
           else
             stream.refuse
@@ -51,8 +59,9 @@ module HTTPX
         end
 
         def __on_promise_response(parser, stream, h)
-          request = @promise_headers.delete(stream)
+          request = promise_headers.delete(stream)
           return unless request
+
           parser.__send__(:on_stream_headers, stream, request, h)
           request.transition(:done)
           response = request.response