net-ssh 5.0.2 → 7.0.1

data/lib/net/ssh/proxy/socks5.rb

@@ -1,11 +1,9 @@
 require 'socket'
-require 'net/ssh/ruby_compat'
 require 'net/ssh/proxy/errors'
 
 module Net
   module SSH
     module Proxy
-
       # An implementation of a SOCKS5 proxy. To use it, instantiate it, then
       # pass the instantiated object via the :proxy key to Net::SSH.start:
       #
@@ -54,7 +52,7 @@ module Net
         # Create a new proxy connection to the given proxy host and port.
         # Optionally, :user and :password options may be given to
         # identify the username and password with which to authenticate.
-        def initialize(proxy_host, proxy_port=1080, options={})
+        def initialize(proxy_host, proxy_port = 1080, options = {})
           @proxy_host = proxy_host
           @proxy_port = proxy_port
           @options = options
@@ -95,7 +93,7 @@ module Net
 
           packet << [port].pack("n")
           socket.send packet, 0
-          
+
           version, reply, = socket.recv(2).unpack("C*")
           socket.recv(1)
           address_type = socket.recv(1).getbyte(0)
@@ -112,7 +110,7 @@ module Net
             raise ConnectError, "Illegal response type"
           end
           portnum = socket.recv(2)
-          
+
           unless reply == SUCCESS
             socket.close
             raise ConnectError, "#{reply}"
@@ -137,7 +135,6 @@ module Net
           end
         end
       end
-
     end
   end
 end

data/lib/net/ssh/service/forward.rb

@@ -3,7 +3,6 @@ require 'net/ssh/loggable'
 module Net
   module SSH
     module Service
-
       # This class implements various port forwarding services for use by
       # Net::SSH clients. The Forward class should never need to be instantiated
       # directly; instead, it should be accessed via the singleton instance
@@ -18,7 +17,7 @@ module Net
         attr_reader :session
 
         # A simple class for representing a requested remote forwarded port.
-        Remote = Struct.new(:host, :port) #:nodoc:
+        Remote = Struct.new(:host, :port) # :nodoc:
 
         # Instantiates a new Forward service instance atop the given connection
         # service session. This will register new channel open handlers to handle
@@ -85,7 +84,8 @@ module Net
             client = server.accept
             debug { "received connection on #{socket}" }
 
-            channel = session.open_channel("direct-tcpip", :string, remote_host, :long, remote_port, :string, bind_address, local_port_type, local_port) do |achannel|
+            channel = session.open_channel("direct-tcpip", :string, remote_host, :long,
+                                           remote_port, :string, bind_address, local_port_type, local_port) do |achannel|
               achannel.info { "direct channel established" }
             end
 
@@ -105,7 +105,7 @@ module Net
         #
         #   ssh.forward.cancel_local(1234)
         #   ssh.forward.cancel_local(1234, "0.0.0.0")
-        def cancel_local(port, bind_address="127.0.0.1")
+        def cancel_local(port, bind_address = "127.0.0.1")
           socket = @local_forwarded_ports.delete([port, bind_address])
           socket.shutdown rescue nil
           socket.close rescue nil
@@ -214,7 +214,7 @@ module Net
         #     raise Net::SSH::Exception, "remote forwarding request failed"
         #   end
         #
-        def remote(port, host, remote_port, remote_host="127.0.0.1")
+        def remote(port, host, remote_port, remote_host = "127.0.0.1")
           session.send_global_request("tcpip-forward", :string, remote_host, :long, remote_port) do |success, response|
             if success
               remote_port = response.read_long if remote_port == 0
@@ -248,7 +248,7 @@ module Net
         #
         #   ssh.forward.cancel_remote(1234, "0.0.0.0")
         #   ssh.loop { ssh.forward.active_remotes.include?([1234, "0.0.0.0"]) }
-        def cancel_remote(port, host="127.0.0.1")
+        def cancel_remote(port, host = "127.0.0.1")
           session.send_global_request("cancel-tcpip-forward", :string, host, :long, port) do |success, response|
             if success
               @remote_forwarded_ports.delete([port, host])
@@ -289,6 +289,7 @@ module Net
         #    end
         def agent(channel)
           return if @agent_forwarded
+
           @agent_forwarded = true
 
           channel.send_channel_request("auth-agent-req@openssh.com") do |achannel, success|
@@ -387,12 +388,13 @@ module Net
           originator_address = packet.read_string
           originator_port    = packet.read_long
 
+          puts "REMOTE 0: #{connected_port} #{connected_address} #{originator_address} #{originator_port}"
           remote = @remote_forwarded_ports[[connected_port, connected_address]]
-
           if remote.nil?
             raise Net::SSH::ChannelOpenFailed.new(1, "unknown request from remote forwarded connection on #{connected_address}:#{connected_port}")
           end
 
+          puts "REMOTE: #{remote.host} #{remote.port}"
           client = TCPSocket.new(remote.host, remote.port)
           info { "connected #{connected_address}:#{connected_port} originator #{originator_address}:#{originator_port}" }
 
@@ -419,7 +421,6 @@ module Net
           end
         end
       end
-
     end
   end
 end

data/lib/net/ssh/test/channel.rb

@@ -1,7 +1,6 @@
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Test
-
       # A mock channel, used for scripting actions in tests. It wraps a
       # Net::SSH::Test::Script instance, and delegates to it for the most part.
       # This class has little real functionality on its own, but rather acts as
@@ -19,34 +18,34 @@ module Net
       class Channel
         # The Net::SSH::Test::Script instance employed by this mock channel.
         attr_reader :script
-    
+
         # Sets the local-id of this channel object (the id assigned by the client).
         attr_writer :local_id
-    
+
         # Sets the remote-id of this channel object (the id assigned by the mock-server).
         attr_writer :remote_id
-    
+
         # Creates a new Test::Channel instance on top of the given +script+ (which
         # must be a Net::SSH::Test::Script instance).
         def initialize(script)
           @script = script
           @local_id = @remote_id = nil
         end
-    
+
         # Returns the local (client-assigned) id for this channel, or a Proc object
         # that will return the local-id later if the local id has not yet been set.
         # (See Net::SSH::Test::Packet#instantiate!.)
         def local_id
           @local_id || Proc.new { @local_id or raise "local-id has not been set yet!" }
         end
-    
+
         # Returns the remote (server-assigned) id for this channel, or a Proc object
         # that will return the remote-id later if the remote id has not yet been set.
         # (See Net::SSH::Test::Packet#instantiate!.)
         def remote_id
           @remote_id || Proc.new { @remote_id or raise "remote-id has not been set yet!" }
         end
-    
+
         # Because adjacent calls to #gets_data will sometimes cause the data packets
         # to be concatenated (causing expectations in tests to fail), you may
         # need to separate those calls with calls to #inject_remote_delay! (which
@@ -58,62 +57,62 @@ module Net
         def inject_remote_delay!
           gets_data("")
         end
-    
-        # Scripts the sending of an "exec" channel request packet to the mock 
+
+        # Scripts the sending of an "exec" channel request packet to the mock
         # server. If +reply+ is true, then the server is expected to reply to the
         # request, otherwise no response to this request will be sent. If +success+
         # is +true+, then the request will be successful, otherwise a failure will
         # be scripted.
         #
         #   channel.sends_exec "ls -l"
-        def sends_exec(command, reply=true, success=true)
+        def sends_exec(command, reply = true, success = true)
           script.sends_channel_request(self, "exec", reply, command, success)
         end
-    
+
         # Scripts the sending of a "subsystem" channel request packet to the mock
         # server. See #sends_exec for a discussion of the meaning of the +reply+
         # and +success+ arguments.
         #
         #   channel.sends_subsystem "sftp"
-        def sends_subsystem(subsystem, reply=true, success=true)
+        def sends_subsystem(subsystem, reply = true, success = true)
           script.sends_channel_request(self, "subsystem", reply, subsystem, success)
         end
-    
+
         # Scripts the sending of a data packet across the channel.
         #
         #   channel.sends_data "foo"
         def sends_data(data)
           script.sends_channel_data(self, data)
         end
-    
+
         # Scripts the sending of an EOF packet across the channel.
         #
         #   channel.sends_eof
         def sends_eof
           script.sends_channel_eof(self)
         end
-    
+
         # Scripts the sending of a "channel close" packet across the channel.
         #
         #   channel.sends_close
         def sends_close
           script.sends_channel_close(self)
         end
-    
+
         # Scripts the sending of a "request pty" request packet across the channel.
         #
         #   channel.sends_request_pty
         def sends_request_pty
           script.sends_channel_request_pty(self)
         end
-    
+
         # Scripts the reception of a channel data packet from the remote end.
         #
         #   channel.gets_data "bar"
         def gets_data(data)
           script.gets_channel_data(self, data)
         end
-    
+
         # Scripts the reception of a channel extended data packet from the remote
         # end.
         #
@@ -121,21 +120,21 @@ module Net
         def gets_extended_data(data)
           script.gets_channel_extended_data(self, data)
         end
-    
+
         # Scripts the reception of an "exit-status" channel request packet.
         #
         #   channel.gets_exit_status(127)
-        def gets_exit_status(status=0)
+        def gets_exit_status(status = 0)
           script.gets_channel_request(self, "exit-status", false, status)
         end
-    
+
         # Scripts the reception of an EOF packet from the remote end.
         #
         #   channel.gets_eof
         def gets_eof
           script.gets_channel_eof(self)
         end
-    
+
         # Scripts the reception of a "channel close" packet from the remote end.
         #
         #   channel.gets_close
@@ -143,7 +142,6 @@ module Net
           script.gets_channel_close(self)
         end
       end
-
     end
   end
-end
+end

data/lib/net/ssh/test/extensions.rb

@@ -6,16 +6,14 @@ require 'net/ssh/connection/constants'
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/packet_stream'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Test
-
       # A collection of modules used to extend/override the default behavior of
       # Net::SSH internals for ease of testing. As a consumer of Net::SSH, you'll
       # never need to use this directly--they're all used under the covers by
       # the Net::SSH::Test system.
       module Extensions
-    
         # An extension to Net::SSH::BufferedIo (assumes that the underlying IO
         # is actually a StringIO). Facilitates unit testing.
         module BufferedIo
@@ -24,80 +22,82 @@ module Net
           def select_for_read?
             pos < size
           end
-    
+
           # Set this to +true+ if you want the IO to pretend to be available for writing
           attr_accessor :select_for_write
-    
+
           # Set this to +true+ if you want the IO to pretend to be in an error state
           attr_accessor :select_for_error
-    
+
           alias select_for_write? select_for_write
           alias select_for_error? select_for_error
         end
-    
+
         # An extension to Net::SSH::Transport::PacketStream (assumes that the
         # underlying IO is actually a StringIO). Facilitates unit testing.
         module PacketStream
           include BufferedIo # make sure we get the extensions here, too
-    
-          def self.included(base) #:nodoc:
+
+          def self.included(base) # :nodoc:
             base.send :alias_method, :real_available_for_read?, :available_for_read?
             base.send :alias_method, :available_for_read?, :test_available_for_read?
-    
+
             base.send :alias_method, :real_enqueue_packet, :enqueue_packet
             base.send :alias_method, :enqueue_packet, :test_enqueue_packet
-    
+
             base.send :alias_method, :real_poll_next_packet, :poll_next_packet
             base.send :alias_method, :poll_next_packet, :test_poll_next_packet
           end
-    
+
           # Called when another packet should be inspected from the current
           # script. If the next packet is a remote packet, it pops it off the
           # script and shoves it onto this IO object, making it available to
           # be read.
           def idle!
             return false unless script.next(:first)
-    
+
             if script.next(:first).remote?
               self.string << script.next.to_s
               self.pos = pos
             end
-    
+
             return true
           end
-    
+
           # The testing version of Net::SSH::Transport::PacketStream#available_for_read?.
           # Returns true if there is data pending to be read. Otherwise calls #idle!.
           def test_available_for_read?
             return true if select_for_read?
+
             idle!
             false
           end
-    
+
           # The testing version of Net::SSH::Transport::PacketStream#enqueued_packet.
           # Simply calls Net::SSH::Test::Script#process on the packet.
           def test_enqueue_packet(payload)
             packet = Net::SSH::Buffer.new(payload.to_s)
             script.process(packet)
           end
-    
+
           # The testing version of Net::SSH::Transport::PacketStream#poll_next_packet.
           # Reads the next available packet from the IO object and returns it.
           def test_poll_next_packet
             return nil if available <= 0
+
             packet = Net::SSH::Buffer.new(read_available(4))
             length = packet.read_long
             Net::SSH::Packet.new(read_available(length))
           end
         end
-    
+
         # An extension to Net::SSH::Connection::Channel. Facilitates unit testing.
         module Channel
-          def self.included(base) #:nodoc:
+          def self.included(base) # :nodoc:
             base.send :alias_method, :send_data_for_real, :send_data
             base.send :alias_method, :send_data, :send_data_for_test
           end
-    
+
           # The testing version of Net::SSH::Connection::Channel#send_data. Calls
           # the original implementation, and then immediately enqueues the data for
           # output so that scripted sends are properly interpreted as discrete
@@ -107,16 +107,16 @@ module Net
             enqueue_pending_output
           end
         end
-    
+
         # An extension to the built-in ::IO class. Simply redefines IO.select
         # so that it can be scripted in Net::SSH unit tests.
         module IO
-          def self.included(base) #:nodoc:
+          def self.included(base) # :nodoc:
             base.extend(ClassMethods)
           end
-    
+
           @extension_enabled = false
-    
+
           def self.with_test_extension(&block)
             orig_value = @extension_enabled
             @extension_enabled = true
@@ -126,41 +126,43 @@ module Net
               @extension_enabled = orig_value
             end
           end
-    
+
           def self.extension_enabled?
             @extension_enabled
           end
-    
+
           module ClassMethods
-            def self.extended(obj) #:nodoc:
-              class <<obj
+            def self.extended(obj) # :nodoc:
+              class << obj
                 alias_method :select_for_real, :select
                 alias_method :select, :select_for_test
               end
             end
-    
+
             # The testing version of ::IO.select. Assumes that all readers,
             # writers, and errors arrays are either nil, or contain only objects
             # that mix in Net::SSH::Test::Extensions::BufferedIo.
-            def select_for_test(readers=nil, writers=nil, errors=nil, wait=nil)
+            def select_for_test(readers = nil, writers = nil, errors = nil, wait = nil)
               return select_for_real(readers, writers, errors, wait) unless Net::SSH::Test::Extensions::IO.extension_enabled?
+
               ready_readers = Array(readers).select { |r| r.select_for_read? }
               ready_writers = Array(writers).select { |r| r.select_for_write? }
               ready_errors  = Array(errors).select  { |r| r.select_for_error? }
-    
+
               return [ready_readers, ready_writers, ready_errors] if ready_readers.any? || ready_writers.any? || ready_errors.any?
-    
+
               processed = 0
               Array(readers).each do |reader|
                 processed += 1 if reader.idle!
               end
-    
+
               raise "no readers were ready for reading, and none had any incoming packets" if processed == 0 && wait != 0
+
+              [[], [], []]
             end
           end
         end
       end
-
     end
   end
 end

data/lib/net/ssh/test/kex.rb

@@ -5,10 +5,9 @@ require 'net/ssh/transport/algorithms'
 require 'net/ssh/transport/constants'
 require 'net/ssh/transport/kex'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Test
-
       # An implementation of a key-exchange strategy specifically for unit tests.
       # (This strategy would never really work against a real SSH server--it makes
       # too many assumptions about the server's response.)
@@ -17,29 +16,28 @@ module Net
       # "test" algorithm.
       class Kex
         include Net::SSH::Transport::Constants
-    
+
         # Creates a new instance of the testing key-exchange algorithm with the
         # given arguments.
         def initialize(algorithms, connection, data)
           @connection = connection
         end
-    
+
         # Exchange keys with the server. This returns a hash of constant values,
         # and does not actually exchange keys.
         def exchange_keys
           result = Net::SSH::Buffer.from(:byte, NEWKEYS)
           @connection.send_message(result)
-    
+
           buffer = @connection.next_message
           raise Net::SSH::Exception, "expected NEWKEYS" unless buffer.type == NEWKEYS
-    
+
           { session_id: "abc-xyz",
             server_key: OpenSSL::PKey::RSA.new(512),
             shared_secret: OpenSSL::BN.new("1234567890", 10),
             hashing_algorithm: OpenSSL::Digest::SHA1 }
         end
       end
-
     end
   end
 end

data/lib/net/ssh/test/local_packet.rb

@@ -4,7 +4,6 @@ require 'net/ssh/test/packet'
 module Net
   module SSH
     module Test
-
       # This is a specialization of Net::SSH::Test::Packet for representing mock
       # packets that are sent from the local (client) host. These are created
       # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
@@ -49,7 +48,6 @@ module Net
           end
         end
       end
-
     end
   end
 end

data/lib/net/ssh/test/packet.rb

@@ -4,7 +4,6 @@ require 'net/ssh/transport/constants'
 module Net
   module SSH
     module Test
-
       # This is an abstract class, not to be instantiated directly, subclassed by
       # Net::SSH::Test::LocalPacket and Net::SSH::Test::RemotePacket. It implements
       # functionality common to those subclasses.
@@ -70,7 +69,7 @@ module Net
         # added. Unsupported packet types will otherwise raise an exception.
         def types
           @types ||= case @type
-                     when KEXINIT then
+                     when KEXINIT
                        %i[long long long long
                           string string string string string string string string string string
                           bool]
@@ -83,13 +82,14 @@ module Net
                      when CHANNEL_REQUEST
                        parts = %i[long string bool]
                        case @data[1]
-                       when "exec", "subsystem","shell" then parts << :string
+                       when "exec", "subsystem", "shell" then parts << :string
                        when "exit-status" then parts << :long
                        when "pty-req" then parts.concat(%i[string long long long long string])
                        when "env" then parts.contact(%i[string string])
                        else
                          request = Packet.registered_channel_requests(@data[1])
                          raise "don't know what to do about #{@data[1]} channel request" unless request
+
                          parts.concat(request[:extra_parts])
                        end
                      else raise "don't know how to parse packet type #{@type}"

data/lib/net/ssh/test/remote_packet.rb

@@ -1,10 +1,9 @@
 require 'net/ssh/buffer'
 require 'net/ssh/test/packet'
 
-module Net 
-  module SSH 
+module Net
+  module SSH
     module Test
-
       # This is a specialization of Net::SSH::Test::Packet for representing mock
       # packets that are received by the local (client) host. These are created
       # automatically by Net::SSH::Test::Script and Net::SSH::Test::Channel by any
@@ -14,7 +13,7 @@ module Net
         def remote?
           true
         end
-    
+
         # The #process method should only be called on Net::SSH::Test::LocalPacket
         # packets; if it is attempted on a remote packet, then it is an expectation
         # mismatch (a remote packet was received when a local packet was expected
@@ -23,8 +22,8 @@ module Net
         def process(packet)
           raise "received packet type #{packet.read_byte} and was not expecting any packet"
         end
-    
-        # Returns this remote packet as a string, suitable for parsing by 
+
+        # Returns this remote packet as a string, suitable for parsing by
         # Net::SSH::Transport::PacketStream and friends. When a remote packet is
         # received, this method is called and the result concatenated onto the
         # input buffer for the packet stream.
@@ -36,7 +35,6 @@ module Net
           end
         end
       end
-
     end
   end
-end
+end