net-ssh-backports 6.3.0.backports

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

@@ -0,0 +1,33 @@
+module Net
+  module SSH
+    module Connection
+      # Definitions of constants that are specific to the connection layer of the
+      # SSH protocol.
+      module Constants
+        #--
+        # Connection protocol generic messages
+        #++
+
+        GLOBAL_REQUEST            = 80
+        REQUEST_SUCCESS           = 81
+        REQUEST_FAILURE           = 82
+
+        #--
+        # Channel related messages
+        #++
+
+        CHANNEL_OPEN              = 90
+        CHANNEL_OPEN_CONFIRMATION = 91
+        CHANNEL_OPEN_FAILURE      = 92
+        CHANNEL_WINDOW_ADJUST     = 93
+        CHANNEL_DATA              = 94
+        CHANNEL_EXTENDED_DATA     = 95
+        CHANNEL_EOF               = 96
+        CHANNEL_CLOSE             = 97
+        CHANNEL_REQUEST           = 98
+        CHANNEL_SUCCESS           = 99
+        CHANNEL_FAILURE           = 100
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'net/ssh/loggable'
+
+module Net
+  module SSH
+    module Connection
+      # EventLoop can be shared across multiple sessions
+      #
+      # one issue is with blocks passed to loop, etc.
+      # they should get current session as parameter, but in
+      # case you're using multiple sessions in an event loop it doesnt makes sense
+      # and we don't pass session.
+      class EventLoop
+        include Loggable
+
+        def initialize(logger=nil)
+          self.logger = logger
+          @sessions = []
+        end
+
+        def register(session)
+          @sessions << session
+        end
+
+        # process until timeout
+        # if a block is given a session will be removed from loop
+        # if block returns false for that session
+        def process(wait = nil, &block)
+          return false unless ev_preprocess(&block)
+
+          ev_select_and_postprocess(wait)
+        end
+
+        # process the event loop but only for the sepcified session
+        def process_only(session, wait = nil)
+          orig_sessions = @sessions
+          begin
+            @sessions = [session]
+            return false unless ev_preprocess
+
+            ev_select_and_postprocess(wait)
+          ensure
+            @sessions = orig_sessions
+          end
+        end
+
+        # Call preprocess on each session. If block given and that
+        # block retuns false then we exit the processing
+        def ev_preprocess(&block)
+          return false if block_given? && !yield(self)
+
+          @sessions.each(&:ev_preprocess)
+          return false if block_given? && !yield(self)
+
+          return true
+        end
+
+        def ev_select_and_postprocess(wait)
+          owners = {}
+          r = []
+          w = []
+          minwait = nil
+          @sessions.each do |session|
+            sr,sw,actwait = session.ev_do_calculate_rw_wait(wait)
+            minwait = actwait if actwait && (minwait.nil? || actwait < minwait)
+            r.push(*sr)
+            w.push(*sw)
+            sr.each { |ri| owners[ri] = session }
+            sw.each { |wi| owners[wi] = session }
+          end
+
+          readers, writers, = IO.select(r, w, nil, minwait)
+
+          fired_sessions = {}
+
+          if readers
+            readers.each do |reader|
+              session = owners[reader]
+              (fired_sessions[session] ||= { r: [],w: [] })[:r] << reader
+            end
+          end
+          if writers
+            writers.each do |writer|
+              session = owners[writer]
+              (fired_sessions[session] ||= { r: [],w: [] })[:w] << writer
+            end
+          end
+
+          fired_sessions.each do |s,rw|
+            s.ev_do_handle_events(rw[:r],rw[:w])
+          end
+
+          @sessions.each { |s| s.ev_do_postprocess(fired_sessions.key?(s)) }
+          true
+        end
+      end
+
+      # optimized version for a single session
+      class SingleSessionEventLoop < EventLoop
+        # Compatibility for original single session event loops:
+        # we call block with session as argument
+        def ev_preprocess(&block)
+          return false if block_given? && !yield(@sessions.first)
+
+          @sessions.each(&:ev_preprocess)
+          return false if block_given? && !yield(@sessions.first)
+
+          return true
+        end
+
+        def ev_select_and_postprocess(wait)
+          raise "Only one session expected" unless @sessions.count == 1
+
+          session = @sessions.first
+          sr,sw,actwait = session.ev_do_calculate_rw_wait(wait)
+          readers, writers, = IO.select(sr, sw, nil, actwait)
+
+          session.ev_do_handle_events(readers,writers)
+          session.ev_do_postprocess(!((readers.nil? || readers.empty?) && (writers.nil? || writers.empty?)))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require 'net/ssh/loggable'
+module Net
+  module SSH
+    module Connection
+      class Keepalive
+        include Loggable
+
+        def initialize(session)
+          @last_keepalive_sent_at = nil
+          @unresponded_keepalive_count = 0
+          @session = session
+          self.logger = session.logger
+        end
+
+        def options
+          @session.options
+        end
+
+        def enabled?
+          options[:keepalive]
+        end
+
+        def interval
+          options[:keepalive_interval] || Session::DEFAULT_IO_SELECT_TIMEOUT
+        end
+
+        def should_send?
+          return false unless enabled?
+          return true unless @last_keepalive_sent_at
+
+          Time.now - @last_keepalive_sent_at >= interval
+        end
+
+        def keepalive_maxcount
+          (options[:keepalive_maxcount] || 3).to_i
+        end
+
+        def send_as_needed(was_events)
+          return if was_events
+          return unless should_send?
+
+          info { "sending keepalive #{@unresponded_keepalive_count}" }
+
+          @unresponded_keepalive_count += 1
+          @session.send_global_request("keepalive@openssh.com") { |success, response|
+            debug { "keepalive response successful. Missed #{@unresponded_keepalive_count - 1} keepalives" }
+            @unresponded_keepalive_count = 0
+          }
+          @last_keepalive_sent_at = Time.now
+          if keepalive_maxcount > 0 && @unresponded_keepalive_count > keepalive_maxcount
+            error { "Timeout, server #{@session.host} not responding. Missed #{@unresponded_keepalive_count - 1} timeouts." }
+            @unresponded_keepalive_count = 0
+            raise Net::SSH::Timeout, "Timeout, server #{@session.host} not responding."
+          end
+        end
+      end
+    end
+  end
+end