vagrant-unbundled 2.2.18.0 → 2.2.19.0

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/socket.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+require 'resolv'
+
+module Excon
+  class Socket
+    include Utils
+
+    extend Forwardable
+
+    attr_accessor :data
+
+    # 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]
+    else # Ruby <= 2.0
+      [Errno::EINPROGRESS]
+    end
+    READ_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitReadable) # Ruby >= 2.1
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable, IO::EAGAINWaitReadable, IO::EWOULDBLOCKWaitReadable]
+    else # Ruby <= 2.0
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable]
+    end
+    WRITE_RETRY_EXCEPTION_CLASSES = if defined?(IO::EAGAINWaitWritable) # Ruby >= 2.1
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable, IO::EAGAINWaitWritable, IO::EWOULDBLOCKWaitWritable]
+    else # Ruby <= 2.0
+      [Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable]
+    end
+
+    def params
+      Excon.display_warning('Excon::Socket#params is deprecated use Excon::Socket#data instead.')
+      @data
+    end
+
+    def params=(new_params)
+      Excon.display_warning('Excon::Socket#params= is deprecated use Excon::Socket#data= instead.')
+      @data = new_params
+    end
+
+    attr_reader :remote_ip
+
+    def_delegators(:@socket, :close)
+
+    def initialize(data = {})
+      @data = data
+      @nonblock = data[:nonblock]
+      @port ||= @data[:port] || 80
+      @read_buffer = String.new
+      @eof = false
+      connect
+    end
+
+    def read(max_length = nil)
+      if @eof
+        return max_length ? nil : ''
+      elsif @nonblock
+        read_nonblock(max_length)
+      else
+        read_block(max_length)
+      end
+    end
+
+    def readline
+      return legacy_readline if RUBY_VERSION.to_f <= 1.8_7
+      buffer = String.new
+      buffer << (read_nonblock(1) || raise(EOFError)) while buffer[-1] != "\n"
+      buffer
+    end
+
+    def legacy_readline
+      begin
+        Timeout.timeout(@data[:read_timeout]) do
+          @socket.readline
+        end
+      rescue Timeout::Error
+        raise Excon::Errors::Timeout.new('read timeout reached')
+      end
+    end
+
+    def write(data)
+      if @nonblock
+        write_nonblock(data)
+      else
+        write_block(data)
+      end
+    end
+
+    def local_address
+      unpacked_sockaddr[1]
+    end
+
+    def local_port
+      unpacked_sockaddr[0]
+    end
+
+    private
+
+    def connect
+      @socket = nil
+      exception = nil
+      hostname = @data[:hostname]
+      port = @port
+      family = @data[:family]
+
+      if @data[:proxy]
+        hostname = @data[:proxy][:hostname]
+        port = @data[:proxy][:port]
+        family = @data[:proxy][:family]
+      end
+
+      Resolv.each_address(hostname) do |ip|
+        # already succeeded on previous addrinfo
+        if @socket
+          break
+        end
+
+        @remote_ip = ip
+        @data[:remote_ip] = ip
+
+        # nonblocking connect
+        begin
+          sockaddr = ::Socket.sockaddr_in(port, ip)
+          addrinfo = Addrinfo.getaddrinfo(ip, port, family, :STREAM).first
+          socket = ::Socket.new(addrinfo.pfamily, addrinfo.socktype, addrinfo.protocol)
+
+          if @data[:reuseaddr]
+            socket.setsockopt(::Socket::Constants::SOL_SOCKET, ::Socket::Constants::SO_REUSEADDR, true)
+            if defined?(::Socket::Constants::SO_REUSEPORT)
+              socket.setsockopt(::Socket::Constants::SOL_SOCKET, ::Socket::Constants::SO_REUSEPORT, true)
+            end
+          end
+
+          if @nonblock
+            socket.connect_nonblock(sockaddr)
+          else
+            socket.connect(sockaddr)
+          end
+          @socket = socket
+        rescue *CONNECT_RETRY_EXCEPTION_CLASSES
+          select_with_timeout(socket, :connect_write)
+          begin
+            socket.connect_nonblock(sockaddr)
+            @socket = socket
+          rescue Errno::EISCONN
+            @socket = socket
+          rescue SystemCallError => exception
+            socket.close rescue nil
+          end
+        rescue SystemCallError => exception
+          socket.close rescue nil if socket
+        end
+      end
+
+      exception ||= Resolv::ResolvError.new("no address for #{hostname}")
+
+      # this will be our last encountered exception
+      fail exception unless @socket
+
+      if @data[:tcp_nodelay]
+        @socket.setsockopt(::Socket::IPPROTO_TCP,
+                           ::Socket::TCP_NODELAY,
+                           true)
+      end
+
+      if @data[:keepalive]
+        if [:SOL_SOCKET, :SO_KEEPALIVE, :SOL_TCP, :TCP_KEEPIDLE, :TCP_KEEPINTVL, :TCP_KEEPCNT].all?{|c| ::Socket.const_defined? c}
+          @socket.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_KEEPALIVE, true)
+          @socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPIDLE, @data[:keepalive][:time])
+          @socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPINTVL, @data[:keepalive][:intvl])
+          @socket.setsockopt(::Socket::SOL_TCP, ::Socket::TCP_KEEPCNT, @data[:keepalive][:probes])
+        else
+          Excon.display_warning('Excon::Socket keepalive was set, but is not supported by Ruby version.')
+        end
+      end
+    end
+
+    def read_nonblock(max_length)
+      begin
+        if max_length
+          until @read_buffer.length >= max_length
+            @read_buffer << @socket.read_nonblock(max_length - @read_buffer.length)
+          end
+        else
+          loop do
+            @read_buffer << @socket.read_nonblock(@data[:chunk_size])
+          end
+        end
+      rescue OpenSSL::SSL::SSLError => error
+        if error.message == 'read would block'
+          select_with_timeout(@socket, :read) && retry
+        else
+          raise(error)
+        end
+      rescue *READ_RETRY_EXCEPTION_CLASSES
+        if @read_buffer.empty?
+          # if we didn't read anything, try again...
+          select_with_timeout(@socket, :read) && retry
+        end
+      rescue EOFError
+        @eof = true
+      end
+
+      if max_length
+        if @read_buffer.empty?
+          nil # EOF met at beginning
+        else
+          @read_buffer.slice!(0, max_length)
+        end
+      else
+        # read until EOFError, so return everything
+        @read_buffer.slice!(0, @read_buffer.length)
+      end
+    end
+
+    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 *READ_RETRY_EXCEPTION_CLASSES
+      if @read_buffer.empty?
+        select_with_timeout(@socket, :read) && retry
+      end
+    rescue EOFError
+      @eof = true
+    end
+
+    def write_nonblock(data)
+      data = binary_encode(data)
+      loop do
+        written = nil
+        begin
+          # I wish that this API accepted a start position, then we wouldn't
+          # have to slice data when there is a short write.
+          written = @socket.write_nonblock(data)
+        rescue Errno::EFAULT => error
+          if OpenSSL.const_defined?(:OPENSSL_LIBRARY_VERSION) && OpenSSL::OPENSSL_LIBRARY_VERSION.split(' ')[1] == '1.0.2'
+            msg = "The version of OpenSSL this ruby is built against (1.0.2) has a vulnerability
+                   which causes a fault. For more, see https://github.com/excon/excon/issues/467"
+            raise SecurityError.new(msg)
+          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
+        end
+
+        # Fast, common case.
+        break if written == data.size
+
+        # This takes advantage of the fact that most ruby implementations
+        # have Copy-On-Write strings. Thusly why requesting a subrange
+        # of data, we actually don't copy data because the new string
+        # simply references a subrange of the original.
+        data = data[written, data.size]
+      end
+    end
+
+    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
+    end
+
+    def select_with_timeout(socket, type)
+      select = case type
+      when :connect_read
+        IO.select([socket], nil, nil, @data[:connect_timeout])
+      when :connect_write
+        IO.select(nil, [socket], nil, @data[:connect_timeout])
+      when :read
+        IO.select([socket], nil, nil, @data[:read_timeout])
+      when :write
+        IO.select(nil, [socket], nil, @data[:write_timeout])
+      end
+      select || raise(Excon::Errors::Timeout.new("#{type} 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
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/ssl_socket.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+module Excon
+  class SSLSocket < Socket
+    HAVE_NONBLOCK = [:connect_nonblock, :read_nonblock, :write_nonblock].all? do |m|
+      OpenSSL::SSL::SSLSocket.public_method_defined?(m)
+    end
+
+    def initialize(data = {})
+      @port = data[:port] || 443
+      super
+
+      # create ssl context
+      ssl_context = OpenSSL::SSL::SSLContext.new
+
+      # set the security level before setting other parameters affected by it
+      if @data[:ssl_security_level]
+        ssl_context.security_level = @data[:ssl_security_level]
+      end
+
+      # disable less secure options, when supported
+      ssl_context_options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
+      if defined?(OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS)
+        ssl_context_options &= ~OpenSSL::SSL::OP_DONT_INSERT_EMPTY_FRAGMENTS
+      end
+
+      if defined?(OpenSSL::SSL::OP_NO_COMPRESSION)
+        ssl_context_options |= OpenSSL::SSL::OP_NO_COMPRESSION
+      end
+      ssl_context.options = ssl_context_options
+
+      ssl_context.ciphers = @data[:ciphers]
+      if @data[:ssl_version]
+        ssl_context.ssl_version = @data[:ssl_version]
+      end
+      if @data[:ssl_min_version]
+        ssl_context.min_version = @data[:ssl_min_version]
+      end
+      if @data[:ssl_max_version]
+        ssl_context.max_version = @data[:ssl_max_version]
+      end
+
+
+      if @data[:ssl_verify_peer]
+        # turn verification on
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        if (ca_file = @data[:ssl_ca_file] || ENV['SSL_CERT_FILE'])
+          ssl_context.ca_file = ca_file
+        end
+        if (ca_path = @data[:ssl_ca_path] || ENV['SSL_CERT_DIR'])
+          ssl_context.ca_path = ca_path
+        end
+        if (cert_store = @data[:ssl_cert_store])
+          ssl_context.cert_store = cert_store
+        end
+
+        # no defaults, fallback to bundled
+        unless ca_file || ca_path || cert_store
+          ssl_context.cert_store = OpenSSL::X509::Store.new
+          ssl_context.cert_store.set_default_paths
+
+          # workaround issue #257 (JRUBY-6970)
+          ca_file = DEFAULT_CA_FILE
+          ca_file = ca_file.gsub(/^jar:/, '') if ca_file =~ /^jar:file:\//
+
+          begin
+            ssl_context.cert_store.add_file(ca_file)
+          rescue
+            Excon.display_warning("Excon unable to add file to cert store, ignoring: #{ca_file}\n[#{$!.class}] #{$!.message}")
+          end
+        end
+
+        if (verify_callback = @data[:ssl_verify_callback])
+          ssl_context.verify_callback = verify_callback
+        end
+      else
+        # turn verification off
+        ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      # Verify certificate hostname if supported (ruby >= 2.4.0)
+      ssl_context.verify_hostname = @data[:ssl_verify_hostname] if ssl_context.respond_to?(:verify_hostname=)
+
+      if client_cert_data && client_key_data
+        ssl_context.cert = OpenSSL::X509::Certificate.new client_cert_data
+        if OpenSSL::PKey.respond_to? :read
+          ssl_context.key = OpenSSL::PKey.read(client_key_data, client_key_pass)
+        else
+          ssl_context.key = OpenSSL::PKey::RSA.new(client_key_data, client_key_pass)
+        end
+      elsif @data.key?(:certificate) && @data.key?(:private_key)
+        ssl_context.cert = OpenSSL::X509::Certificate.new(@data[:certificate])
+        if OpenSSL::PKey.respond_to? :read
+          ssl_context.key = OpenSSL::PKey.read(@data[:private_key], client_key_pass)
+        else
+          ssl_context.key = OpenSSL::PKey::RSA.new(@data[:private_key], client_key_pass)
+        end
+      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}"
+
+        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)
+          auth = ["#{user}:#{pass}"].pack('m').delete(Excon::CR_NL)
+          request += "Proxy-Authorization: Basic #{auth}#{Excon::CR_NL}"
+        end
+
+        request += "Proxy-Connection: Keep-Alive#{Excon::CR_NL}"
+
+        if @data[:ssl_proxy_headers]
+          request << Utils.headers_hash_to_s(@data[:ssl_proxy_headers])
+        end
+
+        request += Excon::CR_NL
+
+        # write out the proxy setup request
+        @socket.write(request)
+
+        # eat the proxy's connection response
+        response = Excon::Response.parse(self,  :expects => 200, :method => 'CONNECT')
+        if response[:response][:status] != 200
+          raise(Excon::Errors::ProxyConnectionError.new("proxy connection could not be established", request, response))
+        end
+      end
+
+      # convert Socket to OpenSSL::SSL::SSLSocket
+      @socket = OpenSSL::SSL::SSLSocket.new(@socket, ssl_context)
+      @socket.sync_close = true
+
+      # Server Name Indication (SNI) RFC 3546
+      if @socket.respond_to?(:hostname=)
+        @socket.hostname = @data[:host]
+      end
+
+      begin
+        if @nonblock
+          begin
+            @socket.connect_nonblock
+          rescue Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitReadable
+            select_with_timeout(@socket, :connect_read) && retry
+          rescue IO::WaitWritable
+            select_with_timeout(@socket, :connect_write) && retry
+          end
+        else
+          @socket.connect
+        end
+      rescue Errno::ETIMEDOUT, Timeout::Error
+        raise Excon::Errors::Timeout.new('connect timeout reached')
+      end
+
+      # verify connection
+      if @data[:ssl_verify_peer]
+        @socket.post_connection_check(@data[:ssl_verify_peer_host] || @data[:host])
+      end
+    end
+
+    private
+
+    def client_cert_data
+      @client_cert_data ||= if (ccd = @data[:client_cert_data])
+                              ccd
+                            elsif (path = @data[:client_cert])
+                              File.read path
+                            elsif (path = @data[:certificate_path])
+                              warn ":certificate_path is no longer supported and will be deprecated. Please use :client_cert or :client_cert_data"
+                              File.read path
+                            end
+    end
+
+    def connect
+      # backwards compatability for things lacking nonblock
+      @nonblock = HAVE_NONBLOCK && @nonblock
+      super
+    end
+
+    def client_key_data
+      @client_key_data ||= if (ckd = @data[:client_key_data])
+                             ckd
+                           elsif (path = @data[:client_key])
+                             File.read path
+                           elsif (path = @data[:private_key_path])
+                             warn ":private_key_path is no longer supported and will be deprecated. Please use :client_key or :client_key_data"
+                             File.read path
+                           end
+    end
+
+    def client_key_pass
+      @data[:client_key_pass] || @data[:private_key_pass]
+    end
+
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/test/plugin/server/exec.rb

@@ -0,0 +1,26 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Exec
+          def start(app_str = app)
+            open_process(app_str)
+            process_stderr = ""
+            line = ''
+            until line =~ /\Aready\Z/
+              line = error.gets
+              raise process_stderr if line.nil?
+              process_stderr << line
+              fatal_time = elapsed_time > timeout
+              if fatal_time
+                msg = "executable #{app_str} has taken too long to start"
+                raise msg
+              end
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/test/plugin/server/puma.rb

@@ -0,0 +1,23 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Puma
+          def start(app_str = app, bind_uri = bind)
+            open_process(RbConfig.ruby, '-S', 'puma', '-b', bind_uri.to_s, app_str)
+            process_stderr = ""
+            line = ''
+            until line =~ /Use Ctrl-C to stop/
+              line = read.gets
+              raise process_stderr if line.nil?
+              process_stderr << line
+              fatal_time = elapsed_time > timeout
+              raise 'puma server has taken too long to start' if fatal_time
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/test/plugin/server/unicorn.rb

@@ -0,0 +1,40 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Unicorn
+          def start(app_str = app, bind_uri = bind)
+            bind_uri = URI.parse(bind_uri) unless bind_uri.is_a? URI::Generic
+            is_unix_socket = (bind_uri.scheme == "unix")
+            if is_unix_socket
+              bind_str = bind_uri.to_s
+            else
+              host = bind_uri.host.gsub(/[\[\]]/, '')
+              bind_str = "#{host}:#{bind_uri.port}"
+            end
+            args = [ 
+              RbConfig.ruby,
+              '-S',
+              'unicorn', 
+              '--no-default-middleware', 
+              '-l',
+              bind_str,  
+              app_str
+            ]
+            open_process(*args)
+            process_stderr = ''
+            line = ''
+            until line =~ /worker\=0 ready/
+              line = error.gets
+              raise process_stderr if line.nil?
+              process_stderr << line
+              fatal_time = elapsed_time > timeout
+              raise 'unicorn server has taken too long to start' if fatal_time
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/excon-0.89.0/lib/excon/test/plugin/server/webrick.rb

@@ -0,0 +1,26 @@
+module Excon
+  module Test
+    module Plugin
+      module Server
+        module Webrick
+          def start(app_str = app, bind_uri = bind)
+            bind_uri = URI.parse(bind_uri) unless bind_uri.is_a? URI::Generic
+            host = bind_uri.host.gsub(/[\[\]]/, '')
+            port = bind_uri.port.to_s
+            open_process(RbConfig.ruby, '-S', 'rackup', '-s', 'webrick', '--host', host, '--port', port, app_str)
+            process_stderr = ""
+            line = ''
+            until line =~ /HTTPServer#start/
+              line = error.gets
+              raise process_stderr if line.nil?
+              process_stderr << line
+              fatal_time = elapsed_time > timeout
+              raise 'webrick server has taken too long to start' if fatal_time
+            end
+            true
+          end
+        end
+      end
+    end
+  end
+end