ftpd 2.0.1 → 2.0.2

data/features/support/env.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH << File.expand_path('../../lib', File.dirname(__FILE__))
-
-require 'ftpd'
-require 'stringio'

data/features/support/example_server.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-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 = ''.dup
-    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

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

data/features/support/file_templates/ascii_windows

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

data/features/support/test_client.rb

@@ -1,258 +0,0 @@
-# frozen_string_literal: true
-
-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
-    @ftp = nil
-  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 ftp
-    raise "Not started" unless @ftp
-    @ftp
-  end
-
-  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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-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)
-    @templates = TestFileTemplates.new
-  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, :'nat_ip='
-  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 server
-    @server ||= make_server
-  end
-
-  def make_server
-    s = Ftpd::FtpServer.new(@driver)
-    s.certfile_path = insecure_certfile_path
-    s.tls = :off
-    s
-  end
-
-  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