hrr_rb_sftp 0.1.0

data/hrr_rb_sftp.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/hrr_rb_sftp/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hrr_rb_sftp"
+  spec.version       = HrrRbSftp::VERSION
+  spec.authors       = ["hirura"]
+  spec.email         = ["hirura@gmail.com"]
+
+  spec.summary       = "Pure Ruby SFTP server implementation."
+  spec.description   = "Pure Ruby SFTP server implementation."
+  spec.homepage      = "https://github.com/hirura/hrr_rb_sftp"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.0.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  #spec.metadata["source_code_uri"] = spec.homepage
+  #spec.metadata["changelog_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+
+  spec.require_paths = ["lib"]
+end

data/lib/hrr_rb_sftp.rb

@@ -0,0 +1,13 @@
+module HrrRbSftp
+end
+
+require "fileutils"
+require "stringio"
+require "etc"
+
+require "hrr_rb_sftp/version"
+require "hrr_rb_sftp/loggable"
+require "hrr_rb_sftp/protocol"
+require "hrr_rb_sftp/receiver"
+require "hrr_rb_sftp/sender"
+require "hrr_rb_sftp/server"

data/lib/hrr_rb_sftp/loggable.rb

@@ -0,0 +1,41 @@
+module HrrRbSftp
+  module Loggable
+    attr_accessor :logger
+
+    def log_fatal
+      if logger
+        logger.fatal(log_key){ yield }
+      end
+    end
+
+    def log_error
+      if logger
+        logger.error(log_key){ yield }
+      end
+    end
+
+    def log_warn
+      if logger
+        logger.warn(log_key){ yield }
+      end
+    end
+
+    def log_info
+      if logger
+        logger.info(log_key){ yield }
+      end
+    end
+
+    def log_debug
+      if logger
+        logger.debug(log_key){ yield }
+      end
+    end
+
+    private
+
+    def log_key
+      @log_key ||= self.class.to_s + "[%x]" % object_id
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol.rb

@@ -0,0 +1,62 @@
+module HrrRbSftp
+  class Protocol
+    include Loggable
+
+    def self.versions
+      constants.select{|c| c.to_s.start_with?("Version")}.map{|c| const_get(c)}.map{|klass| klass::PROTOCOL_VERSION}
+    end
+
+    def initialize version, logger: nil
+      self.logger = logger
+
+      @handles = Hash.new
+      @version = version
+      @version_class = self.class.const_get(:"Version#{@version}")
+      packet_classes = @version_class::Packet.constants.select{|c| c.to_s.start_with?("SSH_FXP_")}.map{|c| @version_class::Packet.const_get(c)}
+      @packets = packet_classes.map{|pkt| [pkt::TYPE, pkt.new(@handles, logger: logger)]}.inject(Hash.new){|h,(k,v)| h.update({k => v})}
+    end
+
+    def respond_to request_payload
+      request_type = request_payload[0].unpack("C")[0]
+      response_packet = if @packets.has_key?(request_type)
+                          begin
+                            request_packet = @packets[request_type].decode request_payload
+                          rescue => e
+                            {
+                              :"type"          => @version_class::Packet::SSH_FXP_STATUS::TYPE,
+                              :"request-id"    => (request_payload[1,4].unpack("N")[0] || 0),
+                              :"code"          => @version_class::Packet::SSH_FXP_STATUS::SSH_FX_BAD_MESSAGE,
+                              :"error message" => e.message,
+                              :"language tag"  => "",
+                            }
+                          else
+                            @packets[request_type].respond_to request_packet
+                          end
+                        else
+                          {
+                            :"type"          => @version_class::Packet::SSH_FXP_STATUS::TYPE,
+                            :"request-id"    => (request_payload[1,4].unpack("N")[0] || 0),
+                            :"code"          => @version_class::Packet::SSH_FXP_STATUS::SSH_FX_OP_UNSUPPORTED,
+                            :"error message" => "Unsupported type: #{request_type}",
+                            :"language tag"  => "",
+                          }
+                        end
+      response_type = response_packet[:"type"]
+      @packets[response_type].encode response_packet
+    end
+
+    def close_handles
+      log_info { "closing handles" }
+      @handles.each do |k, v|
+        v.close rescue nil
+      end
+      @handles.clear
+      log_info { "handles closed" }
+    end
+  end
+end
+
+require "hrr_rb_sftp/protocol/common"
+require "hrr_rb_sftp/protocol/version1"
+require "hrr_rb_sftp/protocol/version2"
+require "hrr_rb_sftp/protocol/version3"

data/lib/hrr_rb_sftp/protocol/common.rb

@@ -0,0 +1,10 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+    end
+  end
+end
+
+require "hrr_rb_sftp/protocol/common/data_type"
+require "hrr_rb_sftp/protocol/common/packetable"
+require "hrr_rb_sftp/protocol/common/packet"

data/lib/hrr_rb_sftp/protocol/common/data_type.rb

@@ -0,0 +1,15 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+      end
+    end
+  end
+end
+
+require "hrr_rb_sftp/protocol/common/data_type/byte"
+require "hrr_rb_sftp/protocol/common/data_type/uint32"
+require "hrr_rb_sftp/protocol/common/data_type/uint64"
+require 'hrr_rb_sftp/protocol/common/data_type/string'
+require 'hrr_rb_sftp/protocol/common/data_type/extension_pair'
+require 'hrr_rb_sftp/protocol/common/data_type/extension_pairs'

data/lib/hrr_rb_sftp/protocol/common/data_type/byte.rb

@@ -0,0 +1,22 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+        module Byte
+          def self.encode arg
+            case arg
+            when 0x00..0xff
+              [arg].pack("C")
+            else
+              raise ArgumentError, "must be in #{0x00}..#{0xff}, but got #{arg.inspect}"
+            end
+          end
+
+          def self.decode io
+            io.read(1).unpack("C")[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/data_type/extension_pair.rb

@@ -0,0 +1,23 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+        module ExtensionPair
+          def self.encode arg
+            unless arg.kind_of? ::Hash
+              raise ArgumentError, "must be a kind of Hash, but got #{arg.inspect}"
+            end
+            DataType::String.encode(arg[:"extension-name"]) + DataType::String.encode(arg[:"extension-data"])
+          end
+
+          def self.decode io
+            {
+              :"extension-name" => DataType::String.decode(io),
+              :"extension-data" => DataType::String.decode(io),
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/data_type/extension_pairs.rb

@@ -0,0 +1,24 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+        module ExtensionPairs
+          def self.encode arg
+            unless arg.kind_of? ::Array
+              raise ArgumentError, "must be a kind of Array, but got #{arg.inspect}"
+            end
+            arg.map{|arg| ExtensionPair.encode(arg)}.join
+          end
+
+          def self.decode io
+            extension_pairs = Array.new
+            until io.eof?
+              extension_pairs.push ExtensionPair.decode(io)
+            end
+            extension_pairs
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/data_type/string.rb

@@ -0,0 +1,24 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+        module String
+          def self.encode arg
+            unless arg.kind_of? ::String
+              raise ArgumentError, "must be a kind of String, but got #{arg.inspect}"
+            end
+            if arg.bytesize > 0xffff_ffff
+              raise ArgumentError, "must be shorter than or equal to #{0xffff_ffff}, but got length #{arg.bytesize}"
+            end
+            [arg.bytesize, arg].pack("Na*")
+          end
+
+          def self.decode io
+            length = io.read(4).unpack("N")[0]
+            io.read(length).unpack("a*")[0].force_encoding(Encoding::UTF_8)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/data_type/uint32.rb

@@ -0,0 +1,22 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+        module Uint32
+          def self.encode arg
+            case arg
+            when 0x0000_0000..0xffff_ffff
+              [arg].pack("N")
+            else
+              raise ArgumentError, "must be in #{0x0000_0000}..#{0xffff_ffff}, but got #{arg.inspect}"
+            end
+          end
+
+          def self.decode io
+            io.read(4).unpack("N")[0]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/data_type/uint64.rb

@@ -0,0 +1,22 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module DataType
+        module Uint64
+          def self.encode arg
+            case arg
+            when 0x0000_0000_0000_0000..0xffff_ffff_ffff_ffff
+              [arg >> 32].pack("N") + [arg & 0x0000_0000_ffff_ffff].pack("N")
+            else
+              raise ArgumentError, "must be in #{0x0000_0000_0000_0000}..#{0xffff_ffff_ffff_ffff}, but got #{arg.inspect}"
+            end
+          end
+
+          def self.decode io
+            (io.read(4).unpack("N")[0] << 32) + (io.read(4).unpack("N")[0])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/packet.rb

@@ -0,0 +1,11 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module Packet
+      end
+    end
+  end
+end
+
+require "hrr_rb_sftp/protocol/common/packet/001_ssh_fxp_init"
+require "hrr_rb_sftp/protocol/common/packet/002_ssh_fxp_version"

data/lib/hrr_rb_sftp/protocol/common/packet/001_ssh_fxp_init.rb

@@ -0,0 +1,18 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module Packet
+        class SSH_FXP_INIT
+          include Packetable
+
+          TYPE = 1
+
+          FORMAT = [
+            [DataType::Byte,   :"type"   ],
+            [DataType::Uint32, :"version"],
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/packet/002_ssh_fxp_version.rb

@@ -0,0 +1,19 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module Packet
+        class SSH_FXP_VERSION
+          include Packetable
+
+          TYPE = 2
+
+          FORMAT = [
+            [DataType::Byte,           :"type"      ],
+            [DataType::Uint32,         :"version"   ],
+            [DataType::ExtensionPairs, :"extensions"],
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/hrr_rb_sftp/protocol/common/packetable.rb

@@ -0,0 +1,72 @@
+module HrrRbSftp
+  class Protocol
+    module Common
+      module Packetable
+        include Loggable
+
+        def initialize handles, logger: nil
+          self.logger = logger
+
+          @handles = handles
+        end
+
+        def encode packet
+          log_debug { 'encoding packet: ' + packet.inspect }
+          format = common_format + conditional_format(packet)
+          format.map{ |data_type, field_name|
+            begin
+              field_value = packet[field_name]
+              data_type.encode field_value
+            rescue => e
+              log_debug { "'field_name', 'field_value': #{field_name.inspect}, #{field_value.inspect}" }
+              raise e
+            end
+          }.join
+        end
+
+        def decode payload
+          payload_io = StringIO.new payload
+          format = common_format
+          decoded_packet = decode_recursively(payload_io).inject(Hash.new){ |h, (k, v)| h.update({k => v}) }
+          log_debug { 'decoded packet: ' + decoded_packet.inspect }
+          decoded_packet
+        end
+
+        private
+
+        def common_format
+          self.class::FORMAT
+        end
+
+        def conditional_format packet
+          return [] unless self.class.const_defined? :CONDITIONAL_FORMAT
+          packet.inject([]){ |a, (field_name, field_value)|
+            a + (self.class::CONDITIONAL_FORMAT.fetch(field_name, {})[field_value] || [])
+          }
+        end
+
+        def decode_recursively payload_io, packet=nil
+          if packet.class == Array and packet.size == 0
+            []
+          else
+            format = case packet
+                     when nil
+                       common_format
+                     when Array
+                       conditional_format(packet)
+                     end
+            decoded_packet = format.map{ |data_type, field_name|
+              begin
+                [field_name, data_type.decode(payload_io)]
+              rescue => e
+                log_debug { "'field_name': #{field_name.inspect}" }
+                raise e
+              end
+            }
+            decoded_packet + decode_recursively(payload_io, decoded_packet)
+          end
+        end
+      end
+    end
+  end
+end