net-ssh 2.6.8 → 2.7.0

data/CHANGES.txt

@@ -1,4 +1,13 @@
 
+
+=== 2.7.0 / 11 Sep 2013
+
+* Fix for 'Could not parse PKey: no start line' error on private keys with passphrases (issue #101) [metametaclass]
+* Automatically forward environment variables defined in OpenSSH config files [fnordfish]
+* Guard against socket.gets being nil in Net::SSH::Proxy::HTTP [krishicks]
+* Implemented experimental keepalive feature [noric]
+
+
 === 2.6.8 / 6 Jul 2013
 
 * Added support for host wildcard substitution [GabKlein]

data/lib/net/ssh.rb

@@ -62,12 +62,13 @@ module Net
     # Net::SSH.start for a description of each option.
     VALID_OPTIONS = [
       :auth_methods, :bind_address, :compression, :compression_level, :config,
-      :encryption, :forward_agent, :hmac, :host_key, :kex, :keys, :key_data,
+      :encryption, :forward_agent, :hmac, :host_key,
+      :keepalive, :keepalive_interval, :kex, :keys, :key_data,
       :languages, :logger, :paranoid, :password, :port, :proxy,
       :rekey_blocks_limit,:rekey_limit, :rekey_packet_limit, :timeout, :verbose,
       :global_known_hosts_file, :user_known_hosts_file, :host_key_alias,
       :host_name, :user, :properties, :passphrase, :keys_only, :max_pkt_size,
-      :max_win_size
+      :max_win_size, :send_env
     ]
 
     # The standard means of starting a new SSH connection. When used with a
@@ -124,6 +125,11 @@ module Net
     #   specified in an SSH configuration file. It lets you specify an
     #   "alias", similarly to adding an entry in /etc/hosts but without needing
     #   to modify /etc/hosts.
+    #   :keepalive => set to +true+ to send a keepalive packet to the SSH server
+    #   when there's no traffic between the SSH server and Net::SSH client for
+    #   the keepalive_interval seconds. Defaults to +false+.
+    #   :keepalive_interval => the interval seconds for keepalive.
+    #   Defaults to +300+ seconds.
     # * :kex => the key exchange algorithm (or algorithms) to use
     # * :keys => an array of file names of private keys to use for publickey
     #   and hostbased authentication
@@ -151,6 +157,8 @@ module Net
     # * :rekey_blocks_limit => the max number of blocks to process before rekeying
     # * :rekey_limit => the max number of bytes to process before rekeying
     # * :rekey_packet_limit => the max number of packets to process before rekeying
+    # * :send_env => an array of local environment variable names to export to the
+    #   remote environment. Names may be given as String or Regexp.
     # * :timeout => how long to wait for the initial connection to be made
     # * :user => the user name to log in as; this overrides the +user+
     #   parameter, and is primarily only useful when provided via an SSH

data/lib/net/ssh/authentication/key_manager.rb

@@ -229,6 +229,9 @@ module Net
               else
                 identity
               end
+            rescue ArgumentError => e
+              process_identity_loading_error(identity, e)
+              nil
             rescue Exception => e
               process_identity_loading_error(identity, e)
               nil

data/lib/net/ssh/config.rb

@@ -176,6 +176,9 @@ module Net; module SSH
             hash[:user] = value
           when 'userknownhostsfile'
             hash[:user_known_hosts_file] = value
+          when 'sendenv'
+            multi_send_env = value.to_s.split(/\s+/)
+            hash[:send_env] = multi_send_env.map { |e| Regexp.new pattern2regex(e).source, false }
           end
           hash
         end

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

@@ -510,6 +510,7 @@ module Net; module SSH; module Connection
         @remote_window_size = @remote_maximum_window_size = max_window
         @remote_maximum_packet_size = max_packet
         connection.forward.agent(self) if connection.options[:forward_agent] && type == "session"
+        forward_local_env(connection.options[:send_env]) if connection.options[:send_env]
         @on_confirm_open.call(self) if @on_confirm_open
       end
 
@@ -625,6 +626,25 @@ module Net; module SSH; module Connection
           @local_maximum_window_size += 0x20000
         end
       end
+
+      # Gets an +Array+ of local environment variables in the remote process'
+      # environment.
+      # A variable name can either be described by a +Regexp+ or +String+.
+      #
+      #   channel.forward_local_env [/^GIT_.*$/, "LANG"]
+      def forward_local_env(env_variable_patterns)
+        Array(env_variable_patterns).each do |env_variable_pattern|
+          matched_variables = ENV.find_all do |env_name, _|
+            case env_variable_pattern
+            when Regexp then env_name =~ env_variable_pattern
+            when String then env_name == env_variable_pattern
+            end
+          end
+          matched_variables.each do |env_name, env_value|
+            self.env(env_name, env_value)
+          end
+        end
+      end
   end
 
 end; end; end

data/lib/net/ssh/connection/session.rb

@@ -25,6 +25,9 @@ module Net; module SSH; module Connection
   class Session
     include Constants, Loggable
 
+    # Default IO.select timeout threshold
+    DEFAULT_IO_SELECT_TIMEOUT = 300
+
     # The underlying transport layer abstraction (see Net::SSH::Transport::Session).
     attr_reader :transport
 
@@ -75,6 +78,8 @@ module Net; module SSH; module Connection
 
       @max_pkt_size = (options.has_key?(:max_pkt_size) ? options[:max_pkt_size] : 0x8000)
       @max_win_size = (options.has_key?(:max_win_size) ? options[:max_win_size] : 0x20000)
+
+      @last_keepalive_sent_at = nil
     end
 
     # Retrieves a custom property from this instance. This can be used to
@@ -201,7 +206,7 @@ module Net; module SSH; module Connection
 
       r = listeners.keys
       w = r.select { |w2| w2.respond_to?(:pending_write?) && w2.pending_write? }
-      readers, writers, = Net::SSH::Compat.io_select(r, w, nil, wait)
+      readers, writers, = Net::SSH::Compat.io_select(r, w, nil, io_select_wait(wait))
 
       postprocess(readers, writers)
     end
@@ -239,6 +244,7 @@ module Net; module SSH; module Connection
         writer.send_pending
       end
 
+      send_keepalive_as_needed(readers, writers)
       transport.rekey_as_needed
 
       return true
@@ -590,6 +596,31 @@ module Net; module SSH; module Connection
         channels[packet[:local_id]].do_failure
       end
 
+      def io_select_wait(wait)
+        return wait if wait
+        return wait unless options[:keepalive]
+        keepalive_interval
+      end
+
+      def keepalive_interval
+        options[:keepalive_interval] || DEFAULT_IO_SELECT_TIMEOUT
+      end
+
+      def should_send_keepalive?
+        return false unless options[:keepalive]
+        return true unless @last_keepalive_sent_at
+        Time.now - @last_keepalive_sent_at >= keepalive_interval
+      end
+
+      def send_keepalive_as_needed(readers, writers)
+        return unless readers.nil? && writers.nil?
+        return unless should_send_keepalive?
+        info { "sending keepalive" }
+        msg = Net::SSH::Buffer.from(:byte, Packet::IGNORE, :string, "keepalive")
+        send_message(msg)
+        @last_keepalive_sent_at = Time.now
+      end
+
       MAP = Constants.constants.inject({}) do |memo, name|
         value = const_get(name)
         next unless Integer === value

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

@@ -73,7 +73,7 @@ module Net; module SSH; module Proxy
         version, code, reason = socket.gets.chomp.split(/ /, 3)
         headers = {}
 
-        while (line = socket.gets.chomp) != ""
+        while (line = socket.gets) && (line.chomp! != "")
           name, value = line.split(/:/, 2)
           headers[name.strip] = value.strip
         end

data/lib/net/ssh/version.rb

@@ -48,10 +48,10 @@ module Net; module SSH
     MAJOR = 2
 
     # The minor component of this version of the Net::SSH library
-    MINOR = 6
+    MINOR = 7
 
     # The tiny component of this version of the Net::SSH library
-    TINY  = 8
+    TINY  = 0
 
     # The current version of the Net::SSH library as a Version instance
     CURRENT = new(MAJOR, MINOR, TINY)

data/net-ssh.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "net-ssh"
-  s.version = "2.6.8"
+  s.version = "2.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jamis Buck", "Delano Mandelbaum"]
-  s.date = "2013-07-06"
+  s.date = "2013-09-11"
   s.description = "Net::SSH: a pure-Ruby implementation of the SSH2 client protocol. It allows you to write programs that invoke and interact with processes on remote servers, via SSH2."
   s.email = "net-ssh@solutious.com"
   s.extra_rdoc_files = [
@@ -126,12 +126,14 @@ Gem::Specification.new do |s|
     "test/configs/multihost",
     "test/configs/nohost",
     "test/configs/numeric_host",
+    "test/configs/send_env",
     "test/configs/substitutes",
     "test/configs/wild_cards",
     "test/connection/test_channel.rb",
     "test/connection/test_session.rb",
     "test/known_hosts/github",
     "test/manual/test_forward.rb",
+    "test/start/test_options.rb",
     "test/start/test_transport.rb",
     "test/test_all.rb",
     "test/test_buffer.rb",

data/test/configs/send_env

@@ -0,0 +1,2 @@
+Host 1234
+	SendEnv GIT_* LANG LC_*

data/test/connection/test_session.rb

@@ -363,6 +363,44 @@ module Connection
       session.process
     end
 
+    def test_process_should_call_enqueue_message_if_io_select_timed_out
+      timeout = Net::SSH::Connection::Session::DEFAULT_IO_SELECT_TIMEOUT
+      options = { :keepalive => true }
+      expected_packet = P(:byte, Net::SSH::Packet::IGNORE, :string, "keepalive")
+      IO.stubs(:select).with([socket],[],nil,timeout).returns(nil)
+      transport.expects(:enqueue_message).with{ |msg| msg.content == expected_packet.content  }
+      session(options).process
+    end
+
+    def test_process_should_not_call_enqueue_message_unless_io_select_timed_out
+      timeout = Net::SSH::Connection::Session::DEFAULT_IO_SELECT_TIMEOUT
+      options = { :keepalive => true }
+      IO.stubs(:select).with([socket],[],nil,timeout).returns([[],[],[]])
+      transport.expects(:enqueue_message).never
+      session(options).process
+    end
+
+    def test_process_should_not_call_enqueue_message_unless_keepalive_interval_not_go_on
+      timeout = 10
+      options = { :keepalive => true, :keepalive_interval => timeout }
+      Time.stubs(:now).returns(Time.at(0), Time.at(9), Time.at(timeout))
+      IO.stubs(:select).with([socket],[],nil,timeout).returns(nil)
+      transport.expects(:enqueue_message).times(2)
+      3.times { session(options).process }
+    end
+
+    def test_process_should_call_io_select_with_nil_as_last_arg_if_keepalive_disabled
+      IO.expects(:select).with([socket],[],nil,nil).returns([[],[],[]])
+      session.process
+    end
+
+    def test_process_should_call_io_select_with_interval_as_last_arg_if_keepalive_interval_passed
+      timeout = 10
+      options = { :keepalive => true, :keepalive_interval => timeout }
+      IO.expects(:select).with([socket],[],nil,timeout).returns([[],[],[]])
+      session(options).process
+    end
+
     def test_loop_should_call_process_until_process_returns_false
       IO.stubs(:select).with([socket],[],nil,nil).returns([[],[],[]])
       session.expects(:process).with(nil).times(4).returns(true,true,true,false).yields

data/test/start/test_options.rb

@@ -0,0 +1,36 @@
+require 'common'
+require 'net/ssh'
+
+module NetSSH
+  class TestStartOptions < Test::Unit::TestCase
+    def setup
+      authentication_session = mock('authentication_session')
+      authentication_session.stubs(:authenticate).returns(true)
+      Net::SSH::Authentication::Session.stubs(:new).returns(authentication_session)
+      Net::SSH::Transport::Session.stubs(:new).returns(mock('transport_session'))
+      Net::SSH::Connection::Session.stubs(:new).returns(mock('connection_session'))
+    end
+
+    def test_start_should_accept_keepalive_option
+      assert_nothing_raised do
+        options = { :keepalive => true }
+        Net::SSH.start('localhost', 'testuser', options)
+      end
+    end
+
+    def test_start_should_accept_keepalive_interval_option
+      assert_nothing_raised do
+        options = { :keepalive_interval => 10 }
+        Net::SSH.start('localhost', 'testuser', options)
+      end
+    end
+
+    def test_start_should_accept_send_env_option
+      assert_nothing_raised do
+        options = { :send_env => [ /^LC_.*$/, "LANG" ] }
+        Net::SSH.start('localhost', 'testuser', options)
+      end
+    end
+  end
+end
+

data/test/test_config.rb

@@ -86,7 +86,8 @@ class TestConfig < Test::Unit::TestCase
       'passwordauthentication'  => true,
       'port'                    => 1234,
       'pubkeyauthentication'    => true,
-      'rekeylimit'              => 1024
+      'rekeylimit'              => 1024,
+      'sendenv'                 => "LC_*"
     }
 
     net_ssh = Net::SSH::Config.translate(open_ssh)
@@ -103,6 +104,7 @@ class TestConfig < Test::Unit::TestCase
     assert_equal 1234,      net_ssh[:port]
     assert_equal 1024,      net_ssh[:rekey_limit]
     assert_equal "127.0.0.1", net_ssh[:bind_address]
+    assert_equal [/^LC_.*$/], net_ssh[:send_env]
   end
   
   def test_load_with_plus_sign_hosts
@@ -134,7 +136,13 @@ class TestConfig < Test::Unit::TestCase
     net_ssh = Net::SSH::Config.translate(config)
     assert_equal 'prefix.1234.sufix', net_ssh[:host_name]
   end
-  
+
+  def test_load_with_send_env
+    config = Net::SSH::Config.load(config(:send_env), "1234")
+    net_ssh = Net::SSH::Config.translate(config)
+    assert_equal [/^GIT_.*$/, /^LANG$/, /^LC_.*$/], net_ssh[:send_env]
+  end
+
   private
 
     def config(name)

data/test/transport/kex/test_diffie_hellman_group_exchange_sha256.rb

@@ -1,5 +1,6 @@
 require 'common'
 require 'net/ssh/transport/kex/diffie_hellman_group_exchange_sha1'
+require 'transport/kex/test_diffie_hellman_group_exchange_sha1'
 
 module Transport; module Kex
 

data/test/transport/kex/test_ecdh_sha2_nistp384.rb

@@ -3,6 +3,7 @@ require 'openssl'
 unless defined?(OpenSSL::PKey::EC)
   puts "Skipping tests for ecdh-sha2-nistp384 key exchange"
 else
+  require 'transport/kex/test_ecdh_sha2_nistp256'
   module Transport; module Kex
     class TestEcdhSHA2NistP384 < TestEcdhSHA2NistP256
 

data/test/transport/kex/test_ecdh_sha2_nistp521.rb

@@ -3,6 +3,7 @@ require 'openssl'
 unless defined?(OpenSSL::PKey::EC)
   puts "Skipping tests for ecdh-sha2-nistp521 key exchange"
 else
+  require 'transport/kex/test_ecdh_sha2_nistp256'
   module Transport; module Kex
     class TestEcdhSHA2NistP521 < TestEcdhSHA2NistP256
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: net-ssh
 version: !ruby/object:Gem::Version
-  version: 2.6.8
+  version: 2.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-06 00:00:00.000000000 Z
+date: 2013-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -163,12 +163,14 @@ files:
 - test/configs/multihost
 - test/configs/nohost
 - test/configs/numeric_host
+- test/configs/send_env
 - test/configs/substitutes
 - test/configs/wild_cards
 - test/connection/test_channel.rb
 - test/connection/test_session.rb
 - test/known_hosts/github
 - test/manual/test_forward.rb
+- test/start/test_options.rb
 - test/start/test_transport.rb
 - test/test_all.rb
 - test/test_buffer.rb