net-ssh 3.2.0 → 7.2.0.rc1

data/lib/net/ssh/packet.rb

@@ -3,100 +3,104 @@ require 'net/ssh/transport/constants'
 require 'net/ssh/authentication/constants'
 require 'net/ssh/connection/constants'
 
-module Net; module SSH
-
-  # A specialization of Buffer that knows the format of certain common
-  # packet types. It auto-parses those packet types, and allows them to
-  # be accessed via the #[] accessor.
-  #
-  #   data = some_channel_request_packet
-  #   packet = Net::SSH::Packet.new(data)
-  #
-  #   p packet.type #-> 98 (CHANNEL_REQUEST)
-  #   p packet[:request]
-  #   p packet[:want_reply]
-  #
-  # This is used exclusively internally by Net::SSH, and unless you're doing
-  # protocol-level manipulation or are extending Net::SSH in some way, you'll
-  # never need to use this class directly.
-  class Packet < Buffer
-    @@types = {}
-
-    # Register a new packet type that should be recognized and auto-parsed by
-    # Net::SSH::Packet. Note that any packet type that is not preregistered
-    # will not be autoparsed.
+module Net
+  module SSH
+    # A specialization of Buffer that knows the format of certain common
+    # packet types. It auto-parses those packet types, and allows them to
+    # be accessed via the #[] accessor.
     #
-    # The +pairs+ parameter must be either empty, or an array of two-element
-    # tuples, where the first element of each tuple is the name of the field,
-    # and the second is the type.
+    #   data = some_channel_request_packet
+    #   packet = Net::SSH::Packet.new(data)
     #
-    #   register DISCONNECT, [:reason_code, :long], [:description, :string], [:language, :string]
-    def self.register(type, *pairs)
-      @@types[type] = pairs
-    end
+    #   p packet.type #-> 98 (CHANNEL_REQUEST)
+    #   p packet[:request]
+    #   p packet[:want_reply]
+    #
+    # This is used exclusively internally by Net::SSH, and unless you're doing
+    # protocol-level manipulation or are extending Net::SSH in some way, you'll
+    # never need to use this class directly.
+    class Packet < Buffer
+      @@types = {}
 
-    include Transport::Constants, Authentication::Constants, Connection::Constants
+      # Register a new packet type that should be recognized and auto-parsed by
+      # Net::SSH::Packet. Note that any packet type that is not preregistered
+      # will not be autoparsed.
+      #
+      # The +pairs+ parameter must be either empty, or an array of two-element
+      # tuples, where the first element of each tuple is the name of the field,
+      # and the second is the type.
+      #
+      #   register DISCONNECT, [:reason_code, :long], [:description, :string], [:language, :string]
+      def self.register(type, *pairs)
+        @@types[type] = pairs
+      end
 
-    #--
-    # These are the recognized packet types. All other packet types will be
-    # accepted, but not auto-parsed, requiring the client to parse the
-    # fields using the methods provided by Net::SSH::Buffer.
-    #++
+      include Connection::Constants
+      include Authentication::Constants
+      include Transport::Constants
 
-    register DISCONNECT,                [:reason_code, :long], [:description, :string], [:language, :string]
-    register IGNORE,                    [:data, :string]
-    register UNIMPLEMENTED,             [:number, :long]
-    register DEBUG,                     [:always_display, :bool], [:message, :string], [:language, :string]
-    register SERVICE_ACCEPT,            [:service_name, :string]
-    register USERAUTH_BANNER,           [:message, :string], [:language, :string]
-    register USERAUTH_FAILURE,          [:authentications, :string], [:partial_success, :bool]
-    register GLOBAL_REQUEST,            [:request_type, :string], [:want_reply, :bool], [:request_data, :buffer]
-    register CHANNEL_OPEN,              [:channel_type, :string], [:remote_id, :long], [:window_size, :long], [:packet_size, :long]
-    register CHANNEL_OPEN_CONFIRMATION, [:local_id, :long], [:remote_id, :long], [:window_size, :long], [:packet_size, :long]
-    register CHANNEL_OPEN_FAILURE,      [:local_id, :long], [:reason_code, :long], [:description, :string], [:language, :string]
-    register CHANNEL_WINDOW_ADJUST,     [:local_id, :long], [:extra_bytes, :long]
-    register CHANNEL_DATA,              [:local_id, :long], [:data, :string]
-    register CHANNEL_EXTENDED_DATA,     [:local_id, :long], [:data_type, :long], [:data, :string]
-    register CHANNEL_EOF,               [:local_id, :long]
-    register CHANNEL_CLOSE,             [:local_id, :long]
-    register CHANNEL_REQUEST,           [:local_id, :long], [:request, :string], [:want_reply, :bool], [:request_data, :buffer]
-    register CHANNEL_SUCCESS,           [:local_id, :long]
-    register CHANNEL_FAILURE,           [:local_id, :long]
+      #--
+      # These are the recognized packet types. All other packet types will be
+      # accepted, but not auto-parsed, requiring the client to parse the
+      # fields using the methods provided by Net::SSH::Buffer.
+      #++
 
-    # The (integer) type of this packet.
-    attr_reader :type
+      register DISCONNECT,                %i[reason_code long], %i[description string], %i[language string]
+      register IGNORE,                    %i[data string]
+      register UNIMPLEMENTED,             %i[number long]
+      register DEBUG,                     %i[always_display bool], %i[message string], %i[language string]
+      register SERVICE_ACCEPT,            %i[service_name string]
+      register USERAUTH_BANNER,           %i[message string], %i[language string]
+      register USERAUTH_FAILURE,          %i[authentications string], %i[partial_success bool]
+      register GLOBAL_REQUEST,            %i[request_type string], %i[want_reply bool], %i[request_data buffer]
+      register CHANNEL_OPEN,              %i[channel_type string], %i[remote_id long], %i[window_size long], %i[packet_size long]
+      register CHANNEL_OPEN_CONFIRMATION, %i[local_id long], %i[remote_id long], %i[window_size long], %i[packet_size long]
+      register CHANNEL_OPEN_FAILURE,      %i[local_id long], %i[reason_code long], %i[description string], %i[language string]
+      register CHANNEL_WINDOW_ADJUST,     %i[local_id long], %i[extra_bytes long]
+      register CHANNEL_DATA,              %i[local_id long], %i[data string]
+      register CHANNEL_EXTENDED_DATA,     %i[local_id long], %i[data_type long], %i[data string]
+      register CHANNEL_EOF,               %i[local_id long]
+      register CHANNEL_CLOSE,             %i[local_id long]
+      register CHANNEL_REQUEST,           %i[local_id long], %i[request string], %i[want_reply bool], %i[request_data buffer]
+      register CHANNEL_SUCCESS,           %i[local_id long]
+      register CHANNEL_FAILURE,           %i[local_id long]
 
-    # Create a new packet from the given payload. This will automatically
-    # parse the packet if it is one that has been previously registered with
-    # Packet.register; otherwise, the packet will need to be manually parsed
-    # using the methods provided in the Net::SSH::Buffer superclass.
-    def initialize(payload)
-      @named_elements = {}
-      super
-      @type = read_byte
-      instantiate!
-    end
+      # The (integer) type of this packet.
+      attr_reader :type
 
-    # Access one of the auto-parsed fields by name. Raises an error if no
-    # element by the given name exists.
-    def [](name)
-      name = name.to_sym
-      raise ArgumentError, "no such element #{name}" unless @named_elements.key?(name)
-      @named_elements[name]
-    end
+      # Create a new packet from the given payload. This will automatically
+      # parse the packet if it is one that has been previously registered with
+      # Packet.register; otherwise, the packet will need to be manually parsed
+      # using the methods provided in the Net::SSH::Buffer superclass.
+      def initialize(payload)
+        @named_elements = {}
+        super
+        @type = read_byte
+        instantiate!
+      end
+
+      # Access one of the auto-parsed fields by name. Raises an error if no
+      # element by the given name exists.
+      def [](name)
+        name = name.to_sym
+        raise ArgumentError, "no such element #{name}" unless @named_elements.key?(name)
 
-    private
+        @named_elements[name]
+      end
+
+      private
 
       # Parse the packet's contents and assign the named elements, as described
       # by the registered format for the packet.
       def instantiate!
         (@@types[type] || []).each do |name, datatype|
           @named_elements[name.to_sym] = if datatype == :buffer
-            remainder_as_buffer
-          else
-            send("read_#{datatype}")
-          end
+                                           remainder_as_buffer
+                                         else
+                                           send("read_#{datatype}")
+                                         end
         end
       end
+    end
   end
-end; end
+end

data/lib/net/ssh/prompt.rb

@@ -1,93 +1,62 @@
-module Net; module SSH
-
-  # A basic prompt module that can be mixed into other objects. If HighLine is
-  # installed, it will be used to display prompts and read input from the
-  # user. Otherwise, the termios library will be used. If neither HighLine
-  # nor termios is installed, a simple prompt that echos text in the clear
-  # will be used.
-
-  module PromptMethods
-
-    # Defines the prompt method to use if the Highline library is installed.
-    module Highline
-      # Uses Highline#ask to present a prompt and accept input. If +echo+ is
-      # +false+, the characters entered by the user will not be echoed to the
-      # screen.
-      def prompt(prompt, echo=true)
-        @highline ||= ::HighLine.new
-        @highline.ask(prompt + " ") { |q| q.echo = echo }
-      end
-    end
-
-    # Defines the prompt method to use if the Termios library is installed.
-    module Termios
-      # Displays the prompt to $stdout. If +echo+ is false, the Termios
-      # library will be used to disable keystroke echoing for the duration of
-      # this method.
-      def prompt(prompt, echo=true)
-        $stdout.print(prompt)
-        $stdout.flush
-
-        set_echo(false) unless echo
-        $stdin.gets.chomp
-      ensure
-        if !echo
-          set_echo(true)
-          $stdout.puts
-        end
+require 'io/console'
+
+module Net
+  module SSH
+    # Default prompt implementation, called for asking password from user.
+    # It will never be instantiated directly, but will instead be created for
+    # you automatically.
+    #
+    # A custom prompt objects can implement caching, or different UI. The prompt
+    # object should implemnted a start method, which should return something implementing
+    # ask and success. Net::SSH uses it like:
+    #
+    #   prompter = options[:password_prompt].start({type:'password'})
+    #   while !ok && max_retries < 3
+    #     user = prompter.ask("user: ", true)
+    #     password = prompter.ask("password: ", false)
+    #     ok = send(user, password)
+    #     prompter.sucess if ok
+    #   end
+    #
+    class Prompt
+      # factory
+      def self.default(options = {})
+        @default ||= new(options)
       end
 
-      private
+      def initialize(options = {}); end
 
-        # Enables or disables keystroke echoing using the Termios library.
-        def set_echo(enable)
-          term = ::Termios.getattr($stdin)
-
-          if enable
-            term.c_lflag |= (::Termios::ECHO | ::Termios::ICANON)
-          else
-            term.c_lflag &= ~::Termios::ECHO
+      # default prompt object implementation. More sophisticated implemenetations
+      # might implement caching.
+      class Prompter
+        def initialize(info)
+          if info[:type] == 'keyboard-interactive'
+            $stdout.puts(info[:name]) unless info[:name].empty?
+            $stdout.puts(info[:instruction]) unless info[:instruction].empty?
           end
-
-          ::Termios.setattr($stdin, ::Termios::TCSANOW, term)
         end
-    end
 
-    # Defines the prompt method to use when neither Highline nor Termios are
-    # installed.
-    module Clear
-      # Displays the prompt to $stdout and pulls the response from $stdin.
-      # Text is always echoed in the clear, regardless of the +echo+ setting.
-      # The first time a prompt is given and +echo+ is false, a warning will
-      # be written to $stderr recommending that either Highline or Termios
-      # be installed.
-      def prompt(prompt, echo=true)
-        @seen_warning ||= false
-        if !echo && !@seen_warning
-          $stderr.puts "Text will be echoed in the clear. Please install the HighLine or Termios libraries to suppress echoed text."
-          @seen_warning = true
+        # ask input from user, a prompter might ask for multiple inputs
+        # (like user and password) in a single session.
+        def ask(prompt, echo = true)
+          $stdout.print(prompt)
+          $stdout.flush
+          ret = $stdin.noecho(&:gets).chomp
+          $stdout.print("\n")
+          ret
         end
 
-        $stdout.print(prompt)
-        $stdout.flush
-        $stdin.gets.chomp
+        # success method will be called when the password was accepted
+        # It's a good time to save password asked to a cache.
+        def success; end
       end
-    end
-  end
 
-  # Try to load Highline and Termios in turn, selecting the corresponding
-  # PromptMethods module to use. If neither are available, choose PromptMethods::Clear.
-  Prompt = begin
-      require 'highline'
-      HighLine.track_eof = false
-      PromptMethods::Highline
-    rescue LoadError
-      begin
-        require 'termios'
-        PromptMethods::Termios
-      rescue LoadError
-        PromptMethods::Clear
+      # start password session. Multiple questions might be asked multiple times
+      # on the returned object. Info hash tries to uniquely identify the password
+      # session, so caching implementations can save passwords properly.
+      def start(info)
+        Prompter.new(info)
       end
     end
-
-end; end
+  end
+end

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

@@ -1,108 +1,123 @@
 require 'socket'
 require 'rubygems'
 require 'net/ssh/proxy/errors'
-require 'net/ssh/ruby_compat'
 
-module Net; module SSH; module Proxy
+module Net
+  module SSH
+    module Proxy
+      # An implementation of a command proxy. To use it, instantiate it,
+      # then pass the instantiated object via the :proxy key to
+      # Net::SSH.start:
+      #
+      #   require 'net/ssh/proxy/command'
+      #
+      #   proxy = Net::SSH::Proxy::Command.new('ssh relay nc %h %p')
+      #   Net::SSH.start('host', 'user', :proxy => proxy) do |ssh|
+      #     ...
+      #   end
+      class Command
+        # The command line template
+        attr_reader :command_line_template
 
-  # An implementation of a command proxy. To use it, instantiate it,
-  # then pass the instantiated object via the :proxy key to
-  # Net::SSH.start:
-  #
-  #   require 'net/ssh/proxy/command'
-  #
-  #   proxy = Net::SSH::Proxy::Command.new('ssh relay nc %h %p')
-  #   Net::SSH.start('host', 'user', :proxy => proxy) do |ssh|
-  #     ...
-  #   end
-  class Command
+        # The command line for the session
+        attr_reader :command_line
 
-    # The command line template
-    attr_reader :command_line_template
+        # Timeout in seconds in open, defaults to 60
+        attr_accessor :timeout
 
-    # The command line for the session
-    attr_reader :command_line
-
-    # Create a new socket factory that tunnels via a command executed
-    # with the user's shell, which is composed from the given command
-    # template.  In the command template, `%h' will be substituted by
-    # the host name to connect and `%p' by the port.
-    def initialize(command_line_template)
-      @command_line_template = command_line_template
-      @command_line = nil
-    end
-
-    # Return a new socket connected to the given host and port via the
-    # proxy that was requested when the socket factory was instantiated.
-    def open(host, port, connection_options = nil)
-      command_line = @command_line_template.gsub(/%(.)/) {
-        case $1
-        when 'h'
-          host
-        when 'p'
-          port.to_s
-        when 'r'
-          remote_user = connection_options && connection_options[:remote_user]
-          if remote_user
-            remote_user
-          else
-            raise ArgumentError, "remote user name not available"
-          end
-        when '%'
-          '%'
-        else
-          raise ArgumentError, "unknown key: #{$1}"
-        end
-      }
-      begin
-        io = IO.popen(command_line, "r+")
-        if result = Net::SSH::Compat.io_select([io], nil, [io], 60)
-          if result.last.any?
-            raise "command failed"
-          end
-        else
-          raise "command timed out"
-        end
-      rescue => e
-        raise ConnectError, "#{e}: #{command_line}"
-      end
-      @command_line = command_line
-      if Gem.win_platform?
-        # read_nonblock and write_nonblock are not available on Windows
-        # pipe. Use sysread and syswrite as a replacement works.
-        def io.send(data, flag)
-          syswrite(data)
+        # Create a new socket factory that tunnels via a command executed
+        # with the user's shell, which is composed from the given command
+        # template.  In the command template, `%h' will be substituted by
+        # the host name to connect and `%p' by the port.
+        def initialize(command_line_template)
+          @command_line_template = command_line_template
+          @command_line = nil
+          @timeout = 60
         end
 
-        def io.recv(size)
-          sysread(size)
-        end
-      else
-        def io.send(data, flag)
+        # Return a new socket connected to the given host and port via the
+        # proxy that was requested when the socket factory was instantiated.
+        def open(host, port, connection_options = nil)
+          command_line = @command_line_template.gsub(/%(.)/) {
+            case $1
+            when 'h'
+              host
+            when 'p'
+              port.to_s
+            when 'r'
+              remote_user = connection_options && connection_options[:remote_user]
+              if remote_user
+                remote_user
+              else
+                raise ArgumentError, "remote user name not available"
+              end
+            when '%'
+              '%'
+            else
+              raise ArgumentError, "unknown key: #{$1}"
+            end
+          }
           begin
-            result = write_nonblock(data)
-          rescue IO::WaitWritable, Errno::EINTR
-            IO.select(nil, [self])
-            retry
+            io = IO.popen(command_line, "r+")
+            begin
+              if result = IO.select([io], nil, [io], @timeout)
+                if result.last.any? || io.eof?
+                  raise "command failed"
+                end
+              else
+                raise "command timed out"
+              end
+            rescue StandardError
+              close_on_error(io)
+              raise
+            end
+          rescue StandardError => e
+            raise ConnectError, "#{e}: #{command_line}"
           end
-          result
-        end
+          @command_line = command_line
+          if Gem.win_platform?
+            # read_nonblock and write_nonblock are not available on Windows
+            # pipe. Use sysread and syswrite as a replacement works.
+            def io.send(data, flag)
+              syswrite(data)
+            end
 
-        def io.recv(size)
-          begin
-            result = read_nonblock(size)
-          rescue IO::WaitReadable, Errno::EINTR
-            timeout_in_seconds = 20
-            if IO.select([self], nil, [self], timeout_in_seconds) == nil
-              raise "Unexpected spurious read wakeup"
+            def io.recv(size)
+              sysread(size)
+            end
+          else
+            def io.send(data, flag)
+              begin
+                result = write_nonblock(data)
+              rescue IO::WaitWritable, Errno::EINTR
+                IO.select(nil, [self])
+                retry
+              end
+              result
+            end
+
+            def io.recv(size)
+              begin
+                result = read_nonblock(size)
+              rescue IO::WaitReadable, Errno::EINTR
+                timeout_in_seconds = 20
+                if IO.select([self], nil, [self], timeout_in_seconds) == nil
+                  raise "Unexpected spurious read wakeup"
+                end
+
+                retry
+              end
+              result
             end
-            retry
           end
-          result
+          io
+        end
+
+        def close_on_error(io)
+          Process.kill('TERM', io.pid)
+          Thread.new { io.close }
         end
       end
-      io
     end
   end
-
-end; end; end
+end

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

@@ -1,14 +1,16 @@
 require 'net/ssh/errors'
 
-module Net; module SSH; module Proxy
+module Net
+  module SSH
+    module Proxy
+      # A general exception class for all Proxy errors.
+      class Error < Net::SSH::Exception; end
 
-  # A general exception class for all Proxy errors.
-  class Error < Net::SSH::Exception; end
+      # Used for reporting proxy connection errors.
+      class ConnectError < Error; end
 
-  # Used for reporting proxy connection errors.
-  class ConnectError < Error; end
-
-  # Used when the server doesn't recognize the user's credentials.
-  class UnauthorizedError < Error; end
-
-end; end; end
+      # Used when the server doesn't recognize the user's credentials.
+      class UnauthorizedError < Error; end
+    end
+  end
+end