net-ssh 0.5.0

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

@@ -0,0 +1,47 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+#
+# This source file is distributed as part of the Net::SSH Secure Shell Client
+# library for Ruby. This file (and the library as a whole) may be used only as
+# allowed by either the BSD license, or the Ruby license (or, by association
+# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
+# distribution for the texts of these licenses.
+# -----------------------------------------------------------------------------
+# net-ssh website : http://net-ssh.rubyforge.org
+# project website: http://rubyforge.org/projects/net-ssh
+# =============================================================================
+#++
+
+module Net
+  module SSH
+    module Connection
+
+      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/driver.rb

@@ -0,0 +1,343 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+#
+# This source file is distributed as part of the Net::SSH Secure Shell Client
+# library for Ruby. This file (and the library as a whole) may be used only as
+# allowed by either the BSD license, or the Ruby license (or, by association
+# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
+# distribution for the texts of these licenses.
+# -----------------------------------------------------------------------------
+# net-ssh website : http://net-ssh.rubyforge.org
+# project website: http://rubyforge.org/projects/net-ssh
+# =============================================================================
+#++
+
+require 'thread'
+require 'net/ssh/connection/constants'
+require 'net/ssh/errors'
+
+module Net
+  module SSH
+    module Connection
+
+      class Driver
+        include Constants
+
+        # A structure for representing global requests, as registered by the
+        # #global_request method.
+        Request = Struct.new( :type, :data, :callback )
+
+        #--
+        # ====================================================================
+        # CONSTRUCTOR
+        # ====================================================================
+        #++
+
+        # Create a new connection driver that communicates over the given
+        # transport session. +log+ is the logger instance to write log messages
+        # to, buffers is a buffer factory, and channels is a factory that can
+        # return new channel instances.
+        def initialize( session, log, buffers, factories )
+          @session = session
+          @log = log
+          @buffers = buffers
+          @factories = factories
+
+          @channel_id_mutex = Mutex.new
+          @next_channel_id = 0
+
+          @channel_map = Hash.new
+          @request_queue = Array.new
+          @channel_open_handlers = Hash.new
+        end
+
+        #--
+        # ====================================================================
+        # CHANNEL MANAGEMENT
+        # ====================================================================
+        #++
+
+        # Open and return a new channel. This returns immediately, before the
+        # server confirms that the channel was opened. When the server sends
+        # the confirmation, the +on_confirm+ callback will be invoked.
+        def open_channel( type, extra_data=nil, &on_confirm )
+          channel = @factories[:open].call( type, extra_data )
+          channel.on_confirm_open &on_confirm
+          @channel_map[ channel.local_id ] = channel
+        end
+
+        # Remove the given channel from the connection.
+        def remove_channel( channel )
+          @channel_map.delete channel.local_id
+        end
+
+        # Returns an array of active channels.
+        def channels
+          @channel_map.values
+        end
+
+        # Add a callback to be invoked when a channel-open request is recieved
+        # for a channel of the given type. The handler-id is returned.
+        def add_channel_open_handler( type, &block )
+          ( @channel_open_handlers[ type ] ||= Array.new ).push block
+          @channel_open_handlers.length
+        end
+
+        # Remove a callback with the given id for channel-open requests of the
+        # given type.
+        def remove_channel_open_handler( type, id )
+          @channel_open_handlers[ type ][ id-1 ] = nil
+        end
+
+        # Return the next available channel id for this connection. This
+        # method is thread-safe.
+        def allocate_channel_id
+          @channel_id_mutex.synchronize do
+            @next_channel_id += 1
+            return @next_channel_id
+          end
+        end
+
+        #--
+        # ====================================================================
+        # CONNECTION PROCESSING
+        # ====================================================================
+        #++
+
+        # Repeated call #process for as long as the given block returns
+        # +true+. If no block is given, then the loop continues until there
+        # are no more open channels on this connection.
+        def loop( &block )
+          block ||= proc { not @channel_map.empty? }
+          process while block.call
+        end
+
+        # Wait for and dispatch a single event.
+        def process
+          type, response = @session.wait_for_message
+
+          unless ( dispatcher = MESSAGES[ type ] )
+            raise Net::SSH::Exception,
+              "Unexpected response type '#{type}', (#{response.inspect})"
+          end
+
+          dispatcher[:method].bind( self ).call( response )
+          self
+        end
+
+        #--
+        # ====================================================================
+        # COMMUNICATION
+        # ====================================================================
+        #++
+
+        # Send a global request packet to the server. This returns immediately.
+        # The given block will be invoked when the server responds.
+        def global_request( type, data=nil, &block )
+          writer = @buffers.writer
+          writer.write_byte GLOBAL_REQUEST
+          writer.write_string type.to_s
+          writer.write_bool true
+          writer.write data.to_s if data
+          @session.send_message writer
+
+          @request_queue.push Request.new( type, data, block )
+          self
+        end
+
+        # A convenience method for sending messages.
+        def send_message( msg )
+          @session.send_message msg
+          self
+        end
+
+        #--
+        # ====================================================================
+        # MESSAGE HANDLERS
+        # ====================================================================
+        #++
+
+        def do_request_success( response )
+          @log.debug "REQUEST_SUCCESS received" if @log.debug?
+          process_request response, true
+        end
+
+        def do_request_failure( response )
+          @log.debug "REQUEST_FAILURE received" if @log.debug?
+          process_request response, false
+        end
+
+        def do_channel_open( response )
+          ch_type = response.read_string
+          @log.debug "CHANNEL_OPEN recieved (#{ch_type})" if @log.debug?
+          handled = false
+
+          sender_channel = response.read_long
+          window_size = response.read_long
+          packet_size = response.read_long
+
+          channel = @factories[:create].call( ch_type, sender_channel,
+                        window_size, packet_size )
+
+          ( @channel_open_handlers[ ch_type ] || [] ).each do |handler|
+            next unless handler
+            handled = true
+            handler.call( self, channel, response )
+          end
+
+          unless handled
+            raise Net::SSH::Exception,
+              "cannot handle request to open a channel of type '#{ch_type}'"
+          end
+
+          @channel_map[channel.local_id] = channel
+
+          writer = @buffers.writer
+          writer.write_byte CHANNEL_OPEN_CONFIRMATION
+          writer.write_long channel.remote_id
+          writer.write_long channel.local_id
+          writer.write_long 0x7FFFFFFF
+          writer.write_long 0x7FFFFFFF
+          @session.send_message writer
+        end
+
+        def do_channel_open_failure( response )
+          local_id = response.read_long
+          reason_code = response.read_long
+          reason = response.read_string
+          language = response.read_string
+
+          @log.debug "CHANNEL_OPEN_FAILURE recieved (#{reason})" if @log.debug?
+
+          channel = @channel_map[ local_id ]
+          @channel_map.delete local_id
+          channel.do_confirm_failed reason_code, reason, language
+        end
+
+        def do_channel_open_confirmation( response )
+          local_id = response.read_long
+          remote_id = response.read_long
+          window_size = response.read_long
+          packet_size = response.read_long
+
+          if @log.debug?
+            @log.debug "CHANNEL_OPEN_CONFIRMATION recieved (#{local_id})"
+          end
+
+          channel = @channel_map[ local_id ]
+          channel.do_confirm_open remote_id, window_size, packet_size
+        end
+
+        def do_channel_window_adjust( response )
+          local_id = response.read_long
+          bytes_to_add = response.read_long
+
+          if @log.debug?
+            @log.debug "CHANNEL_WINDOW_ADJUST recieved " +
+              "(#{local_id}:#{bytes_to_add})"
+          end
+
+          @channel_map[ local_id ].do_window_adjust( bytes_to_add )
+        end
+
+        def do_channel_data( response )
+          local_id = response.read_long
+          data = response.read_string
+
+          if @log.debug?
+            @log.debug "CHANNEL_DATA recieved (#{local_id}:#{data.inspect})"
+          end
+
+          @channel_map[ local_id ].do_data data
+        end
+
+        def do_channel_extended_data( response )
+          local_id = response.read_long
+          data_type = response.read_long
+          data = response.read_string
+
+          if @log.debug?
+            @log.debug "CHANNEL_EXTENDED_DATA recieved " +
+              "(#{local_id}:#{data_type}:#{data.inspect})"
+          end
+
+          @channel_map[ local_id ].do_extended_data data_type, data
+        end
+
+        def do_channel_eof( response )
+          local_id = response.read_long
+          @log.debug "CHANNEL_EOF recieved (#{local_id})" if @log.debug?
+          @channel_map[ local_id ].do_eof
+        end
+
+        def do_channel_close( response )
+          local_id = response.read_long
+          @log.debug "CHANNEL_CLOSE recieved (#{local_id})" if @log.debug?
+          @channel_map[ local_id ].close false
+        end
+
+        def do_channel_request( response )
+          local_id = response.read_long
+          request = response.read_string
+          want_reply = response.read_bool
+          request_data = response.remainder_as_buffer
+
+          if @log.debug?
+            @log.debug "CHANNEL_REQUEST recieved (#{local_id}:#{request})"
+          end
+
+          @channel_map[ local_id ].do_request request, want_reply, request_data
+        end
+
+        def do_channel_success( response )
+          local_id = response.read_long
+          @log.debug "CHANNEL_SUCCESS recieved (#{local_id})" if @log.debug?
+          @channel_map[ local_id ].do_success
+        end
+
+        def do_channel_failure( response )
+          local_id = response.read_long
+          @log.debug "CHANNEL_FAILURE recieved (#{local_id})" if @log.debug?
+          @channel_map[ local_id ].do_failure
+        end
+
+        #--
+        # ====================================================================
+        # INTERNAL STATE MANAGEMENT
+        # ====================================================================
+        private
+        #++
+
+        # Process a response recived from a "global_request".
+        def process_request( response, success )
+          request = @request_queue.shift
+          request.callback.call( success, response ) if request.callback
+        end
+
+        #--
+        # ====================================================================
+        # MESSAGE DISPATCHER SETUP
+        # ====================================================================
+        #++
+
+        MESSAGES = {}
+        [ :request_success, :request_failure, :channel_open,
+          :channel_open_failure, :channel_open_confirmation,
+          :channel_window_adjust, :channel_data, :channel_extended_data,
+          :channel_eof, :channel_close, :channel_request, :channel_success,
+          :channel_failure
+        ].each do |event|
+          constant = Constants.const_get event.to_s.upcase.to_sym
+          MESSAGES[ constant ] = {
+            :name => event,
+            :method => instance_method( "do_#{event}".to_sym )
+          }
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+#--
+# =============================================================================
+# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu)
+# All rights reserved.
+#
+# This source file is distributed as part of the Net::SSH Secure Shell Client
+# library for Ruby. This file (and the library as a whole) may be used only as
+# allowed by either the BSD license, or the Ruby license (or, by association
+# with the Ruby license, the GPL). See the "doc" subdirectory of the Net::SSH
+# distribution for the texts of these licenses.
+# -----------------------------------------------------------------------------
+# net-ssh website : http://net-ssh.rubyforge.org
+# project website: http://rubyforge.org/projects/net-ssh
+# =============================================================================
+#++
+
+module Net
+  module SSH
+    module Connection
+
+      # Register the services that define the "connection" layer of the SSH
+      # protocol.
+      def register_services( container )
+
+        # The :connection namespace contains all of the services in the
+        # connection layer of the SSH protocol.
+        container.namespace_define :connection do |ns|
+
+          # The :channel namespace contains the channel-specific services.
+          ns.namespace_define :channel do |ch|
+
+            # The :open service provides a proc object that may be used to
+            # request that a new channel be opened.
+            ch.open do |c,p|
+              require 'net/ssh/connection/channel'
+              lambda do |type, data|
+                Channel.open( c[:driver],
+                              c[:log_for, p],
+                              c[:transport][:buffers],
+                              type, data )
+              end
+            end
+
+            # The :create service provides a proc object that may be used to
+            # create new channels, without sending a request to the server.
+            ch.create do |c,p|
+              require 'net/ssh/connection/channel'
+              lambda do |type,rid,wsize,psize|
+                Channel.create( c[:driver],
+                                c[:log_for, p],
+                                c[:transport][:buffers],
+                                type, rid, wsize, psize )
+              end
+            end
+          end
+
+          # The :driver service manages the connection layer.
+          ns.driver do |c,p|
+            require 'net/ssh/connection/driver'
+            Driver.new( c[:transport][:session],
+                        c[:log_for, p],
+                        c[:transport][:buffers],
+                        :open => c[:channel][:open],
+                        :create => c[:channel][:create] )
+          end
+        end
+      end
+      module_function :register_services
+
+    end
+  end
+end