investtools-ftpd 1.0.1

data/features/step_definitions/system.rb

@@ -0,0 +1,7 @@
+When /^the client successfully queries system ID$/ do
+  @reply = client.system
+end
+
+Then /^the server returns a system ID reply$/ do
+  step 'the server returns a "UNIX Type: L8" reply'
+end

data/features/step_definitions/timing.rb

@@ -0,0 +1,19 @@
+Before do
+  @start_time = Time.now
+end
+
+When /^the client is idle for (\S+) seconds$/ do |seconds|
+  sleep seconds.to_f
+end
+
+Then /^it should take at least (\S+) seconds$/ do |s|
+  min_elapsed_time = s.to_f
+  elapsed_time = Time.now - @start_time
+  expect(elapsed_time).to be >= min_elapsed_time
+end
+
+Then /^it should take less than (\S+) seconds$/ do |s|
+  max_elapsed_time = s.to_f
+  elapsed_time = Time.now - @start_time
+  expect(elapsed_time).to be < max_elapsed_time
+end

data/features/step_definitions/type.rb

@@ -0,0 +1,15 @@
+When /^the client successfully sets type "(.*?)"$/ do |type|
+  client.raw 'TYPE', type
+end
+
+When /^the client sets type "(.*?)"$/ do |type|
+  capture_error do
+    step %Q'the client successfully sets type "#{type}"'
+  end
+end
+
+When /^the client sets type with no parameter$/ do
+  capture_error do
+    client.raw 'TYPE'
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'ftpd'
+require 'stringio'

data/features/support/example_server.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+require 'forwardable'
+require File.expand_path('test_server_files',
+                         File.dirname(__FILE__))
+
+class ExampleServer
+
+  extend Forwardable
+  include FileUtils
+  include TestServerFiles
+
+  def initialize(args = nil)
+    command = [
+      File.expand_path('../../examples/example.rb',
+                       File.dirname(__FILE__)),
+      args,
+    ].join(' ')
+    @io = IO.popen(command, 'r+')
+    @output = read_output
+  end
+
+  def stop 
+    @io.close
+  end
+
+  def host
+    @output[/Host: (.*)$/, 1]
+  end
+
+  def port
+    @output[/Port: (.*)$/, 1].to_i
+  end
+
+  def user
+    @output[/User: "(.*)"$/, 1]
+  end
+
+  def password
+    @output[/Pass: "(.*)"$/, 1]
+  end
+
+  def account
+    @output[/Account: "(.*)"$/, 1]
+  end
+
+  def auth_level
+    Ftpd::AUTH_PASSWORD
+  end
+
+  private
+
+  def read_output
+    output = ''
+    loop do
+      line = @io.gets
+      break if line.nil?
+      output << line
+      break if line =~ /FTP server started/
+    end
+    output
+  end
+
+  def temp_dir
+    @output[/Directory: (.*)$/, 1]
+  end
+
+end

data/features/support/file_templates/ascii_unix

@@ -0,0 +1,4 @@
+Billy was a chemist
+but Billy is no more
+For what he thought was H2O
+Was H2SO4

data/features/support/file_templates/ascii_windows

@@ -0,0 +1,4 @@
+Billy was a chemist
+but Billy is no more
+For what he thought was H2O
+Was H2SO4

data/features/support/test_client.rb

@@ -0,0 +1,250 @@
+require 'double_bag_ftps'
+require 'net/ftp'
+
+class TestClient
+
+  extend Forwardable
+  include FileUtils
+
+  attr_accessor :tls_mode
+
+  def initialize
+    @tls_mode = :off
+    @temp_dir = Ftpd::TempDir.make
+    @templates = TestFileTemplates.new
+  end
+
+  def start
+    @ftp = make_ftp
+  end
+
+  def close
+    return unless @ftp
+    @ftp.close
+  end
+
+  def_delegators :@ftp,
+  :chdir,
+  :connect,
+  :delete,
+  :getbinaryfile,
+  :gettextfile,
+  :help,
+  :login,
+  :ls,
+  :mkdir,
+  :nlst,
+  :noop,
+  :passive=,
+  :pwd,
+  :quit,
+  :rename,
+  :rmdir,
+  :status,
+  :system
+
+  # Make a connection from a specific IP.  Net::FTP doesn't have a way
+  # to force the local IP, so fake it here.
+
+  def connect_from(source_ip, host, port)
+    in_addr = Socket.pack_sockaddr_in(0, source_ip)
+    out_addr = Socket.pack_sockaddr_in(port, host)
+    socket = Socket.open(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+    socket.bind(in_addr)
+    socket.connect(out_addr)
+    decorate_socket socket
+    @ftp = make_ftp
+    @ftp.set_socket(socket)
+  end
+
+  def raw(*command)
+    @ftp.sendcmd command.compact.join(' ')
+  end
+
+  def get(mode, remote_path)
+    method = "get#{mode}file"
+    @ftp.send method, remote_path, local_path(remote_path)
+  end
+
+  def put(mode, remote_path)
+    method = "put#{mode}file"
+    @ftp.send method, local_path(remote_path), remote_path
+  end
+
+  def get_size(mode, remote_path)
+    raise unless ['binary', 'text'].include?(mode)
+    @ftp.binary = mode == 'binary'
+    override_with_binary do
+      @ftp.size(remote_path)
+    end
+  end
+
+  def get_mtime(remote_path)
+    @ftp.mtime(remote_path)
+  end
+
+  def add_file(path)
+    full_path = temp_path(path)
+    mkdir_p File.dirname(full_path)
+    File.open(full_path, 'wb') do |file|
+      file.write @templates[File.basename(full_path)]
+    end
+  end
+
+  def template(path)
+    @templates[File.basename(path)]
+  end
+
+  def file_contents(path)
+    File.open(temp_path(path), 'rb', &:read)
+  end
+
+  def xpwd
+    response = @ftp.sendcmd('XPWD')
+    response[/"(.+)"/, 1]
+  end
+
+  def store_unique(local_path, remote_path)
+    command = ['STOU', remote_path].compact.join(' ')
+    File.open(temp_path(local_path), 'rb') do |file|
+      @ftp.storbinary command, file, Net::FTP::DEFAULT_BLOCKSIZE
+    end
+  end
+
+  def append_binary(local_path, remote_path)
+    command = ['APPE', remote_path].compact.join(' ')
+    File.open(temp_path(local_path), 'rb') do |file|
+      @ftp.storbinary command, file, Net::FTP::DEFAULT_BLOCKSIZE
+    end
+  end
+
+  def append_text(local_path, remote_path)
+    command = ['APPE', remote_path].compact.join(' ')
+    File.open(temp_path(local_path), 'rb') do |file|
+      @ftp.storlines command, file
+    end
+  end
+
+  def connected?
+    begin
+      @ftp.noop
+      true
+    rescue Net::FTPTempError => e
+      !!e.to_s =~ /^421/
+    rescue EOFError
+      false
+    end
+  end
+
+  def set_option(option)
+    @ftp.sendcmd "OPTS #{option}"
+  end
+
+  private
+
+  RAW_METHOD_REGEX = /^send_(.*)$/
+
+  def local_path(remote_path)
+    temp_path(File.basename(remote_path))
+  end
+
+  def temp_path(path)
+    File.expand_path(path, @temp_dir)
+  end
+
+  def make_ftp
+    ftp =
+      case @tls_mode
+      when :off
+        make_non_tls_ftp
+      when :implicit
+        make_tls_ftp(:implicit)
+      when :explicit
+        make_tls_ftp(:explicit)
+      else
+        raise "Unknown TLS mode: #{@tls_mode}"
+      end
+    allow_size_in_ascii_mode ftp
+    ftp
+  end
+
+  def make_tls_ftp(ftps_mode)
+    ftp = DoubleBagFTPS.new
+    context_opts = {
+      :verify_mode => OpenSSL::SSL::VERIFY_NONE
+    }
+    ftp.ssl_context = DoubleBagFTPS.create_ssl_context(context_opts)
+    ftp.ftps_mode = ftps_mode
+    ftp
+  end
+
+  def make_non_tls_ftp
+    Net::FTP.new
+  end
+
+  # Ruby FTP client forces binary mode when doing a SIZE command.  Our
+  # tests want to check that the server's SIZE command works correctly
+  # in ASCII mode as well, so we'll monkey-patch the FTP client.
+
+  def allow_size_in_ascii_mode(ftp)
+
+    class << ftp
+
+      attr_accessor :override_with_binary
+
+      alias :orig_with_binary :with_binary
+
+      def with_binary(*args, &block)
+        if @override_with_binary
+          block.call
+        else
+          return orig_with_binary(*args, &block)
+        end
+      end
+
+    end
+
+  end
+
+  def override_with_binary
+    orig = @ftp.override_with_binary
+    begin
+      @ftp.override_with_binary = true
+      yield
+    ensure
+      @ftp.override_with_binary = orig
+    end
+  end
+
+  # Ruby 2.0's Ftp class is expecting a TCPSocket, not a Socket.  The
+  # trouble comes with Ftp#close, which closes sockets by first doing
+  # a shutdown, setting the read timeout, and doing a read.  Plain
+  # Socket doesn't have those methods, so fake it.
+  #
+  # Plain socket _does_ have #close, but we short-circuit it, too,
+  # because it takes a few seconds.  We're in a hurry when running
+  # tests, and can afford to be a little sloppy when cleaning up.
+
+  def decorate_socket(sock)
+
+    def sock.shutdown(how)
+      @shutdown = true
+    end
+
+    def sock.read_timeout=(seconds)
+    end
+
+    # Skip read after shutdown.  Prevents 2.0 from hanging in
+    # Ftp#close
+
+    def sock.read(*args)
+      return if @shutdown
+      super(*args)
+    end
+
+    def close
+    end
+
+  end
+
+end

data/features/support/test_file_templates.rb

@@ -0,0 +1,33 @@
+class TestFileTemplates
+
+  def [](filename)
+    if have_template?(filename)
+      read_template filename
+    else
+      default_template filename
+    end
+  end
+
+  private
+
+  def have_template?(filename)
+    File.exists?(template_path(filename))
+  end
+
+  def read_template(filename)
+    File.open(template_path(filename), 'rb', &:read)
+  end
+
+  def template_path(filename)
+    File.expand_path(filename, templates_path)
+  end
+
+  def templates_path
+    File.expand_path('file_templates', File.dirname(__FILE__))
+  end
+
+  def default_template(filename)
+    "Contents of #{filename}"
+  end
+
+end

data/features/support/test_server.rb

@@ -0,0 +1,293 @@
+require 'fileutils'
+require 'forwardable'
+require 'stringio'
+require 'tempfile'
+
+require File.expand_path('test_server_files',
+                         File.dirname(__FILE__))
+
+class TestServer
+  class TestServerDriver
+
+    extend Forwardable
+
+    USER = 'user'
+    PASSWORD = 'password'
+    ACCOUNT = 'account'
+
+    attr_accessor :append
+    attr_accessor :delete
+    attr_accessor :list
+    attr_accessor :mkdir
+    attr_accessor :read
+    attr_accessor :rename
+    attr_accessor :rmdir
+    attr_accessor :write
+
+    def initialize(temp_dir)
+      @temp_dir = temp_dir
+      @append = true
+      @delete = true
+      @list = true
+      @mkdir = true
+      @read = true
+      @rename = true
+      @rmdir = true
+      @write = true
+    end
+
+    def authenticate(user, password, account)
+      user == USER &&
+        (password.nil? || password == PASSWORD) &&
+        (account.nil? || account == ACCOUNT)
+    end
+
+    def file_system(user)
+      TestServerFileSystem.new(@temp_dir,
+                               :append => @append,
+                               :delete => @delete,
+                               :list => @list,
+                               :mkdir => @mkdir,
+                               :read => @read,
+                               :rename => @rename,
+                               :rmdir => @rmdir,
+                               :write => @write)
+    end
+
+  end
+end
+
+class TestServer
+
+  module ForcesAccessDenied
+
+    def self.included(includer)
+      includer.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def return_false_on_force_access_denied(method_name)
+        original_method = instance_method(method_name)
+        define_method method_name do |*args|
+          ftp_path = args.first
+          return false if force_access_denied?(ftp_path)
+          original_method.bind(self).call *args
+        end
+      end
+
+    end
+
+    def force_access_denied?(ftp_path)
+      ftp_path =~ /forbidden/
+    end
+
+  end
+
+end
+
+class TestServer
+
+  module ForcesFileSystemError
+
+    def self.included(includer)
+      includer.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def raise_on_file_system_error(method_name)
+        original_method = instance_method(method_name)
+        define_method method_name do |*args, &block|
+          ftp_path = args.first
+          if force_file_system_error?(ftp_path)
+            raise Ftpd::PermanentFileSystemError, 'Unable to do it'
+          end
+          original_method.bind(self).call *args, &block
+        end
+      end
+
+      def return_true_on_file_system_error(method_name)
+        original_method = instance_method(method_name)
+        define_method method_name do |*args, &block|
+          ftp_path = args.first
+          return true if force_file_system_error?(ftp_path)
+          original_method.bind(self).call *args, &block
+        end
+      end
+
+    end
+
+    def force_file_system_error?(ftp_path)
+      ftp_path =~ /unable/
+    end
+
+  end
+end
+
+class TestServer
+  class TestServerFileSystem
+
+    # In order to test ftpd's ability to adapt itself to the driver's
+    # signature, we create a new, anonymous instance of the file
+    # system class for each test.  The option flags determine whether
+    # or not to mix in certain behavior such as writing files, reading
+    # files, etc.
+
+    def self.new(data_dir, opts)
+      Class.new do
+
+        include ForcesAccessDenied
+        include ForcesFileSystemError
+
+        include Ftpd::DiskFileSystem::Base
+
+        if opts[:append]
+          include Ftpd::DiskFileSystem::Append
+          raise_on_file_system_error :append
+        end
+
+        if opts[:delete]
+          include Ftpd::DiskFileSystem::Delete
+          raise_on_file_system_error :delete
+        end
+
+        if opts[:list]
+          include Ftpd::DiskFileSystem::List
+        end
+
+        if opts[:mkdir]
+          include Ftpd::DiskFileSystem::Mkdir
+        end
+
+        if opts[:read]
+          include Ftpd::DiskFileSystem::Read
+          raise_on_file_system_error :read
+        end
+
+        if opts[:rename]
+          include Ftpd::DiskFileSystem::Rename
+          raise_on_file_system_error :rename
+        end
+
+        if opts[:rmdir]
+          include Ftpd::DiskFileSystem::Rmdir
+        end
+
+        if opts[:write]
+          include Ftpd::DiskFileSystem::Write
+          raise_on_file_system_error :write
+        end
+
+        def initialize(data_dir)
+          set_data_dir data_dir
+          translate_exception SystemCallError
+        end
+
+        return_false_on_force_access_denied :accessible?
+
+        return_true_on_file_system_error :accessible?
+        return_true_on_file_system_error :exists?
+        return_true_on_file_system_error :directory?
+
+      end.new(data_dir)
+    end
+
+  end
+end
+
+class TestServer
+
+  extend Forwardable
+  include FileUtils
+  include Ftpd::InsecureCertificate
+  include TestServerFiles
+
+  attr_writer :logging
+
+  def initialize
+    @temp_dir = Ftpd::TempDir.make
+    @log_device = StringIO.new
+    @driver = TestServerDriver.new(@temp_dir)
+    @server = Ftpd::FtpServer.new(@driver)
+    @server.certfile_path = insecure_certfile_path
+    @templates = TestFileTemplates.new
+    self.tls = :off
+  end
+
+  def_delegator :@server, :'allow_low_data_ports='
+  def_delegator :@server, :'auth_level'
+  def_delegator :@server, :'auth_level='
+  def_delegator :@server, :'failed_login_delay='
+  def_delegator :@server, :'interface='
+  def_delegator :@server, :'max_connections='
+  def_delegator :@server, :'max_connections_per_ip='
+  def_delegator :@server, :'max_failed_logins='
+  def_delegator :@server, :'server_name'
+  def_delegator :@server, :'server_name='
+  def_delegator :@server, :'session_timeout='
+  def_delegator :@server, :'tls='
+
+  def_delegator :@driver, :'append='
+  def_delegator :@driver, :'delete='
+  def_delegator :@driver, :'list='
+  def_delegator :@driver, :'mkdir='
+  def_delegator :@driver, :'rmdir='
+  def_delegator :@driver, :'read='
+  def_delegator :@driver, :'rename='
+  def_delegator :@driver, :'write='
+
+  def log_output
+    @log_device.string
+  end
+
+  def start
+    @server.log = make_log
+    @server.start
+  end
+
+  def stop
+    @server.stop
+  end
+
+  def host
+    @server.interface
+  end
+
+  def user
+    TestServerDriver::USER
+  end
+
+  def password
+    TestServerDriver::PASSWORD
+  end
+
+  def account
+    TestServerDriver::ACCOUNT
+  end
+
+  def port
+    @server.bound_port
+  end
+
+  def template(path)
+    @templates[File.basename(path)]
+  end
+
+  private
+
+  def temp_dir
+    @temp_dir
+  end
+
+  def make_log
+    if @logging
+      Logger.new(@log_device)
+    elsif ENV['FTPD_DEBUG'].to_i != 0
+      Logger.new($stdout)
+    else
+      nil
+    end
+  end
+
+end