hrr_rb_ssh 0.3.0.pre1 → 0.4.2

data/lib/hrr_rb_ssh/authentication/method/publickey/algorithm/signature_blob.rb

@@ -9,10 +9,8 @@ module HrrRbSsh
     class Method
       class Publickey
         class Algorithm
-          module SignatureBlob
-            class << self
-              include Codable
-            end
+          class SignatureBlob
+            include Codable
             DEFINITION = [
               [DataType::String,  :'session identifier'],
               [DataType::Byte,    :'message number'],

data/lib/hrr_rb_ssh/authentication/method/publickey/context.rb

@@ -1,16 +1,21 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   class Authentication
     class Method
       class Publickey
         class Context
+          include Loggable
+
           attr_reader \
             :username,
             :session_id,
+            :variables,
+            :vars,
+            :authentication_methods,
             :message_number,
             :service_name,
             :method_name,
@@ -19,11 +24,15 @@ module HrrRbSsh
             :public_key_blob,
             :signature
 
-          def initialize username, algorithm, session_id, message
+          def initialize username, algorithm, session_id, message, variables, authentication_methods, logger: nil
+            self.logger = logger
             @username   = username
             @algorithm  = algorithm
             @session_id = session_id
             @message    = message
+            @variables  = variables
+            @vars       = variables
+            @authentication_methods = authentication_methods
 
             @message_number            = message[:'message number']
             @service_name              = message[:'service name']

data/lib/hrr_rb_ssh/client.rb

@@ -0,0 +1,234 @@
+# coding: utf-8
+# vim: et ts=2 sw=2
+
+require 'socket'
+require 'stringio'
+require 'hrr_rb_ssh/loggable'
+require 'hrr_rb_ssh/mode'
+require 'hrr_rb_ssh/transport'
+require 'hrr_rb_ssh/authentication'
+require 'hrr_rb_ssh/connection'
+
+module HrrRbSsh
+  class Client
+    include Loggable
+
+    def self.start target, options={}
+      client = self.new target, options
+      client.start
+      if block_given?
+        begin
+          yield client
+        ensure
+          client.close unless client.closed?
+        end
+      else
+        client
+      end
+    end
+
+    def initialize target, tmp_options={}
+      @closed = true
+      options = initialize_options tmp_options
+      io = case target
+           when IO
+             target
+           when Array
+             io = TCPSocket.new *target
+           when String
+             port = 22
+             io = TCPSocket.new target, port
+           end
+      transport      = HrrRbSsh::Transport.new      io, HrrRbSsh::Mode::CLIENT, options, logger: logger
+      authentication = HrrRbSsh::Authentication.new transport, HrrRbSsh::Mode::CLIENT, options, logger: logger
+      @connection    = HrrRbSsh::Connection.new     authentication, HrrRbSsh::Mode::CLIENT, options, logger: logger
+    end
+
+    def initialize_options tmp_options
+      tmp_options = Hash[tmp_options.map{|k, v| [k.to_s, v]}]
+      self.logger = tmp_options['logger']
+      options = {}
+      options['username'] = tmp_options['username']
+      options['authentication_preferred_authentication_methods'] = tmp_options['authentication_preferred_authentication_methods']
+      options['client_authentication_password']                  = tmp_options['password']
+      options['client_authentication_publickey']                 = tmp_options['publickey']
+      options['client_authentication_keyboard_interactive']      = tmp_options['keyboard_interactive']
+      options['transport_preferred_encryption_algorithms']       = tmp_options['transport_preferred_encryption_algorithms']
+      options['transport_preferred_server_host_key_algorithms']  = tmp_options['transport_preferred_server_host_key_algorithms']
+      options['transport_preferred_kex_algorithms']              = tmp_options['transport_preferred_kex_algorithms']
+      options['transport_preferred_mac_algorithms']              = tmp_options['transport_preferred_mac_algorithms']
+      options['transport_preferred_compression_algorithms']      = tmp_options['transport_preferred_compression_algorithms']
+      options
+    end
+
+    def start
+      @connection.start foreground: false
+      @closed = false
+    end
+
+    def loop
+      @connection.loop
+    end
+
+    def closed?
+      @closed
+    end
+
+    def close
+      log_info { "closing client" }
+      @closed = true
+      @connection.close
+      log_info { "client closed" }
+    end
+
+    def exec! command, pty: false, env: {}
+      log_info { "start exec!: #{command}" }
+      out_buf = StringIO.new
+      err_buf = StringIO.new
+      begin
+        log_info { "Opning channel" }
+        channel = @connection.request_channel_open "session"
+        log_info { "Channel opened" }
+        if pty
+          channel.send_channel_request_pty_req 'xterm', 80, 24, 580, 336, ''
+        end
+        env.each{ |variable_name, variable_value|
+          channel.send_channel_request_env variable_name, variable_value
+        }
+        channel.send_channel_request_exec command
+        out_t = Thread.new {
+          while true
+            begin
+              out_buf.write channel.io[1].readpartial(10240)
+            rescue
+              break
+            end
+          end
+        }
+        err_t = Thread.new {
+          while true
+            begin
+              err_buf.write channel.io[2].readpartial(10240)
+            rescue
+              break
+            end
+          end
+        }
+        [out_t, err_t].each{ |t|
+          begin
+            t.join
+          rescue => e
+            log_warn { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+          end
+        }
+      rescue => e
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        raise "Error in exec!"
+      ensure
+        if channel
+          log_info { "closing channel IOs" }
+          channel.io.each{ |io| io.close rescue nil }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
+          channel.wait_until_closed
+          channel.close
+          log_info { "channel closed" }
+        end
+      end
+      [out_buf.string, err_buf.string]
+    end
+
+    def exec command, pty: false, env: {}
+      log_info { "start exec: #{command}" }
+      begin
+        log_info { "Opning channel" }
+        channel = @connection.request_channel_open "session"
+        log_info { "Channel opened" }
+        if pty
+          channel.send_channel_request_pty_req 'xterm', 80, 24, 580, 336, ''
+        end
+        env.each{ |variable_name, variable_value|
+          channel.send_channel_request_env variable_name, variable_value
+        }
+        channel.send_channel_request_exec command
+        yield channel.io
+      rescue => e
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        raise "Error in shell"
+      ensure
+        if channel
+          log_info { "closing channel IOs" }
+          channel.io.each{ |io| io.close rescue nil }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
+          channel.wait_until_closed
+          channel.close
+          log_info { "channel closed" }
+        end
+      end
+      channel_exit_status = channel.exit_status rescue nil
+    end
+
+    def shell env: {}
+      log_info { "start shell" }
+      begin
+        log_info { "Opning channel" }
+        channel = @connection.request_channel_open "session"
+        log_info { "Channel opened" }
+        channel.send_channel_request_pty_req 'xterm', 80, 24, 580, 336, ''
+        env.each{ |variable_name, variable_value|
+          channel.send_channel_request_env variable_name, variable_value
+        }
+        channel.send_channel_request_shell
+        yield channel.io
+      rescue => e
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        raise "Error in shell"
+      ensure
+        if channel
+          log_info { "closing channel IOs" }
+          channel.io.each{ |io| io.close rescue nil }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
+          channel.wait_until_closed
+          channel.close
+          log_info { "channel closed" }
+        end
+      end
+      channel_exit_status = channel.exit_status rescue nil
+    end
+
+    def subsystem name
+      log_info { "start subsystem" }
+      begin
+        log_info { "Opning channel" }
+        channel = @connection.request_channel_open "session"
+        log_info { "Channel opened" }
+        channel.send_channel_request_subsystem name
+        yield channel.io
+      rescue => e
+        log_error { "Failed opening channel" }
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        raise "Error in subsystem"
+      ensure
+        if channel
+          log_info { "closing channel IOs" }
+          channel.io.each{ |io| io.close rescue nil }
+          log_info { "channel IOs closed" }
+          log_info { "closing channel" }
+          log_info { "wait until threads closed in channel" }
+          channel.wait_until_closed
+          channel.close
+          log_info { "channel closed" }
+        end
+      end
+      channel_exit_status = channel.exit_status rescue nil
+    end
+  end
+end

data/lib/hrr_rb_ssh/codable.rb

@@ -1,36 +1,38 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 
 module HrrRbSsh
   module Codable
-    def logger
-      @logger ||= Logger.new self.name
+    include Loggable
+
+    def initialize logger: nil
+      self.logger = logger
     end
 
     def common_definition
-      self::DEFINITION
+      self.class::DEFINITION
     end
 
     def conditional_definition message
-      return [] unless self.const_defined? :CONDITIONAL_DEFINITION
+      return [] unless self.class.const_defined? :CONDITIONAL_DEFINITION
       message.inject([]){ |a, (k,v)|
         field_name  = k
         field_value = if v.instance_of? ::Proc then v.call else v end
-        a + (self::CONDITIONAL_DEFINITION.fetch(field_name, {})[field_value] || [])
+        a + (self.class::CONDITIONAL_DEFINITION.fetch(field_name, {})[field_value] || [])
       }
     end
 
     def encode message, complementary_message={}
-      logger.debug { 'encoding message: ' + message.inspect }
+      log_debug { 'encoding message: ' + message.inspect }
       definition = common_definition + conditional_definition(message.merge complementary_message)
       definition.map{ |data_type, field_name|
         begin
           field_value = if message[field_name].instance_of? ::Proc then message[field_name].call else message[field_name] end
-          data_type.encode( field_value )
+          data_type.encode field_value
         rescue => e
-          logger.debug { "'field_name', 'field_value': #{field_name.inspect}, #{field_value.inspect}" }
+          log_debug { "'field_name', 'field_value': #{field_name.inspect}, #{field_value.inspect}" }
           raise e
         end
       }.join
@@ -49,7 +51,7 @@ module HrrRbSsh
         decoded_message = definition.map{ |data_type, field_name|
           [
             field_name,
-            data_type.decode( payload_io )
+            data_type.decode(payload_io)
           ]
         }
         decoded_message + decode_recursively(payload_io, decoded_message)
@@ -58,11 +60,11 @@ module HrrRbSsh
 
     def decode payload, complementary_message={}
       payload_io = StringIO.new payload
-      decoded_message = decode_recursively(payload_io).to_h
+      decoded_message = decode_recursively(payload_io).inject(Hash.new){ |h, (k, v)| h.update({k => v}) }
       if complementary_message.any?
-        decoded_message.merge! decode_recursively(payload_io, complementary_message.to_a).to_h
+        decoded_message.merge! decode_recursively(payload_io, complementary_message.to_a).inject(Hash.new){ |h, (k, v)| h.update({k => v}) }
       end
-      logger.debug { 'decoded message: ' + decoded_message.inspect }
+      log_debug { 'decoded message: ' + decoded_message.inspect }
       decoded_message
     end
   end

data/lib/hrr_rb_ssh/compat/ruby.rb

@@ -1,6 +1,5 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/compat/ruby/array'
 require 'hrr_rb_ssh/compat/ruby/openssl'
 require 'hrr_rb_ssh/compat/ruby/queue'

data/lib/hrr_rb_ssh/connection.rb

@@ -1,26 +1,30 @@
 # coding: utf-8
 # vim: et ts=2 sw=2
 
-require 'hrr_rb_ssh/logger'
+require 'hrr_rb_ssh/loggable'
 require 'hrr_rb_ssh/error/closed_connection'
 require 'hrr_rb_ssh/connection/global_request_handler'
 require 'hrr_rb_ssh/connection/channel'
 
 module HrrRbSsh
   class Connection
+    include Loggable
+
     attr_reader \
       :username,
-      :options
-
-    def initialize authentication, options={}
-      @logger = Logger.new self.class.name
+      :variables,
+      :options,
+      :mode
 
+    def initialize authentication, mode, options={}, logger: nil
+      self.logger = logger
       @authentication = authentication
+      @mode = mode
       @options = options
-
-      @global_request_handler = GlobalRequestHandler.new self
+      @global_request_handler = GlobalRequestHandler.new self, logger: logger
       @channels = Hash.new
       @username = nil
+      @variables = nil
       @closed = nil
     end
 
@@ -36,75 +40,103 @@ module HrrRbSsh
     def assign_channel
       i = 0
       res = nil
-      loop do
+      while true
         break unless @channels.keys.include?(i)
         i += 1
       end
       i
     end
 
-    def start
-      @authentication.start
+    def start foreground: true
+      log_info { "start connection" }
+      begin
+        @authentication.start
+      rescue Error::ClosedAuthentication
+        close
+        raise Error::ClosedConnection
+      end
       @closed = false
-      connection_loop
+      @connection_loop_thread = connection_loop_thread
+      if foreground
+        @connection_loop_thread.join
+      end
+    end
+
+    def loop
+      @connection_loop_thread.join
     end
 
     def close
+      return if @closed
+      log_info { "close connection" }
       @closed = true
+      @authentication.close
       @channels.values.each do |channel|
         begin
           channel.close
         rescue => e
-          @logger.error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+          log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         end
       end
       @channels.clear
       @global_request_handler.close
+      @connection_loop_thread.join if @connection_loop_thread && @connection_loop_thread != Thread.current
+      log_info { "connection closed" }
     end
 
     def closed?
       @closed
     end
 
-    def connection_loop
-      @logger.info { "start connection" }
-      loop do
+    def connection_loop_thread
+      log_info { "start connection loop" }
+      Thread.new do
         begin
-          payload = @authentication.receive
-        rescue Error::ClosedAuthentication => e
-          @logger.info { "closing connection loop" }
-          break
-        end
-        @username ||= @authentication.username
-        case payload[0,1].unpack("C")[0]
-        when Message::SSH_MSG_GLOBAL_REQUEST::VALUE
-          global_request payload
-        when Message::SSH_MSG_CHANNEL_OPEN::VALUE
-          channel_open payload
-        when Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE
-          channel_open_confirmation payload
-        when Message::SSH_MSG_CHANNEL_REQUEST::VALUE
-          channel_request payload
-        when Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
-          channel_window_adjust payload
-        when Message::SSH_MSG_CHANNEL_DATA::VALUE
-          channel_data payload
-        when Message::SSH_MSG_CHANNEL_EOF::VALUE
-          channel_eof payload
-        when Message::SSH_MSG_CHANNEL_CLOSE::VALUE
-          channel_close payload
-        else
-          @logger.warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
+          while true
+            begin
+              payload = @authentication.receive
+            rescue Error::ClosedAuthentication => e
+              log_info { "authentication closed" }
+              break
+            end
+            @username ||= @authentication.username
+            @variables ||= @authentication.variables
+            case payload[0,1].unpack("C")[0]
+            when Message::SSH_MSG_GLOBAL_REQUEST::VALUE
+              global_request payload
+            when Message::SSH_MSG_CHANNEL_OPEN::VALUE
+              channel_open payload
+            when Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::VALUE
+              channel_open_confirmation payload
+            when Message::SSH_MSG_CHANNEL_REQUEST::VALUE
+              channel_request payload
+            when Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::VALUE
+              channel_window_adjust payload
+            when Message::SSH_MSG_CHANNEL_DATA::VALUE
+              channel_data payload
+            when Message::SSH_MSG_CHANNEL_EXTENDED_DATA::VALUE
+              channel_extended_data payload
+            when Message::SSH_MSG_CHANNEL_EOF::VALUE
+              channel_eof payload
+            when Message::SSH_MSG_CHANNEL_CLOSE::VALUE
+              channel_close payload
+            else
+              log_warn { "received unsupported message: id: #{payload[0,1].unpack("C")[0]}" }
+            end
+          end
+        rescue => e
+          log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
+        ensure
+          log_info { "closing connection loop" }
+          close
+          log_info { "connection loop closed" }
         end
       end
-      @logger.info { "closing connection" }
-      close
-      @logger.info { "connection closed" }
     end
 
     def global_request payload
-      @logger.info { 'received ' + Message::SSH_MSG_GLOBAL_REQUEST::ID }
-      message = Message::SSH_MSG_GLOBAL_REQUEST.decode payload
+      log_info { 'received ' + Message::SSH_MSG_GLOBAL_REQUEST::ID }
+      message = Message::SSH_MSG_GLOBAL_REQUEST.new(logger: logger).decode payload
       begin
         @global_request_handler.request message
       rescue
@@ -119,10 +151,10 @@ module HrrRbSsh
     end
 
     def channel_open_start address, port, socket
-      @logger.info { 'channel open start' }
-      channel = Channel.new self, {:'channel type' => "forwarded-tcpip"}, socket
+      log_info { 'channel open start' }
+      channel = Channel.new self, {:'channel type' => "forwarded-tcpip"}, socket, logger: logger
       @channels[channel.local_channel] = channel
-      @logger.info { 'channel opened' }
+      log_info { 'channel opened' }
       message = {
         :'message number'             => Message::SSH_MSG_CHANNEL_OPEN::VALUE,
         :'channel type'               => "forwarded-tcpip",
@@ -138,72 +170,110 @@ module HrrRbSsh
     end
 
     def channel_open payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN::ID }
-      message = Message::SSH_MSG_CHANNEL_OPEN.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN::ID }
+      message = Message::SSH_MSG_CHANNEL_OPEN.new(logger: logger).decode payload
       begin
-        channel = Channel.new self, message
+        channel = Channel.new self, message, logger: logger
         @channels[channel.local_channel] = channel
         channel.start
         send_channel_open_confirmation channel
       rescue => e
+        log_error { [e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join }
         recipient_channel = message[:'sender channel']
         send_channel_open_failure recipient_channel, Message::SSH_MSG_CHANNEL_OPEN_FAILURE::ReasonCode::SSH_OPEN_CONNECT_FAILED, e.message
       end
     end
 
+    def request_channel_open channel_type, channel_specific_message={}, wait_response=true
+      log_info { 'request channel open' }
+      case channel_type
+      when "session"
+        channel = Channel.new self, {:'channel type' => channel_type}, logger: logger
+        @channels[channel.local_channel] = channel
+      end
+      message = {
+        :'message number'             => Message::SSH_MSG_CHANNEL_OPEN::VALUE,
+        :'channel type'               => channel_type,
+        :'sender channel'             => channel.local_channel,
+        :'initial window size'        => channel.local_window_size,
+        :'maximum packet size'        => channel.local_maximum_packet_size,
+      }
+      send_channel_open message.merge(channel_specific_message)
+      log_info { 'sent channel open' }
+      if wait_response
+        log_info { 'wait response' }
+        channel.wait_until_started
+      end
+      unless channel.closed?
+        log_info { 'channel opened' }
+        channel
+      else
+        raise "Faild opening channel"
+      end
+    end
+
     def channel_open_confirmation payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
-      message = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION::ID }
+      message = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.new(logger: logger).decode payload
       channel = @channels[message[:'recipient channel']]
       channel.set_remote_parameters message
       channel.start
     end
 
     def channel_request payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_REQUEST::ID }
-      message = Message::SSH_MSG_CHANNEL_REQUEST.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_REQUEST::ID }
+      message = Message::SSH_MSG_CHANNEL_REQUEST.new(logger: logger).decode payload
       local_channel = message[:'recipient channel']
-      @channels[local_channel].receive_message_queue.enq message
+      @channels[local_channel].receive_message_queue.enq message if @channels.has_key? local_channel
     end
 
     def channel_window_adjust payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID }
-      message = Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_WINDOW_ADJUST::ID }
+      message = Message::SSH_MSG_CHANNEL_WINDOW_ADJUST.new(logger: logger).decode payload
       local_channel = message[:'recipient channel']
-      @channels[local_channel].receive_message_queue.enq message
+      @channels[local_channel].receive_message_queue.enq message if @channels.has_key? local_channel
     end
 
     def channel_data payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_DATA::ID }
-      message = Message::SSH_MSG_CHANNEL_DATA.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_DATA::ID }
+      message = Message::SSH_MSG_CHANNEL_DATA.new(logger: logger).decode payload
       local_channel = message[:'recipient channel']
-      @channels[local_channel].receive_message_queue.enq message
+      @channels[local_channel].receive_message_queue.enq message if @channels.has_key? local_channel
+    end
+
+    def channel_extended_data payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_EXTENDED_DATA::ID }
+      message = Message::SSH_MSG_CHANNEL_EXTENDED_DATA.new(logger: logger).decode payload
+      local_channel = message[:'recipient channel']
+      @channels[local_channel].receive_message_queue.enq message if @channels.has_key? local_channel
     end
 
     def channel_eof payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_EOF::ID }
-      message = Message::SSH_MSG_CHANNEL_EOF.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_EOF::ID }
+      message = Message::SSH_MSG_CHANNEL_EOF.new(logger: logger).decode payload
       local_channel = message[:'recipient channel']
-      channel = @channels[local_channel]
-      channel.receive_message_queue.close
+      @channels[local_channel].receive_message_queue.enq message if @channels.has_key? local_channel
     end
 
     def channel_close payload
-      @logger.info { 'received ' + Message::SSH_MSG_CHANNEL_CLOSE::ID }
-      message = Message::SSH_MSG_CHANNEL_CLOSE.decode payload
+      log_info { 'received ' + Message::SSH_MSG_CHANNEL_CLOSE::ID }
+      message = Message::SSH_MSG_CHANNEL_CLOSE.new(logger: logger).decode payload
       local_channel = message[:'recipient channel']
       channel = @channels[local_channel]
       channel.close
-      @logger.info { "deleting channel" }
+      log_info { "wait until threads closed in channel" }
+      channel.wait_until_closed
+      log_info { "channel closed" }
+      log_info { "deleting channel" }
       @channels.delete local_channel
-      @logger.info { "channel deleted" }
+      log_info { "channel deleted" }
     end
 
     def send_request_success
       message = {
         :'message number' => Message::SSH_MSG_REQUEST_SUCCESS::VALUE,
       }
-      payload = Message::SSH_MSG_REQUEST_SUCCESS.encode message
+      payload = Message::SSH_MSG_REQUEST_SUCCESS.new(logger: logger).encode message
       @authentication.send payload
     end
 
@@ -211,12 +281,12 @@ module HrrRbSsh
       message = {
         :'message number' => Message::SSH_MSG_REQUEST_FAILURE::VALUE,
       }
-      payload = Message::SSH_MSG_REQUEST_FAILURE.encode message
+      payload = Message::SSH_MSG_REQUEST_FAILURE.new(logger: logger).encode message
       @authentication.send payload
     end
 
     def send_channel_open message
-      payload = Message::SSH_MSG_CHANNEL_OPEN.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN.new(logger: logger).encode message
       @authentication.send payload
     end
 
@@ -229,7 +299,7 @@ module HrrRbSsh
         :'initial window size' => channel.local_window_size,
         :'maximum packet size' => channel.local_maximum_packet_size,
       }
-      payload = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN_CONFIRMATION.new(logger: logger).encode message
       @authentication.send payload
     end
 
@@ -241,7 +311,7 @@ module HrrRbSsh
         :'description'         => description,
         :'language tag'        => "",
       }
-      payload = Message::SSH_MSG_CHANNEL_OPEN_FAILURE.encode message
+      payload = Message::SSH_MSG_CHANNEL_OPEN_FAILURE.new(logger: logger).encode message
       @authentication.send payload
     end
   end