excon 0.109.0 → 1.5.0

data/lib/excon/resolver_factory.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Excon
+  # This factory produces new +resolv+ gem resolver instances. Users who wants
+  # to configure a custom resolver (varying settings for varying resolvers) can
+  # provide a custom resolver factory class and configure it globally on the
+  # Excon defaults:
+  #
+  #   Excon.defaults[:resolver_factory] = MyCustomResolverFactory
+  #
+  # Then you just need to provide a static method called +.create_resolver+
+  # which returns a new +Resolv+ instance. This allows the customization.
+  class ResolverFactory
+    # @return [Resolv] the new resolver instance
+    def self.create_resolver
+      Resolv.new
+    end
+  end
+end

data/lib/excon/response.rb

@@ -106,9 +106,9 @@ module Excon
 
       unless (['HEAD', 'CONNECT'].include?(datum[:method].to_s.upcase)) || NO_ENTITY.include?(datum[:response][:status])
 
-        if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Transfer-Encoding') == 0 })
+        if (key = datum[:response][:headers].keys.detect {|k| k.casecmp?('Transfer-Encoding') })
           encodings = Utils.split_header_value(datum[:response][:headers][key])
-          if (encoding = encodings.last) && encoding.casecmp('chunked') == 0
+          if (encoding = encodings.last) && encoding.casecmp?('chunked')
             transfer_encoding_chunked = true
             if encodings.length == 1
               datum[:response][:headers].delete(key)
@@ -156,7 +156,7 @@ module Excon
           end
           parse_headers(socket, datum) # merge trailers into headers
         else
-          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp('Content-Length') == 0 })
+          if (key = datum[:response][:headers].keys.detect {|k| k.casecmp?('Content-Length') })
             content_length = datum[:response][:headers][key].to_i
           end
 
@@ -202,7 +202,7 @@ module Excon
           raise Excon::Error::ResponseParse, 'malformed header' unless value
           # add key/value or append value to existing values
           datum[:response][:headers][key] = ([datum[:response][:headers][key]] << value.strip).compact.join(', ')
-          if key.casecmp('Set-Cookie') == 0
+          if key.casecmp?('Set-Cookie')
             datum[:response][:cookies] << value.strip
           end
           last_key = key

data/lib/excon/socket.rb

@@ -11,19 +11,19 @@ module Excon
 
     # read/write drawn from https://github.com/ruby-amqp/bunny/commit/75d9dd79551b31a5dd3d1254c537bad471f108cf
     CONNECT_RETRY_EXCEPTION_CLASSES = if defined?(IO::EINPROGRESSWaitWritable) # Ruby >= 2.1
-      [Errno::EINPROGRESS, IO::EINPROGRESSWaitWritable]
+      [Errno::EINPROGRESS, IO::EINPROGRESSWaitWritable].freeze
     else # Ruby <= 2.0
-      [Errno::EINPROGRESS]
+      [Errno::EINPROGRESS].freeze
     end
     READ_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitReadable) # Ruby >= 2.1
-      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable, IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable]
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable, IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable].freeze
     else # Ruby <= 2.0
-      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable].freeze
     end
     WRITE_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitWritable) # Ruby >= 2.1
-      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable, IO::EAGAINWaitWritable, IO::EWOULDBLOCKWaitWritable]
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable, IO::EAGAINWaitWritable, IO::EWOULDBLOCKWaitWritable].freeze
     else # Ruby <= 2.0
-      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable].freeze
     end
     # Maps a socket operation to a timeout property.
     OPERATION_TO_TIMEOUT = {
@@ -132,7 +132,7 @@ module Excon
         family = @data[:proxy][:family]
       end
 
-      resolver = @data[:resolv_resolver] || Resolv::DefaultResolver
+      resolver = @data[:resolv_resolver] || @data[:resolver_factory].create_resolver
 
       # Deprecated
       if @data[:dns_timeouts]
@@ -181,7 +181,7 @@ module Excon
             socket.close rescue nil
           end
         rescue SystemCallError => exception
-          socket.close rescue nil if socket
+          socket&.close rescue nil
         end
       end
 
@@ -252,15 +252,11 @@ module Excon
             end
           end
         end
-      rescue OpenSSL::SSL::SSLError => error
-        if error.message == 'read would block'
-          if @read_buffer.empty?
-            select_with_timeout(@socket, :read) && retry
-          end
-        else
-          raise(error)
-        end
-      rescue *READ_RETRY_EXCEPTION_CLASSES
+      rescue OpenSSL::SSL::SSLError => e
+        raise(e) unless e.message == 'read would block'
+
+        select_with_timeout(@socket, :read) && retry if @read_buffer.empty?
+      rescue *READ_RETRY_EXCEPTION_CLASSES => e
         if @read_buffer.empty?
           # if we didn't read anything, try again...
           select_with_timeout(@socket, :read) && retry
@@ -299,12 +295,10 @@ module Excon
 
     def read_block(max_length)
       @socket.read(max_length)
-    rescue OpenSSL::SSL::SSLError => error
-      if error.message == 'read would block'
-        select_with_timeout(@socket, :read) && retry
-      else
-        raise(error)
-      end
+    rescue OpenSSL::SSL::SSLError => e
+      select_with_timeout(@socket, :read) && retry if e.message == 'read would block'
+
+      raise(error)
     rescue *READ_RETRY_EXCEPTION_CLASSES
       select_with_timeout(@socket, :read) && retry
     rescue EOFError
@@ -327,12 +321,10 @@ module Excon
           else
             raise error
           end
-        rescue OpenSSL::SSL::SSLError, *WRITE_RETRY_EXCEPTION_CLASSES => error
-          if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
-            raise error
-          else
-            select_with_timeout(@socket, :write) && retry
-          end
+        rescue OpenSSL::SSL::SSLError, *WRITE_RETRY_EXCEPTION_CLASSES => e
+          raise e if error.is_a?(OpenSSL::SSL::SSLError) && e.message != 'write would block'
+
+          select_with_timeout(@socket, :write) && retry
         end
 
         # Fast, common case.
@@ -348,12 +340,10 @@ module Excon
 
     def write_block(data)
       @socket.write(data)
-    rescue OpenSSL::SSL::SSLError, *WRITE_RETRY_EXCEPTION_CLASSES => error
-      if error.is_a?(OpenSSL::SSL::SSLError) && error.message != 'write would block'
-        raise error
-      else
-        select_with_timeout(@socket, :write) && retry
-      end
+    rescue OpenSSL::SSL::SSLError, *WRITE_RETRY_EXCEPTION_CLASSES => e
+      raise e if e.is_a?(OpenSSL::SSL::SSLError) && e.message != 'write would block'
+
+      select_with_timeout(@socket, :write) && retry
     end
 
     def select_with_timeout(socket, type)
@@ -373,25 +363,19 @@ module Excon
       end
 
       select = case type
-      when :connect_read
-        IO.select([socket], nil, nil, timeout)
-      when :connect_write
-        IO.select(nil, [socket], nil, timeout)
-      when :read
-        IO.select([socket], nil, nil, timeout)
-      when :write
-        IO.select(nil, [socket], nil, timeout)
-      end
+               when :connect_read, :read
+                 IO.select([socket], nil, nil, timeout)
+               when :connect_write, :write
+                 IO.select(nil, [socket], nil, timeout)
+               end
 
-      select || raise(Excon::Errors::Timeout.new("#{timeout_kind} timeout reached"))
+      select || raise(Excon::Errors::Timeout.new, "#{timeout_kind} timeout reached")
     end
 
     def unpacked_sockaddr
       @unpacked_sockaddr ||= ::Socket.unpack_sockaddr_in(@socket.to_io.getsockname)
     rescue ArgumentError => e
-      unless e.message == 'not an AF_INET/AF_INET6 sockaddr'
-        raise
-      end
+      raise unless e.message == 'not an AF_INET/AF_INET6 sockaddr'
     end
 
     # Returns the remaining time in seconds until we reach the deadline for the request timeout.

data/lib/excon/socks5.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Excon
+  # SOCKS5 protocol implementation (RFC 1928, RFC 1929)
+  # Shared module for SOCKS5Socket and SOCKS5SSLSocket
+  module SOCKS5
+    SOCKS5_VERSION = 0x05
+    SOCKS5_RESERVED = 0x00
+
+    # Authentication methods
+    SOCKS5_NO_AUTH = 0x00
+    SOCKS5_AUTH_USERNAME_PASSWORD = 0x02
+    SOCKS5_NO_ACCEPTABLE_AUTH = 0xFF
+
+    # Commands
+    SOCKS5_CMD_CONNECT = 0x01
+
+    # Address types
+    SOCKS5_ATYP_IPV4 = 0x01
+    SOCKS5_ATYP_DOMAIN = 0x03
+    SOCKS5_ATYP_IPV6 = 0x04
+
+    # Reply codes
+    SOCKS5_SUCCESS = 0x00
+    SOCKS5_ERRORS = {
+      0x01 => 'General SOCKS server failure',
+      0x02 => 'Connection not allowed by ruleset',
+      0x03 => 'Network unreachable',
+      0x04 => 'Host unreachable',
+      0x05 => 'Connection refused',
+      0x06 => 'TTL expired',
+      0x07 => 'Command not supported',
+      0x08 => 'Address type not supported'
+    }.freeze
+
+    # Maximum hostname length per RFC 1928
+    MAX_HOSTNAME_LENGTH = 255
+
+    private
+
+    # Parse SOCKS5 proxy string into components
+    # @param proxy_string [String] Proxy specification in various formats
+    # @return [Array<String, String, String, String>] host, port, user, pass
+    def parse_socks5_proxy(proxy_string)
+      # Support formats:
+      #   host:port
+      #   user:pass@host:port
+      #   socks5://host:port
+      #   socks5://user:pass@host:port
+      proxy_string = proxy_string.to_s.sub(%r{^socks5://}, '')
+
+      user = nil
+      pass = nil
+
+      if proxy_string.include?('@')
+        auth, host_port = proxy_string.split('@', 2)
+        user, pass = auth.split(':', 2)
+      else
+        host_port = proxy_string
+      end
+
+      host, port = host_port.split(':', 2)
+      port ||= '1080'
+
+      [host, port, user, pass]
+    end
+
+    # Perform SOCKS5 authentication handshake
+    def socks5_authenticate
+      auth_methods = if @proxy_user && @proxy_pass
+        [SOCKS5_NO_AUTH, SOCKS5_AUTH_USERNAME_PASSWORD]
+      else
+        [SOCKS5_NO_AUTH]
+      end
+
+      greeting = [SOCKS5_VERSION, auth_methods.length, *auth_methods].pack('C*')
+      @socket.write(greeting)
+
+      response = socks5_read_exactly(2)
+      version, chosen_method = response.unpack('CC')
+
+      if version != SOCKS5_VERSION
+        raise Excon::Error::Socket.new(Exception.new("SOCKS5 proxy returned invalid version: #{version}"))
+      end
+
+      case chosen_method
+      when SOCKS5_NO_AUTH
+        # No authentication required
+      when SOCKS5_AUTH_USERNAME_PASSWORD
+        unless @proxy_user && @proxy_pass
+          raise Excon::Error::Socket.new(Exception.new('SOCKS5 proxy requires authentication but no credentials provided'))
+        end
+        socks5_username_password_auth
+      when SOCKS5_NO_ACCEPTABLE_AUTH
+        raise Excon::Error::Socket.new(Exception.new('SOCKS5 proxy: no acceptable authentication methods'))
+      else
+        raise Excon::Error::Socket.new(Exception.new("SOCKS5 proxy: unsupported authentication method #{chosen_method}"))
+      end
+    end
+
+    # RFC 1929: Username/Password Authentication
+    def socks5_username_password_auth
+      auth_request = [
+        0x01, # auth protocol version
+        @proxy_user.bytesize,
+        @proxy_user,
+        @proxy_pass.bytesize,
+        @proxy_pass
+      ].pack('CCA*CA*')
+
+      @socket.write(auth_request)
+
+      response = socks5_read_exactly(2)
+      _, status = response.unpack('CC')
+
+      unless status == 0x00
+        raise Excon::Error::Socket.new(Exception.new('SOCKS5 proxy authentication failed'))
+      end
+    end
+
+    # Request connection to target through SOCKS5 proxy
+    def socks5_connect(host, port)
+      if host.bytesize > MAX_HOSTNAME_LENGTH
+        raise Excon::Error::Socket.new(Exception.new("SOCKS5: hostname exceeds maximum length of #{MAX_HOSTNAME_LENGTH} bytes"))
+      end
+
+      # Build CONNECT request with domain name (let proxy resolve DNS)
+      request = [SOCKS5_VERSION, SOCKS5_CMD_CONNECT, SOCKS5_RESERVED].pack('CCC')
+      request += [SOCKS5_ATYP_DOMAIN, host.bytesize, host].pack('CCA*')
+      request += [port.to_i].pack('n')
+
+      @socket.write(request)
+
+      response = socks5_read_exactly(4)
+      version, reply, _, atyp = response.unpack('CCCC')
+
+      if version != SOCKS5_VERSION
+        raise Excon::Error::Socket.new(Exception.new("SOCKS5 proxy returned invalid version: #{version}"))
+      end
+
+      unless reply == SOCKS5_SUCCESS
+        error_msg = SOCKS5_ERRORS[reply] || "Unknown error (#{reply})"
+        raise Excon::Error::Socket.new(Exception.new("SOCKS5 proxy connect failed: #{error_msg}"))
+      end
+
+      # Read and discard bound address (not needed for CONNECT)
+      socks5_read_bound_address(atyp)
+    end
+
+    def socks5_read_bound_address(atyp)
+      case atyp
+      when SOCKS5_ATYP_IPV4
+        socks5_read_exactly(4 + 2) # 4 bytes IP + 2 bytes port
+      when SOCKS5_ATYP_DOMAIN
+        domain_len = socks5_read_exactly(1).unpack1('C')
+        socks5_read_exactly(domain_len + 2)
+      when SOCKS5_ATYP_IPV6
+        socks5_read_exactly(16 + 2) # 16 bytes IP + 2 bytes port
+      else
+        raise Excon::Error::Socket.new(Exception.new("SOCKS5 proxy returned unknown address type: #{atyp}"))
+      end
+    end
+
+    # Read exact number of bytes with timeout support
+    def socks5_read_exactly(nbytes)
+      data = ''.dup
+      deadline = @data[:read_timeout] ? Time.now + @data[:read_timeout] : nil
+
+      while data.bytesize < nbytes
+        if deadline
+          remaining = deadline - Time.now
+          if remaining <= 0
+            raise Excon::Error::Timeout.new('SOCKS5 read timeout')
+          end
+          ready = IO.select([@socket], nil, nil, remaining)
+          unless ready
+            raise Excon::Error::Timeout.new('SOCKS5 read timeout')
+          end
+        end
+
+        chunk = @socket.read_nonblock(nbytes - data.bytesize, exception: false)
+        case chunk
+        when :wait_readable
+          IO.select([@socket], nil, nil, deadline ? [deadline - Time.now, 0].max : nil)
+        when nil, ''
+          raise Excon::Error::Socket.new(Exception.new('SOCKS5 proxy connection closed unexpectedly'))
+        else
+          data << chunk
+        end
+      end
+      data
+    end
+  end
+end

data/lib/excon/socks5_socket.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Excon
+  class SOCKS5Socket < Socket
+    include SOCKS5
+
+    def initialize(data = {})
+      @socks5_proxy = data[:socks5_proxy]
+      @proxy_host, @proxy_port, @proxy_user, @proxy_pass = parse_socks5_proxy(@socks5_proxy)
+      super(data)
+    end
+
+    private
+
+    # Proxy-swap pattern: temporarily set @data[:proxy] to the SOCKS5 proxy
+    # so that Socket#connect routes the TCP connection there (inheriting DNS
+    # resolution, nonblock, retry, keepalive, reuseaddr, remote_ip tracking).
+    # After TCP is up, clear :proxy and run the SOCKS5 handshake.
+    def connect
+      @data[:proxy] = {
+        host:     @proxy_host,
+        hostname: @proxy_host,
+        port:     @proxy_port.to_i
+      }
+
+      begin
+        super
+      ensure
+        @data.delete(:proxy)
+      end
+
+      socks5_authenticate
+      socks5_connect(@data[:host], @data[:port])
+    end
+  end
+end

data/lib/excon/socks5_ssl_socket.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Excon
+  class SOCKS5SSLSocket < SSLSocket
+    include SOCKS5
+
+    def initialize(data = {})
+      @socks5_proxy = data[:socks5_proxy]
+      @proxy_host, @proxy_port, @proxy_user, @proxy_pass = parse_socks5_proxy(@socks5_proxy)
+      super(data)
+    end
+
+    private
+
+    # Proxy-swap pattern (same as SOCKS5Socket#connect).
+    #
+    # Call chain:
+    #   SOCKS5SSLSocket#initialize -> super (SSLSocket#initialize)
+    #     -> super (Socket#initialize) -> connect
+    #       -> SOCKS5SSLSocket#connect (this method)
+    #         -> super -> SSLSocket#connect -> Socket#connect (TCP to proxy)
+    #       -> SOCKS5 handshake on raw TCP socket
+    #     <- returns to SSLSocket#initialize
+    #     -> @data[:proxy] is nil, so HTTP CONNECT is skipped (line 111)
+    #     -> SSL wrapping on the SOCKS5-tunneled socket
+    def connect
+      @data[:proxy] = {
+        host:     @proxy_host,
+        hostname: @proxy_host,
+        port:     @proxy_port.to_i
+      }
+
+      begin
+        super
+      ensure
+        # Clear :proxy so SSLSocket#initialize skips HTTP CONNECT (line 111)
+        @data.delete(:proxy)
+      end
+
+      socks5_authenticate
+      socks5_connect(@data[:host], @data[:port])
+    end
+  end
+end

data/lib/excon/ssl_socket.rb

@@ -26,6 +26,7 @@ module Excon
       if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
         ssl_context_options |= OpenSSL::SSL::OP_NO_COMPRESSION
       end
+      ssl_context_options |= OpenSSL::SSL::OP_IGNORE_UNEXPECTED_EOF if @data[:ignore_unexpected_eof]
       ssl_context.options = ssl_context_options
 
       ssl_context.ciphers = @data[:ciphers]
@@ -63,7 +64,7 @@ module Excon
         unless ca_file || ca_path || cert_store
           # workaround issue #257 (JRUBY-6970)
           ca_file = DEFAULT_CA_FILE
-          ca_file = ca_file.gsub(/^jar:/, '') if ca_file =~ /^jar:file:\//
+          ca_file = ca_file.gsub(/^jar:/, '') if ca_file.match?(/^jar:file:\//)
 
           begin
             ssl_context.cert_store.add_file(ca_file)
@@ -108,8 +109,8 @@ module Excon
       end
 
       if @data[:proxy]
-        request = "CONNECT #{@data[:host]}#{port_string(@data.merge(:omit_default_port => false))}#{Excon::HTTP_1_1}" +
-                  "Host: #{@data[:host]}#{port_string(@data)}#{Excon::CR_NL}"
+        request = "CONNECT #{@data[:host]}:#{@data[:port]}#{Excon::HTTP_1_1}" \
+                  "Host: #{@data[:host]}:#{@data[:port]}#{Excon::CR_NL}"
 
         if @data[:proxy].has_key?(:user) || @data[:proxy].has_key?(:password)
           user, pass = Utils.unescape_form(@data[:proxy][:user].to_s), Utils.unescape_form(@data[:proxy][:password].to_s)

data/lib/excon/test/plugin/server/puma.rb

@@ -7,7 +7,7 @@ module Excon
             open_process(RbConfig.ruby, '-S', 'puma', '-b', bind_uri.to_s, app_str)
             process_stderr = ""
             line = ''
-            until line =~ /Use Ctrl-C to stop/
+            until line.include?('Use Ctrl-C to stop')
               line = read.gets
               raise process_stderr if line.nil?
               process_stderr << line

data/lib/excon/test/plugin/server/unicorn.rb

@@ -12,19 +12,19 @@ module Excon
               host = bind_uri.host.gsub(/[\[\]]/, '')
               bind_str = "#{host}:#{bind_uri.port}"
             end
-            args = [ 
+            args = [
               RbConfig.ruby,
               '-S',
-              'unicorn', 
-              '--no-default-middleware', 
+              'unicorn',
+              '--no-default-middleware',
               '-l',
-              bind_str,  
+              bind_str,
               app_str
             ]
             open_process(*args)
             process_stderr = ''
             line = ''
-            until line =~ /worker\=0 ready/
+            until line.include?('worker=0 ready')
               line = error.gets
               raise process_stderr if line.nil?
               process_stderr << line

data/lib/excon/test/plugin/server/webrick.rb

@@ -10,7 +10,7 @@ module Excon
             open_process(RbConfig.ruby, '-S', 'rackup', '-s', 'webrick', '--host', host, '--port', port, app_str)
             process_stderr = ""
             line = ''
-            until line =~ /HTTPServer#start/
+            until line.include?('Server#start')
               line = error.gets
               raise process_stderr if line.nil?
               process_stderr << line

data/lib/excon/test/server.rb

@@ -13,11 +13,6 @@ module Excon
 
       # Methods that must be implemented by a plugin
       INSTANCE_REQUIRES = [:start]
-      Excon.defaults.merge!(
-        connect_timeout: 5,
-        read_timeout: 5,
-        write_timeout: 5
-      )
 
       def initialize(args)
         # TODO: Validate these args
@@ -55,7 +50,7 @@ module Excon
         if RUBY_PLATFORM == 'java'
           Process.kill('USR1', pid)
         else
-          Process.kill(9, pid)
+          Process.kill('KILL', pid)
           Process.wait(pid)
         end
 
@@ -73,7 +68,7 @@ module Excon
         while (line = lines.shift)
           case line
             when /(ERROR|Error)/
-              unless line =~ /(null cert chain|did not return a certificate|SSL_read:: internal error)/
+              unless line.match?(/(null cert chain|did not return a certificate|SSL_read:: internal error)/)
                 in_err = true
                 puts
               end

data/lib/excon/unix_socket.rb

@@ -34,7 +34,7 @@ module Excon
       end
 
     rescue => error
-      @socket.close rescue nil if @socket
+      @socket&.close rescue nil
       raise error
     end