investtools-ftpd 1.0.1

data/lib/ftpd/cmd_smnt.rb

@@ -0,0 +1,13 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  class CmdSmnt < CommandHandler
+
+    def cmd_smnt(argument)
+      unimplemented_error
+    end
+
+  end
+
+end

data/lib/ftpd/cmd_stat.rb

@@ -0,0 +1,15 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  class CmdStat < CommandHandler
+
+    def cmd_stat(argument)
+      ensure_logged_in
+      syntax_error if argument
+      reply "211 #{server_name_and_version}"
+    end
+
+  end
+
+end

data/lib/ftpd/cmd_stor.rb

@@ -0,0 +1,25 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  class CmdStor < CommandHandler
+
+    def cmd_stor(argument)
+      close_data_server_socket_when_done do
+        ensure_logged_in
+        ensure_file_system_supports :write
+        path = argument
+        syntax_error unless path
+        path = File.expand_path(path, name_prefix)
+        ensure_accessible path
+        ensure_exists File.dirname(path)
+        receive_file do |data_socket|
+          file_system.write path, data_socket
+        end
+        reply "226 Transfer complete"
+      end
+    end
+
+  end
+
+end

data/lib/ftpd/cmd_stou.rb

@@ -0,0 +1,25 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  class CmdStou < CommandHandler
+
+    def cmd_stou(argument)
+      close_data_server_socket_when_done do
+        ensure_logged_in
+        ensure_file_system_supports :write
+        path = argument || 'ftpd'
+        path = File.expand_path(path, name_prefix)
+        path = unique_path(path)
+        ensure_accessible path
+        ensure_exists File.dirname(path)
+        receive_file(File.basename(path)) do |data_socket|
+          file_system.write path, data_socket
+        end
+        reply "226 Transfer complete"
+      end
+    end
+
+  end
+
+end

data/lib/ftpd/cmd_stru.rb

@@ -0,0 +1,27 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  class CmdStru < CommandHandler
+
+    def cmd_stru(argument)
+      syntax_error unless argument
+      ensure_logged_in
+      name, implemented = FILE_STRUCTURES[argument]
+      error "Invalid structure code", 504 unless name
+      error "Structure not implemented", 504 unless implemented
+      self.structure = argument
+      reply "200 File structure set to #{name}"
+    end
+
+    private
+
+    FILE_STRUCTURES = {
+      'R'=>['Record', false],
+      'F'=>['File', true],
+      'P'=>['Page', false],
+    }
+
+  end
+
+end

data/lib/ftpd/cmd_syst.rb

@@ -0,0 +1,16 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  # The System (SYST) command.
+
+  class CmdSyst < CommandHandler
+
+    def cmd_syst(argument)
+      syntax_error if argument
+      reply "215 UNIX Type: L8"
+    end
+
+  end
+
+end

data/lib/ftpd/cmd_type.rb

@@ -0,0 +1,28 @@
+require_relative 'command_handler'
+
+module Ftpd
+
+  class CmdType < CommandHandler
+
+    def cmd_type(argument)
+      ensure_logged_in
+      syntax_error unless argument =~ /^(\S)(?: (\S+))?$/
+      type_code = $1
+      format_code = $2
+      unless argument =~ /^([AEI]( [NTC])?|L .*)$/
+        error 'Invalid type code', 504
+      end
+      case argument
+      when /^A( [NT])?$/
+        self.data_type = 'A'
+      when /^(I|L 8)$/
+        self.data_type = 'I'
+      else
+        error 'Type not implemented', 504
+      end
+      reply "200 Type set to #{data_type}"
+    end
+
+  end
+
+end

data/lib/ftpd/command_handler.rb

@@ -0,0 +1,90 @@
+require_relative 'data_connection_helper'
+require_relative 'error'
+require_relative 'file_system_helper'
+
+module Ftpd
+
+  # Command handler base class
+  
+  class CommandHandler
+
+    extend Forwardable
+
+    include DataConnectionHelper
+    include Error
+    include FileSystemHelper
+
+    COMMAND_FILENAME_PREFIX = 'cmd_'
+    COMMAND_KLASS_PREFIX = 'Cmd'
+    COMMAND_METHOD_PREFIX = 'cmd_'
+
+    # param session [Session] The session
+
+    def initialize(session)
+      @session = session
+    end
+
+    # Return the commands implemented by this handler.  For example,
+    # if the handler has the method "cmd_allo", this returns ['allo'].
+
+    class << self
+      include Memoizer
+      def commands
+        public_instance_methods.map(&:to_s).grep(/#{COMMAND_METHOD_PREFIX}/).map do |method|
+          method.gsub(/^#{COMMAND_METHOD_PREFIX}/, '')
+        end
+      end
+      memoize :commands
+    end
+
+    def_delegator 'self.class', :commands
+
+    private
+
+    attr_reader :session
+
+    # Forward methods to the session
+
+    def_delegators :@session,
+    :close_data_server_socket,
+    :command_not_needed,
+    :config,
+    :data_channel_protection_level,
+    :data_channel_protection_level=,
+    :data_hostname,
+    :data_port,
+    :data_server,
+    :data_server=,
+    :data_type,
+    :data_type=,
+    :ensure_logged_in,
+    :ensure_not_epsv_all,
+    :ensure_protocol_supported,
+    :ensure_tls_supported,
+    :epsv_all=,
+    :execute_command,
+    :expect,
+    :file_system,
+    :list,
+    :list_path,
+    :logged_in,
+    :logged_in=,
+    :login,
+    :mode=,
+    :name_list,
+    :name_prefix,
+    :name_prefix=,
+    :protection_buffer_size_set,
+    :protection_buffer_size_set=,
+    :pwd,
+    :reply,
+    :server_name_and_version,
+    :set_active_mode_address,
+    :socket,
+    :structure=,
+    :supported_commands,
+    :tls_enabled?
+ 
+  end
+
+end

data/lib/ftpd/command_handler_factory.rb

@@ -0,0 +1,51 @@
+module Ftpd
+
+  class CommandHandlerFactory
+
+    def self.standard_command_handlers
+      [
+        CmdAbor,
+        CmdAllo,
+        CmdAppe,
+        CmdAuth,
+        CmdCdup,
+        CmdCwd,
+        CmdDele,
+        CmdEprt,
+        CmdEpsv,
+        CmdFeat,
+        CmdHelp,
+        CmdList,
+        CmdLogin,
+        CmdMdtm,
+        CmdMkd,
+        CmdMode,
+        CmdNlst,
+        CmdNoop,
+        CmdOpts,
+        CmdPasv,
+        CmdPbsz,
+        CmdPort,
+        CmdProt,
+        CmdPwd,
+        CmdQuit,
+        CmdRein,
+        CmdRename,
+        CmdRest,
+        CmdRetr,
+        CmdRmd,
+        CmdSite,
+        CmdSize,
+        CmdSmnt,
+        CmdStat,
+        CmdStor,
+        CmdStou,
+        CmdStru,
+        CmdSyst,
+        CmdType,
+      ]      
+    end
+
+  end
+
+end

data/lib/ftpd/command_handlers.rb

@@ -0,0 +1,60 @@
+module Ftpd
+
+  # All FTP commands which the server supports are dispatched by this
+  # class.
+
+  class CommandHandlers
+
+    def initialize
+      @commands = {}
+    end
+
+    # Add a command handler
+    #
+    # @param command_handler [Command]
+
+    def <<(command_handler)
+      command_handler.commands.each do |command|
+        @commands[command] = command_handler
+      end
+    end
+
+    # @param command [String] the command (e.g. "STOR").  Case
+    #   insensitive.
+    # @return truthy if the server supports the command.
+
+    def has?(command)
+      command = canonical_command(command)
+      @commands.has_key?(command)
+    end
+
+    # Dispatch a command to the appropriate command handler.
+    #
+    # @param command [String] the command (e.g. "STOR").  Case
+    #   insensitive.
+    # @param argument [String] The argument, or nil if there isn't
+    #   one.
+
+    def execute(command, argument)
+      command = canonical_command(command)
+      method = "cmd_#{command}"
+      @commands[command.downcase].send(method, argument)
+    end
+
+    # Return the sorted list of commands supported by this handler
+    #
+    # @return [Array<String>] Lowercase command
+
+    def commands
+      @commands.keys.sort
+    end
+
+    private
+
+    def canonical_command(command)
+      command.downcase
+    end
+
+  end
+
+end

data/lib/ftpd/command_loop.rb

@@ -0,0 +1,80 @@
+module Ftpd
+
+  class CommandLoop
+
+    extend Forwardable
+
+    include Error
+
+    def initialize(session)
+      @session = session
+    end
+
+    def read_and_execute_commands
+      catch :done do
+        begin
+          reply "220 #{server_name_and_version}"
+          loop do
+            begin
+              s = get_command
+              s = process_telnet_sequences(s)
+              syntax_error unless s =~ /^(\w+)(?: (.*))?$/
+              command, argument = $1.downcase, $2
+              unless valid_command?(command)
+                error "Syntax error, command unrecognized: #{s.chomp}", 500
+              end
+              command_sequence_checker.check command
+              execute_command command, argument
+            rescue FtpServerError => e
+              reply e.message_with_code
+            rescue => e
+              reply "451 Requested action aborted. Local error in processing."
+              config.exception_handler.call(e) unless config.exception_handler.nil?
+            end
+          end
+        rescue Errno::ECONNRESET, Errno::EPIPE
+        end
+      end
+    end
+
+    private
+
+    def_delegators :@session,
+    :command_sequence_checker,
+    :config,
+    :execute_command,
+    :reply,
+    :server_name_and_version,
+    :socket,
+    :valid_command?
+
+    def get_command
+      s = gets_with_timeout(socket)
+      throw :done if s.nil?
+      s = s.chomp
+      config.log.debug s
+      s
+    end
+    
+    def gets_with_timeout(socket)
+      ready = IO.select([socket], nil, nil, config.session_timeout)
+      timeout if ready.nil?
+      ready[0].first.gets
+    end
+
+    def timeout
+      reply '421 Control connection timed out.'
+      throw :done
+    end
+
+    def process_telnet_sequences(s)
+      telnet = Telnet.new(s)
+      unless telnet.reply.empty?
+        socket.write telnet.reply
+      end
+      telnet.plain
+    end
+
+  end
+
+end

data/lib/ftpd/command_sequence_checker.rb

@@ -0,0 +1,58 @@
+# Some commands are supposed to occur in sequence.  For example, USER
+# must be immediately followed by PASS.  This class keeps track of
+# when a specific command either must arrive or must not arrive, and
+# raises a "bad sequence" error when commands arrive in the wrong
+# sequence.
+
+module Ftpd
+  class CommandSequenceChecker
+
+    include Error
+
+    def initialize
+      @must_expect = []
+      @expected_command = nil
+    end
+
+    # Set the command to expect next.  If not set, then any command
+    # will be accepted, so long as it hasn't been registered using
+    # {#must_expect}.  Otherwise, the set command must be next or a
+    # sequence error will result.
+    #
+    # @param command [String] The command.  Must be lowercase.
+
+    def expect(command)
+      @expected_command = command
+    end
+
+    # Register a command that must be expected.  When that command is
+    # received without {#expect} having been called for it, a sequence
+    # error will result.
+
+    def must_expect(command)
+      @must_expect << command
+    end
+
+    # Check a command.  If expecting a specific command and this
+    # command isn't it, then raise an error that will cause a "503 Bad
+    # sequence" error to be sent.  After checking, the expected
+    # command is cleared and any command will be accepted until
+    # {#expect} is called again.
+    #
+    # @param command [String] The command.  Must be lowercase.
+    # @raise [FtpServerError] A "503 Bad sequence" error
+
+    def check(command)
+      if @expected_command
+        begin
+          sequence_error unless command == @expected_command
+        ensure
+          @expected_command = nil
+        end
+      else
+        sequence_error if @must_expect.include?(command)
+      end
+    end
+
+  end
+end