net-ssh 5.0.0.beta1 → 5.0.0.beta2

data/lib/net/ssh/loggable.rb

@@ -1,61 +1,63 @@
-module Net; module SSH
-
-  # A simple module to make logging easier to deal with. It assumes that the
-  # logger instance (if not nil) quacks like a Logger object (in Ruby's
-  # standard library). Although used primarily internally by Net::SSH, it
-  # can easily be used to add Net::SSH-like logging to your own programs.
-  #
-  #   class MyClass
-  #     include Net::SSH::Loggable
-  #   end
-  #
-  #   Net::SSH.start(...) do |ssh|
-  #     obj = MyClass.new
-  #     obj.logger = ssh.logger
-  #     ...
-  #   end
-  module Loggable
-    # The logger instance that will be used to log messages. If nil, nothing
-    # will be logged.
-    attr_accessor :logger
-
-    # Displays the result of yielding if the log level is Logger::DEBUG or
-    # greater.
-    def debug
-      logger.add(Logger::DEBUG, nil, facility) { yield } if logger && logger.debug?
-    end
-
-    # Displays the result of yielding if the log level is Logger::INFO or
-    # greater.
-    def info
-      logger.add(Logger::INFO, nil, facility) { yield } if logger && logger.info?
-    end
-
-    # Displays the result of yielding if the log level is Logger::WARN or
-    # greater. (Called lwarn to avoid shadowing with Kernel#warn.)
-    def lwarn
-      logger.add(Logger::WARN, nil, facility) { yield } if logger && logger.warn?
-    end
-
-    # Displays the result of yielding if the log level is Logger:ERROR or
-    # greater.
-    def error
-      logger.add(Logger::ERROR, nil, facility) { yield } if logger && logger.error?
-    end
-
-    # Displays the result of yielding if the log level is Logger::FATAL or
-    # greater.
-    def fatal
-      logger.add(Logger::FATAL, nil, facility) { yield } if logger && logger.fatal?
-    end
-
-    private
-
+module Net 
+  module SSH
+
+    # A simple module to make logging easier to deal with. It assumes that the
+    # logger instance (if not nil) quacks like a Logger object (in Ruby's
+    # standard library). Although used primarily internally by Net::SSH, it
+    # can easily be used to add Net::SSH-like logging to your own programs.
+    #
+    #   class MyClass
+    #     include Net::SSH::Loggable
+    #   end
+    #
+    #   Net::SSH.start(...) do |ssh|
+    #     obj = MyClass.new
+    #     obj.logger = ssh.logger
+    #     ...
+    #   end
+    module Loggable
+      # The logger instance that will be used to log messages. If nil, nothing
+      # will be logged.
+      attr_accessor :logger
+  
+      # Displays the result of yielding if the log level is Logger::DEBUG or
+      # greater.
+      def debug
+        logger.add(Logger::DEBUG, nil, facility) { yield } if logger && logger.debug?
+      end
+  
+      # Displays the result of yielding if the log level is Logger::INFO or
+      # greater.
+      def info
+        logger.add(Logger::INFO, nil, facility) { yield } if logger && logger.info?
+      end
+  
+      # Displays the result of yielding if the log level is Logger::WARN or
+      # greater. (Called lwarn to avoid shadowing with Kernel#warn.)
+      def lwarn
+        logger.add(Logger::WARN, nil, facility) { yield } if logger && logger.warn?
+      end
+  
+      # Displays the result of yielding if the log level is Logger:ERROR or
+      # greater.
+      def error
+        logger.add(Logger::ERROR, nil, facility) { yield } if logger && logger.error?
+      end
+  
+      # Displays the result of yielding if the log level is Logger::FATAL or
+      # greater.
+      def fatal
+        logger.add(Logger::FATAL, nil, facility) { yield } if logger && logger.fatal?
+      end
+  
+      private
+  
       # Sets the "facility" value, used for reporting where a log message
       # originates. It defaults to the name of class with the object_id
       # appended.
       def facility
         @facility ||= self.class.name.gsub(/::/, ".").gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase + "[%x]" % object_id
       end
+    end
   end
-end; end
+end

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
+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.
+    # 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
 
-    private
+      # 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
+
+      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,62 +1,64 @@
 require 'io/console'
 
-module Net; module SSH
+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
-
-    def initialize(options = {}); end
-
-    # 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?
+    # 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
+  
+      def initialize(options = {}); end
+  
+      # 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
+        end
+  
+        # 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
+  
+        # 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
-
-      # 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
+  
+      # 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
-
-      # 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
 
-    # 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

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

@@ -3,121 +3,122 @@ 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
+      # 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
 
-    # The command line template
-    attr_reader :command_line_template
+        # The command line for the session
+        attr_reader :command_line
 
-    # The command line for the session
-    attr_reader :command_line
+        # Timeout in seconds in open, defaults to 60
+        attr_accessor :timeout
 
-    # Timeout in seconds in open, defaults to 60
-    attr_accessor :timeout
-
-    # 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
+        # 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
 
-    # 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"
+        # 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+")
+            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
-        when '%'
-          '%'
-        else
-          raise ArgumentError, "unknown key: #{$1}"
-        end
-      }
-      begin
-        io = IO.popen(command_line, "r+")
-        begin
-          if result = IO.select([io], nil, [io], @timeout)
-            if result.last.any? || io.eof?
-              raise "command failed"
+          @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)
+              sysread(size)
             end
           else
-            raise "command timed out"
-          end
-        rescue
-          close_on_error(io)
-          raise
-        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)
-        end
+            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)
-          sysread(size)
-        end
-      else
-        def io.send(data, flag)
-          begin
-            result = write_nonblock(data)
-          rescue IO::WaitWritable, Errno::EINTR
-            IO.select(nil, [self])
-            retry
+            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
           end
-          result
+          io
         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
+        def close_on_error(io)
+          Process.kill('TERM', io.pid)
+          Thread.new { io.close }
         end
       end
-      io
-    end
-
-    def close_on_error(io)
-      Process.kill('TERM', io.pid)
-      Thread.new { io.close }
     end
-
   end
-
-end; end; end
+end