net-ssh 4.0.0.beta3 → 4.0.0.beta4

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

@@ -232,7 +232,7 @@ module Net
                 identity
               end
 
-            rescue OpenSSL::PKey::RSAError, OpenSSL::PKey::DSAError, OpenSSL::PKey::ECError, ArgumentError => e
+            rescue OpenSSL::PKey::RSAError, OpenSSL::PKey::DSAError, OpenSSL::PKey::ECError, OpenSSL::PKey::PKeyError, ArgumentError => e
               if ignore_decryption_errors
                 identity
               else

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

@@ -13,7 +13,9 @@ else
   # For now map DL to Fiddler versus updating all the code below
   module DL
     CPtr ||= Fiddle::Pointer
-    RUBY_FREE ||= Fiddle::RUBY_FREE
+    if RUBY_PLATFORM != "java"
+      RUBY_FREE ||= Fiddle::RUBY_FREE
+    end
   end
 end
 
@@ -36,7 +38,7 @@ module Net; module SSH; module Authentication
 
     # The definition of the Windows methods and data structures used in
     # communicating with the pageant process.
-    module Win
+    module Win # rubocop:disable Metrics/ModuleLength
       # Compatibility on initialization
       if RUBY_VERSION < "1.9"
         extend DL::Importable
@@ -59,6 +61,11 @@ module Net; module SSH; module Authentication
         SIZEOF_DWORD = Fiddle::SIZEOF_LONG
       end
 
+      if RUBY_ENGINE=="jruby"
+        typealias("HANDLE", "void *")         # From winnt.h
+        typealias("PHANDLE", "void *")         # From winnt.h
+        typealias("ULONG_PTR", "unsigned long*")
+      end
       typealias("LPCTSTR", "char *")         # From winnt.h
       typealias("LPVOID", "void *")          # From winnt.h
       typealias("LPCVOID", "const void *")   # From windef.h
@@ -77,16 +84,22 @@ module Net; module SSH; module Authentication
 
       SMTO_NORMAL = 0   # From winuser.h
 
+      SUFFIX = if RUBY_ENGINE == "jruby"
+                 "A"
+               else
+                 ""
+               end
+
       # args: lpClassName, lpWindowName
-      extern 'HWND FindWindow(LPCTSTR, LPCTSTR)'
+      extern "HWND FindWindow#{SUFFIX}(LPCTSTR, LPCTSTR)"
 
       # args: none
       extern 'DWORD GetCurrentThreadId()'
 
       # args: hFile, (ignored), flProtect, dwMaximumSizeHigh,
       #           dwMaximumSizeLow, lpName
-      extern 'HANDLE CreateFileMapping(HANDLE, void *, DWORD, ' +
-        'DWORD, DWORD, LPCTSTR)'
+      extern "HANDLE CreateFileMapping#{SUFFIX}(HANDLE, void *, DWORD, ' +
+        'DWORD, DWORD, LPCTSTR)"
 
       # args: hFileMappingObject, dwDesiredAccess, dwFileOffsetHigh,
       #           dwfileOffsetLow, dwNumberOfBytesToMap
@@ -99,8 +112,8 @@ module Net; module SSH; module Authentication
       extern 'BOOL CloseHandle(HANDLE)'
 
       # args: hWnd, Msg, wParam, lParam, fuFlags, uTimeout, lpdwResult
-      extern 'LRESULT SendMessageTimeout(HWND, UINT, WPARAM, LPARAM, ' +
-        'UINT, UINT, PDWORD_PTR)'
+      extern "LRESULT SendMessageTimeout#{SUFFIX}(HWND, UINT, WPARAM, LPARAM, ' +
+        'UINT, UINT, PDWORD_PTR)"
 
       # args: none
       extern 'DWORD GetLastError()'
@@ -154,7 +167,11 @@ module Net; module SSH; module Authentication
                                     'LPVOID Dacl']
 
       # The COPYDATASTRUCT is used to send WM_COPYDATA messages
-      COPYDATASTRUCT = struct ['uintptr_t dwData', 'DWORD cbData', 'LPVOID lpData']
+      COPYDATASTRUCT = if RUBY_ENGINE == "jruby"
+                         struct ['ULONG_PTR dwData', 'DWORD cbData', 'LPVOID lpData']
+                       else
+                         struct ['uintptr_t dwData', 'DWORD cbData', 'LPVOID lpData']
+                       end
 
       # Compatibility for security attribute retrieval.
       if RUBY_VERSION < "1.9"
@@ -189,6 +206,30 @@ module Net; module SSH; module Authentication
         def self.set_ptr_data(ptr, data)
           ptr[0] = data
         end
+      elsif RUBY_ENGINE == "jruby"
+        %w(FindWindow CreateFileMapping SendMessageTimeout).each do |name|
+          alias_method name, name+"A"
+          module_function name
+        end
+        # :nodoc:
+        module LibC
+          extend FFI::Library
+          ffi_lib FFI::Library::LIBC
+          attach_function :malloc, [:size_t], :pointer
+          attach_function :free, [:pointer], :void
+        end
+
+        def self.malloc_ptr(size)
+          Fiddle::Pointer.new(LibC.malloc(size), size, LibC.method(:free))
+        end
+
+        def self.get_ptr(ptr)
+          return data.address
+        end
+
+        def self.set_ptr_data(ptr, data)
+          ptr.write_string_length(data, data.size)
+        end
       else
         def self.malloc_ptr(size)
           return DL::CPtr.malloc(size, DL::RUBY_FREE)
@@ -211,12 +252,12 @@ module Net; module SSH; module Authentication
           Win.InitializeSecurityDescriptor(psd_information,
                                            Win::REVISION))
         raise_error_if_zero(
-          Win.SetSecurityDescriptorOwner(psd_information, user.SID,
+          Win.SetSecurityDescriptorOwner(psd_information, get_sid_ptr(user),
                                          0))
         raise_error_if_zero(
           Win.IsValidSecurityDescriptor(psd_information))
 
-        sa = Win::SECURITY_ATTRIBUTES.new(malloc_ptr(Win::SECURITY_ATTRIBUTES.size))
+        sa = Win::SECURITY_ATTRIBUTES.new(to_struct_ptr(malloc_ptr(Win::SECURITY_ATTRIBUTES.size)))
         sa.nLength = Win::SECURITY_ATTRIBUTES.size
         sa.lpSecurityDescriptor = psd_information.to_i
         sa.bInheritHandle = 1
@@ -224,6 +265,65 @@ module Net; module SSH; module Authentication
         return sa
       end
 
+      if RUBY_ENGINE == "jruby"
+        def self.ptr_to_s(ptr, size)
+          ret = ptr.to_s(size)
+          ret << "\x00" while ret.size < size
+          ret
+        end
+
+        def self.ptr_to_handle(phandle)
+          phandle.ptr
+        end
+
+        def self.ptr_to_dword(ptr)
+          first = ptr.ptr.to_i
+          second = ptr_to_s(ptr,Win::SIZEOF_DWORD).unpack('L')[0]
+          raise "Error" unless first == second
+          first
+        end
+
+        def self.to_token_user(ptoken_information)
+           TOKEN_USER.new(ptoken_information.to_ptr)
+        end
+
+        def self.to_struct_ptr(ptr)
+          ptr.to_ptr
+        end
+
+        def self.get_sid(user)
+          ptr_to_s(user.to_ptr.ptr,Win::SIZEOF_DWORD).unpack('L')[0]
+        end
+
+        def self.get_sid_ptr(user)
+          user.to_ptr.ptr
+        end
+      else
+        def self.get_sid(user)
+          user.SID
+        end
+
+        def self.ptr_to_handle(phandle)
+          phandle.ptr.to_i
+        end
+
+        def self.to_struct_ptr(ptr)
+          ptr
+        end
+
+        def self.ptr_to_dword(ptr)
+          ptr.to_s(Win::SIZEOF_DWORD).unpack('L')[0]
+        end
+
+        def self.to_token_user(ptoken_information)
+          TOKEN_USER.new(ptoken_information)
+        end
+
+        def self.get_sid_ptr(user)
+          user.SID
+        end
+      end
+
       def self.get_current_user
         token_handle = open_process_token(Win.GetCurrentProcess,
                                           Win::TOKEN_QUERY)
@@ -238,8 +338,7 @@ module Net; module SSH; module Authentication
         raise_error_if_zero(
           Win.OpenProcessToken(process_handle, desired_access,
                                ptoken_handle))
-        token_handle = ptoken_handle.ptr.to_i
-
+        token_handle = ptr_to_handle(ptoken_handle)
         return token_handle
       end
 
@@ -254,7 +353,7 @@ module Net; module SSH; module Authentication
         Win.GetTokenInformation(token_handle,
                                 token_information_class,
                                 Win::NULL, 0, preturn_length)
-        ptoken_information = malloc_ptr(preturn_length.to_s(Win::SIZEOF_DWORD).unpack('L')[0])
+        ptoken_information = malloc_ptr(ptr_to_dword(preturn_length))
 
         # This call is going to write the requested information to
         # the memory location referenced by token_information.
@@ -265,7 +364,7 @@ module Net; module SSH; module Authentication
                                   ptoken_information.size,
                                   preturn_length))
 
-        return TOKEN_USER.new(ptoken_information)
+        return to_token_user(ptoken_information)
       end
 
       def self.raise_error_if_zero(result)
@@ -288,10 +387,8 @@ module Net; module SSH; module Authentication
 
       private_class_method :new
 
-      # The factory method for creating a new Socket instance. The location
-      # parameter is ignored, and is only needed for compatibility with
-      # the general Socket interface.
-      def self.open(location=nil)
+      # The factory method for creating a new Socket instance.
+      def self.open
         new
       end
 
@@ -300,7 +397,7 @@ module Net; module SSH; module Authentication
       def initialize
         @win = Win.FindWindow("Pageant", "Pageant")
 
-        if @win == 0
+        if @win.to_i == 0
           raise Net::SSH::Exception,
             "pageant process not running"
         end

data/lib/net/ssh/buffered_io.rb

@@ -66,6 +66,9 @@ module Net; module SSH
       debug { "read #{data.length} bytes" }
       input.append(data)
       return data.length
+    rescue EOFError => e
+      @input_errors << e
+      return 0
     end
 
     # Read up to +length+ bytes from the input buffer. If +length+ is nil,
@@ -143,21 +146,23 @@ module Net; module SSH
       # Module#include to add this module.
       def initialize_buffered_io
         @input = Net::SSH::Buffer.new
+        @input_errors = []
         @output = Net::SSH::Buffer.new
+        @output_errors = []
       end
   end
 
 
-  
+
   # Fixes for two issues by Miklós Fazekas:
   #
-  #   * if client closes a forwarded connection, but the server is 
+  #   * if client closes a forwarded connection, but the server is
   #     reading, net-ssh terminates with IOError socket closed.
-  #   * if client force closes (RST) a forwarded connection, but 
+  #   * if client force closes (RST) a forwarded connection, but
   #     server is reading, net-ssh terminates with [an exception]
   #
-  # See: 
-  # 
+  # See:
+  #
   #    http://net-ssh.lighthouseapp.com/projects/36253/tickets/7
   #    http://github.com/net-ssh/net-ssh/tree/portfwfix
   #
@@ -168,24 +173,24 @@ module Net; module SSH
       rescue Errno::ECONNRESET => e
         debug { "connection was reset => shallowing exception:#{e}" }
         return 0
-      rescue IOError => e                                 
-        if e.message =~ /closed/ then 
+      rescue IOError => e
+        if e.message =~ /closed/ then
           debug { "connection was reset => shallowing exception:#{e}" }
           return 0
         else
           raise
-        end 
+        end
       end
     end
-    
+
     def send_pending
       begin
-        super                                                          
+        super
       rescue Errno::ECONNRESET => e
         debug { "connection was reset => shallowing exception:#{e}" }
         return 0
       rescue IOError => e
-        if e.message =~ /closed/ then 
+        if e.message =~ /closed/ then
           debug { "connection was reset => shallowing exception:#{e}" }
           return 0
         else
@@ -194,5 +199,5 @@ module Net; module SSH
       end
     end
   end
-  
+
 end; end

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

@@ -234,7 +234,7 @@ module Net; module SSH; module Connection
     # Called by event loop to process available data before going to
     # event multiplexing
     def ev_preprocess(&block)
-      dispatch_incoming_packets
+      dispatch_incoming_packets(raise_disconnect_errors: false)
       each_channel { |id, channel| channel.process unless channel.local_closed? }
     end
 
@@ -335,6 +335,15 @@ module Net; module SSH; module Connection
       channels[local_id] = channel
     end
 
+    class StringWithExitstatus < String
+      def initialize(str, exitstatus)
+        super(str)
+        @exitstatus = exitstatus
+      end
+
+      attr_reader :exitstatus
+    end
+
     # A convenience method for executing a command and interacting with it. If
     # no block is given, all output is printed via $stdout and $stderr. Otherwise,
     # the block is called for each data and extended data packet, with three
@@ -355,11 +364,21 @@ module Net; module SSH; module Connection
     #       puts data
     #     end
     #   end
-    def exec(command, &block)
+    def exec(command, status: nil, &block)
       open_channel do |channel|
         channel.exec(command) do |ch, success|
           raise "could not execute command: #{command.inspect}" unless success
 
+          if status
+            channel.on_request("exit-status") do |ch2,data|
+              status[:exit_code] = data.read_long
+            end
+
+            channel.on_request("exit-signal") do |ch2, data|
+              status[:exit_signal] = data.read_long
+            end
+          end
+
           channel.on_data do |ch2, data|
             if block
               block.call(ch2, :stdout, data)
@@ -384,19 +403,22 @@ module Net; module SSH; module Connection
     # as a single string.
     #
     #   matches = ssh.exec!("grep something /some/files")
-    def exec!(command, &block)
+    #
+    # the returned string has an exitstatus method to query it's exit satus
+    def exec!(command, status: nil, &block)
       block_or_concat = block || Proc.new do |ch, type, data|
         ch[:result] ||= ""
         ch[:result] << data
       end
 
-      channel = exec(command, &block_or_concat)
+      status ||= {}
+      channel = exec(command, status: status, &block_or_concat)
       channel.wait
 
       channel[:result] ||= "" unless block
       channel[:result] &&= channel[:result].force_encoding("UTF-8") unless block
 
-      return channel[:result]
+      StringWithExitstatus.new(channel[:result], status[:exit_code]) if channel[:result]
     end
 
     # Enqueues a message to be sent to the server as soon as the socket is
@@ -509,7 +531,7 @@ module Net; module SSH; module Connection
 
       # Read all pending packets from the connection and dispatch them as
       # appropriate. Returns as soon as there are no more pending packets.
-      def dispatch_incoming_packets
+      def dispatch_incoming_packets(raise_disconnect_errors: true)
         while packet = transport.poll_message
           unless MAP.key?(packet.type)
             raise Net::SSH::Exception, "unexpected response #{packet.type} (#{packet.inspect})"
@@ -519,7 +541,7 @@ module Net; module SSH; module Connection
         end
       rescue
         force_channel_cleanup_on_close if closed?
-        raise
+        raise if raise_disconnect_errors || !$!.is_a?(Net::SSH::Disconnect)
       end
 
       # Returns the next available channel id to be assigned, and increments

data/lib/net/ssh/key_factory.rb

@@ -49,7 +49,7 @@ module Net; module SSH
       # encrypted (requiring a passphrase to use), the user will be
       # prompted to enter their password unless passphrase works. 
       def load_data_private_key(data, passphrase=nil, ask_passphrase=true, filename="", prompt=Prompt.default)
-        key_read, error_class = classify_key(data, filename)
+        key_read, error_classes = classify_key(data, filename)
 
         encrypted_key = data.match(/ENCRYPTED/)
         tries = 0
@@ -58,7 +58,7 @@ module Net; module SSH
         result = 
           begin
             key_read[data, passphrase || 'invalid']
-          rescue error_class
+          rescue *error_classes
             if encrypted_key && ask_passphrase
               tries += 1
               if tries <= 3
@@ -110,18 +110,18 @@ module Net; module SSH
       def classify_key(data, filename)
         if data.match(/-----BEGIN OPENSSH PRIVATE KEY-----/)
           if defined?(Net::SSH::Authentication::ED25519)
-            return ->(key_data, passphrase) { Net::SSH::Authentication::ED25519::PrivKey.read(key_data, passphrase) }, ArgumentError
+            return ->(key_data, passphrase) { Net::SSH::Authentication::ED25519::PrivKey.read(key_data, passphrase) }, [ArgumentError]
           else
             raise OpenSSL::PKey::PKeyError, "OpenSSH keys only supported if ED25519 is available - #{ED25519_LOAD_ERROR}"
           end
         elsif OpenSSL::PKey.respond_to?(:read)
-          return ->(key_data, passphrase) { OpenSSL::PKey.read(key_data, passphrase) }, ArgumentError
+          return ->(key_data, passphrase) { OpenSSL::PKey.read(key_data, passphrase) }, [ArgumentError, OpenSSL::PKey::PKeyError]
         elsif data.match(/-----BEGIN DSA PRIVATE KEY-----/)
-          return ->(key_data, passphrase) { OpenSSL::PKey::DSA.new(key_data, passphrase) }, OpenSSL::PKey::DSAError
+          return ->(key_data, passphrase) { OpenSSL::PKey::DSA.new(key_data, passphrase) }, [OpenSSL::PKey::DSAError]
         elsif data.match(/-----BEGIN RSA PRIVATE KEY-----/)
-          return ->(key_data, passphrase) { OpenSSL::PKey::RSA.new(key_data, passphrase) }, OpenSSL::PKey::RSAError
+          return ->(key_data, passphrase) { OpenSSL::PKey::RSA.new(key_data, passphrase) }, [OpenSSL::PKey::RSAError]
         elsif data.match(/-----BEGIN EC PRIVATE KEY-----/) && defined?(OpenSSL::PKey::EC)
-          return ->(key_data, passphrase) { OpenSSL::PKey::EC.new(key_data, passphrase) }, OpenSSL::PKey::ECError
+          return ->(key_data, passphrase) { OpenSSL::PKey::EC.new(key_data, passphrase) }, [OpenSSL::PKey::ECError]
         elsif data.match(/-----BEGIN (.+) PRIVATE KEY-----/)
           raise OpenSSL::PKey::PKeyError, "not a supported key type '#{$1}'"
         else