testftpd 0.1.1

data/bin/testftpd

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/testftpd'
+require 'optparse'
+
+options = { :root_dir => File.expand_path('.'), :port => 21 }
+OptionParser.new do |opts|
+  opts.on(
+    '-r', '--root <ROOT_DIR>',
+    'Serve files from <ROOT_DIR>, defaults to the current directory.'
+  ) do |root_dir|
+    options[:root_dir] = root_dir
+  end
+  
+  opts.on(
+    '-p', '--port <FTP_PORT>',
+    'Listen for connections on <FTP_PORT>, defaults to 21.'
+  ) do |ftp_port|
+    options[:port] = ftp_port
+  end
+end.parse!
+
+puts 'Starting TestFTPd::Server...'
+puts "Root Directory: '#{options[:root_dir]}'"
+puts "      TCP Port: #{options[:port]}"
+
+begin
+  TestFtpd::Server.new(options).start
+rescue Exception => e
+  puts 'There was a problem starting the FTP process...'
+  puts e.message
+  exit!(255)
+end
+
+begin
+  sleep 0.1 while true
+rescue Interrupt
+  puts 'Interrupted.'
+end

data/lib/testftpd/file_system_provider.rb

@@ -0,0 +1,81 @@
+module TestFtpd
+
+  class FileSystemProvider
+    attr_reader :path, :ftp_name, :ftp_size, :ftp_date
+
+    def initialize(path)
+      @path = path
+      @ftp_name = path.split('/').last
+      @ftp_name = '/' unless @ftp_name
+      @ftp_dir = File.directory?(path)
+      @ftp_size = File.size?(path)
+      @ftp_size = 0 unless @ftp_size
+      @ftp_date = Time.now
+      @ftp_date = File.mtime(path) if File.exists?(path)
+    end
+
+    def directory?
+      @ftp_dir
+    end
+
+    def ftp_parent(root = nil)
+      return root if root && root.path == path
+      path_parts = path.split('/')
+      return nil unless path_parts.pop
+      return nil if path_parts.size <= 1
+      FileSystemProvider.new(path_parts.join('/'))
+    end
+
+    def ftp_list(filter = nil)
+      if filter
+        if File.directory?(File.join(path, filter))
+          entries = Dir.entries(File.join(path, filter)).map { |name| File.join(filter, name) }
+        else
+          entries = Dir.glob(File.join(path, filter)).map { |name| File.basename(name) }
+        end
+      else
+        entries = Dir.entries(path)
+      end
+      entries = entries.reject { |name| %w{. ..}.include?(File.basename(name)) }
+      entries.map do |name|
+        FileSystemProvider.new(File.join(path, name))
+      end
+    end
+
+    def ftp_create(name, dir = false)
+      return FileSystemProvider.new(path + '/' + name) unless dir
+      Dir.mkdir(path + '/' + name)
+      FileSystemProvider.new(path + '/' + name)
+    rescue
+      return false
+    end
+
+    def ftp_retrieve(output)
+      File.open(path, 'r') { |io| output << io.read }
+    end
+
+    def ftp_store(input)
+      return false unless File.open(path, 'w') do |f|
+        f.write input.read
+      end
+      @ftp_size = File.size?(path)
+      @ftp_date = File.mtime(path) if File.exists?(path)
+    end
+
+    def ftp_rename(to_name)
+      to_path = File.join(File.dirname(path), to_name)
+      FileUtils.mv(path, to_path)
+      true
+    end
+
+    def ftp_delete(dir = false)
+      if dir
+        FileUtils.remove_dir(path)
+      else
+        FileUtils.remove_file(path)
+      end
+      true
+    end
+  end
+
+end

data/lib/testftpd/server.rb

@@ -0,0 +1,44 @@
+require_relative '../../vendor/dyn-ftp-serv/dynftp_server'
+require_relative 'file_system_provider'
+
+require 'timeout'
+
+Thread.abort_on_exception = true
+
+module TestFtpd
+
+  class Server < DynFTPServer
+    def initialize(config = {})
+      config.merge!(:root => FileSystemProvider.new(config[:root_dir]))
+      @ftp_thread = nil
+      super(config)
+    end
+
+    def running?
+      @ftp_thread && @ftp_thread.alive?
+    end
+
+    def start(timeout = 2)
+      Timeout.timeout(timeout) do
+        return if @ftp_thread
+        @ftp_thread = Thread.new { mainloop }
+        sleep 0.1 until running?
+      end
+    rescue TimeoutError
+      raise TimeoutError.new('TestFtpd::Server timeout before start succeeded.')
+    end
+
+    def shutdown(timeout = 2)
+      Timeout.timeout(timeout) do
+        @server.close unless @server.closed?
+        return if @ftp_thread.nil?
+        @ftp_thread.kill
+        sleep 0.1 while running?
+        @ftp_thread = nil
+      end
+    rescue TimeoutError
+      raise TimeoutError.new('TestFtpd::Server timeout before shutdown succeeded.')
+    end
+  end
+
+end

data/lib/testftpd/version.rb

@@ -0,0 +1,3 @@
+module TestFtpd
+  VERSION = '0.1.1'
+end

data/lib/testftpd.rb

@@ -0,0 +1,6 @@
+require_relative 'testftpd/file_system_provider'
+require_relative 'testftpd/server'
+
+module TestFtpd
+
+end

data/spec/fixtures/ftproot/subfolder/test_file1

@@ -0,0 +1 @@
+a file in a sub folder

data/spec/fixtures/ftproot/subfolder/test_file2

@@ -0,0 +1 @@
+a file in a sub folder

data/spec/fixtures/ftproot/test_file

@@ -0,0 +1 @@
+welcome to my FTP server

data/spec/fixtures/ftproot/test_file_to_delete

@@ -0,0 +1 @@
+this file will be deleted

data/spec/fixtures/ftproot/test_file_to_rename

@@ -0,0 +1 @@
+this file will be renamed

data/spec/fixtures/test_file_to_upload

@@ -0,0 +1 @@
+test file

data/spec/integration/test_ftp_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+require 'net/ftp'
+require 'tmpdir'
+
+require 'testftpd'
+
+describe TestFtpd do
+  def copy_ftproot(target_path)
+    FileUtils.cp_r(File.join(APP_PATH, 'spec/fixtures/ftproot/.'), target_path)
+  end
+
+  let(:ftp_port) { 21212 }
+  let(:ftp_root) { Dir.mktmpdir('test_ftp_root') }
+
+  subject { TestFtpd::Server.new(port: ftp_port, root_dir: ftp_root) }
+
+  before do
+    subject.start
+    copy_ftproot(ftp_root)
+  end
+
+  after do
+    subject.shutdown
+    FileUtils.rm_rf(ftp_root)
+  end
+
+  context 'before authenticating' do
+    before :each do
+      @ftp = Net::FTP.new
+      @ftp.connect('127.0.0.1', ftp_port)
+    end
+
+    after :each do
+      @ftp.close
+    end
+
+    it 'sends unauthorised message' do
+      expect { @ftp.list }.to raise_error(Net::FTPPermError, /Not logged in/)
+    end
+  end
+
+  context 'after authenticating' do
+    before :each do
+      @ftp = Net::FTP.new
+      @ftp.connect('127.0.0.1', ftp_port)
+      @ftp.login('username', 'password')
+    end
+
+    after :each do
+      @ftp.close
+    end
+
+    context 'when listing files' do
+      it 'can list remote files' do
+        files = @ftp.list
+        files.count.should eq(5)
+        files.any? { |file| file =~ /test_file/ }.should be_true
+      end
+
+      it 'can list a specific file' do
+        files = @ftp.list('test_file')
+        files.count.should eq(1)
+        files[0].should =~ /test_file/
+      end
+
+      it 'can list a specific file in a subfolder' do
+        files = @ftp.list('subfolder/test_file1')
+        files.count.should eq(1)
+        files[0].should =~ /test_file1/
+      end
+
+      it 'can list a sub folder' do
+        files = @ftp.list('subfolder')
+        files.count.should eq(3)
+        files.any? { |file| file =~ /test_file1/ }.should be_true
+      end
+    end
+
+    it 'can query the current remote directory' do
+      @ftp.pwd.should eq('/')
+    end
+
+    it 'can nlst remote files' do
+      pending 'nlst command not implemented yet'
+    end
+
+    it 'can query modified time of remote file' do
+      modified_time = File.mtime(File.join(ftp_root, 'test_file')).strftime('%Y%m%d%H%M%S')
+      @ftp.mdtm('test_file').should eql(modified_time)
+    end
+
+    it 'can query size of remote file' do
+      size = File.size(File.join(ftp_root, 'test_file'))
+      @ftp.size('test_file').should eq(size)
+    end
+
+    context 'when downloading a file' do
+      it 'can use binary mode' do
+        filename = 'test_file'
+        local_filepath = File.join(Dir.tmpdir, filename)
+        @ftp.binary = true
+        @ftp.get('test_file', local_filepath)
+        File.exists?(local_filepath).should be_true
+      end
+
+      it 'can use text mode' do
+        filename = 'test_file'
+        local_filepath = File.join(Dir.tmpdir, filename)
+        @ftp.binary = false
+        @ftp.get('test_file', local_filepath)
+        File.exists?(local_filepath).should be_true
+      end
+
+      it 'can use passive mode' do
+        filename = 'test_file'
+        local_filepath = File.join(Dir.tmpdir, filename)
+        @ftp.passive = true
+        @ftp.get('test_file', local_filepath)
+        File.exists?(local_filepath).should be_true
+      end
+    end
+
+    context 'when changing folders' do
+      it 'can change into sub folders' do
+        @ftp.chdir('subfolder')
+        @ftp.pwd.should eq(File.join(ftp_root, 'subfolder'))
+      end
+
+      it 'can change into parent folder' do
+        @ftp.chdir('subfolder')
+        @ftp.chdir('..')
+        @ftp.pwd.should eq(ftp_root)
+      end
+
+      it 'does not allow folders outside the ftp root folder' do
+        @ftp.chdir('..')
+        @ftp.pwd.should eq('/')
+      end
+    end
+
+    it 'can create a remote folder' do
+      @ftp.mkdir('new_subfolder')
+      Dir.exists?(File.join(ftp_root, 'new_subfolder')).should be_true
+    end
+
+    it 'can upload a file' do
+      filename = 'test_file_to_upload'
+      local_filepath = File.join(APP_PATH, 'spec/fixtures', filename)
+      @ftp.put(local_filepath, filename)
+      File.exists?(File.join(ftp_root, filename)).should be_true
+    end
+
+    it 'can delete a remote file' do
+      @ftp.delete('test_file_to_delete')
+      File.exists?(File.join(ftp_root, 'test_file_to_delete')).should be_false
+    end
+
+    it 'can rename a remote file' do
+      @ftp.rename('test_file_to_rename', 'test_file_renamed')
+      File.exists?(File.join(ftp_root, 'test_file_renamed')).should be_true
+    end
+
+    it 'can delete a remote folder' do
+      @ftp.rmdir('subfolder_to_delete')
+      File.exists?(File.join(ftp_root, 'subfolder_to_delete')).should be_false
+    end
+
+    it 'responds correctly to unrecognized commands' do
+      expect { @ftp.sendcmd('asdf') }.to raise_error(Net::FTPPermError, /command unrecognized/)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+
+APP_PATH = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.root(APP_PATH)
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+
+  end
+
+  config.before(:each) do
+
+  end
+end

data/spec/unit/testftpd/server_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+require 'testftpd'
+
+describe TestFtpd::Server do
+
+  let(:ftp_port) { 21212 }
+  let(:ftp_root) { APP_PATH }
+
+  subject { TestFtpd::Server.new(port: ftp_port, root_dir: ftp_root) }
+
+  after :each do
+    subject.shutdown
+  end
+
+  describe '.start(timeout = 2)' do
+    it 'raises exception if ftp process does not start within timeout' do
+      Thread.stub(:new) { sleep 0.5 }
+      expect { subject.start(0.1) }.to raise_error(TimeoutError)
+    end
+  end
+
+  describe '.start(timeout = 2)' do
+    it 'raises exception if ftp process does not shutdown within timeout' do
+      subject.start
+      expect { subject.shutdown(0.01) }.to raise_error(TimeoutError)
+    end
+  end
+
+end

data/vendor/dyn-ftp-serv/CHANGELOG

@@ -0,0 +1,15 @@
+2013-03-09 ftp-dyn-serv 0.1.3 (Christian Schulze)
+  Added rename file commands (rnfr/rnto)
+  Added remove directory command (rmd)
+  minor code improvements
+
+2007-11-11 ftp-dyn-serv 0.1.2
+  Added ip masquerading feature.
+  Added settings for minimum and maximum passive port numbers.
+  Fixed issue with authentication.
+
+2007-11-09 ftp-dyn-serv 0.1.1
+  Updated rdoc comments.
+
+2007-11-09 ftp-dyn-serv 0.1.0
+  Initial release.

data/vendor/dyn-ftp-serv/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2007 Rubtsov Vitaly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/vendor/dyn-ftp-serv/dynftp_server.rb

@@ -0,0 +1,478 @@
+# :title:Dynamic FTP server in pure Ruby (dyn-ftp-serv)
+# Version:: 0.1.2
+# Author:: Rubtsov Vitaly (vlrubtsov *at* gmail.com)
+# License:: MIT license
+# Website:: http://rubyforge.org/projects/dyn-ftp-serv/
+#
+# This ftp server implementation features an ability to host any content you want.
+# You are not limited to hosting files and directories via FTP interface.
+# With dyn-ftp-serv you are able to represent any hierarchy under the guise of
+# standard files and directories. You will be able to download and upload files
+# and browse dynamic directories.
+# To work with dyn-ftp-serv you must have an object responding to special ftp messages
+# that will represent the ftp content. You can create a new object or extend the
+# existing one with special messages.
+# There are two sets of messages to be handled: directory messages and file messages.
+# Directory messages are:
+# [+directory?+] must return true.
+# [+ftp_name+] must return the name of a directory
+# [+ftp_size+] must return size for directory
+# [+ftp_date+] must return the date for a directory
+# [+ftp_parent+] must return parent object or nil if root
+# [+ftp_list+] must return an array of ftp objects
+# [<tt>ftp_create(name, dir = false)</tt>]
+#     must return a new object created with the 'name' given.
+#     It can be file (dir=false) or a directory (dir=true). It can return nil if creating is
+#     forbidden.  
+# [+ftp_delete+] directory deletion request. must return true on success, and false on failure.
+# File messages are:
+# [+directory?+] must return false
+# [+ftp_name+] must return the name of a file
+# [+ftp_size+] must return filesize
+# [+ftp_date+] must return filedate
+# [<tt>ftp_retrieve(output)</tt>] streams file contents via output socket.
+# [<tt>ftp_store(input)</tt>] writes file contents reading from a socket
+# [+ftp_delete+] file deletion request. must return true on success, and false on failure.
+#
+# Please, see an example in 'examples' folder showing an implementation of standard file system
+# ftp server.
+
+require 'socket'
+
+class DynFTPServer
+
+  attr_reader :config
+  
+  # Class to instantiate if logger is not given.
+  class DummyLogger
+    def method_missing(method_name, *args, &block); end
+  end
+
+  # Pass a hash containing options.
+  # [<tt>:host</tt>] Local bind address. Default is <em>'0.0.0.0'</em>.
+  # [<tt>:port</tt>] Port to listen. Default is <em>21</em>.
+  # [<tt>:masquerade_ip</tt>] IP masquerade for passive connections. Use this settings if you are behind a firewall and set it to the external ip address.
+  # [<tt>:pasv_min_port</tt>] Minimum port num for passive connections.
+  # [<tt>:pasv_max_port</tt>] Maximum port num for passive connections.
+  # [<tt>:root</tt>] Root ftp object.
+  # [<tt>:authentication</tt>] Function used to check users login information.
+  # [<tt>:logger</tt>] Logger object.
+  def initialize(config)
+    @config = defaults.merge(config)
+    raise(ArgumentError, 'Root object must not be null.') unless @config[:root]
+    @server = TCPServer.new(@config[:host], @config[:port])
+  end
+
+  def defaults
+    {
+      host:           '',
+      port:           21,
+      masquerade_ip:  nil,
+      pasv_min_port:  1024,
+      pasv_max_port:  65535,
+      root:           nil,
+      authentication: ->(user, pass) { return true },
+      logger:         nil
+    }
+  end
+
+  def mainloop
+    threads = []
+    log.debug 'Waiting for connection'
+    while (session = @server.accept)
+      log.debug "Accepted connection from #{session.addr.join(', ')}"
+      threads << Thread.new(session) do |s|
+        thread[:socket] = s
+        client_loop
+      end
+    end
+    threads.each {|t| t.join }
+  end
+  
+  private
+
+  def log
+    return config[:logger] if config[:logger]
+    DummyLogger.new
+  end
+  
+  def not_implemented
+    status(500)
+  end
+
+  def not_authorized
+    status(530)
+  end
+  
+  def status(code, description = nil)
+    unless description.nil?
+      message = "#{code.to_s} #{description}"
+      log.debug "Response: #{message}"
+      thread[:socket].puts "#{message}\r\n"
+      return
+    end
+    case code.to_i
+    when 125
+      status(code, 'Data connection already open; transfer starting.')
+    when 150
+      status(code, 'File status okay; about to open data connection.')
+    when 200
+      status(code, 'Command okey.')
+    when 226
+      status(code, 'Closing data connection.')
+    when 230
+      status(code, 'User logged in, proceed.')
+    when 250
+      status(code, 'Requested file action okay, completed.')
+    when 331
+      status(code, 'User name okay, need password.')
+    when 350
+      status(code, 'RNFR completed, continue with RNTO.')
+    when 425
+      status(code, "Can't open data connection.")
+    when 500
+      status(code, 'Syntax error, command unrecognized.')
+    when 502
+      status(code, 'Command not implemented.')
+    when 530
+      status(code, 'Not logged in.')
+    when 550
+      status(code, 'Requested action not taken.')
+    else
+      status(code, '')
+    end
+  end
+  
+  def data_connection(&block)
+    client_socket = nil
+    if thread[:passive]
+      unless IO.select([thread[:data_socket]], nil, nil, 60000)
+        status(425)
+        return false
+      end
+      client_socket = thread[:data_socket].accept
+      status(150)
+    else
+      client_socket = thread[:data_socket]
+      status(125)
+    end
+    yield(client_socket)
+    return true
+  ensure
+    client_socket.close if client_socket && thread[:passive]
+    client_socket = nil    
+  end
+
+  def passive_server
+    server = nil
+    port = config[:pasv_min_port]
+    while server.nil? && (port <= config[:pasv_max_port])
+      begin
+        server = TCPServer.new(config[:host], port)
+      rescue Errno::EADDRINUSE
+        log.error "#{port} is already in use. Trying next port."
+      end
+      port += 1
+    end
+    server
+  end
+  
+  def open_object(path)
+    if (path[0,1] == '/') || (path.is_a?(Array) && (path[0] == ''))
+      dir = config[:root]
+    else
+      dir = thread[:cwd]
+    end
+    path = path.split('/') unless path.is_a?(Array)
+    return dir if path.empty?
+    last_element = path.pop
+    path.each do |p|
+      unless p == ''
+        dir = dir.ftp_list.detect {|d| (d.ftp_name.casecmp(p) == 0) && (d.directory?) }
+        return nil unless dir
+      end
+    end    
+    dir.ftp_list.detect {|d| (d.ftp_name.casecmp(last_element) == 0) } unless last_element == ''
+  end
+  
+  def open_path(path)
+    result = open_object(path)
+    result = nil if result && !result.directory?
+    result
+  end
+  
+  def open_file(path)
+    result = open_object(path)
+    result = nil if result && result.directory?
+    result
+  end
+  
+  def get_path(object)
+    return '/' unless object
+    return '/' if object == config[:root]
+    result = ''    
+    while object do
+      result = '/' + object.ftp_name + result
+      object = object.ftp_parent
+    end
+    result
+  end
+
+  def get_quoted_path(object)
+    get_path(object).gsub('"', '""')
+  end
+
+  def thread
+    Thread.current
+  end
+
+  # Commands
+  
+  def cmd_cdup(params)
+    thread[:cwd] = thread[:cwd].ftp_parent(config[:root])
+    thread[:cwd] = config[:root] unless thread[:cwd]
+    status(250, 'Directory successfully changed.')
+  end
+  
+  def cmd_cwd(path)
+    if path == '.'
+      status(250, 'Directory successfully changed.')
+    elsif (newpath = open_path(path))
+      thread[:cwd] = newpath
+      status(250, 'Directory successfully changed.')
+    else
+      status(550, 'Failed to change directory.')
+    end
+  end
+  
+  def cmd_dele(path)
+    if (file = open_file(path)) && file.ftp_delete
+      status 250
+    else
+      status(550, 'Delete operation failed.')
+    end
+  end
+  
+#  def cmd_feat(params)
+#    thread[:socket].puts "211-Features\r\n"
+#    thread[:socket].puts " UTF8\r\n"
+#    thread[:socket].puts "211 end\r\n"
+#  end
+  
+  def cmd_list(file_spec)
+    data_connection do |data_socket|
+      list = thread[:cwd].ftp_list(file_spec)
+      list.each {|file| data_socket.puts(((file.directory?) ? 'd': '-') + 'rw-rw-rw- 1 ftp ftp ' + file.ftp_size.to_s + ' ' + file.ftp_date.strftime('%b %d %H:%M') + ' ' + file.ftp_name + "\r\n") }
+    end
+    thread[:data_socket].close if thread[:data_socket]
+    thread[:data_socket] = nil
+    
+    status(226, 'Transfer complete')
+  end
+  
+  def cmd_mdtm(path)
+    file = open_file(path)
+    if file
+      status(213, file.ftp_date.strftime('%Y%m%d%H%M%S'))
+    else
+      status(550, 'Could not get modification time.')
+    end
+  end
+  
+  def cmd_mkd(path)
+    dir = open_object(path)
+    if dir
+      status(521, 'Directory already exists')
+      return
+    end
+    splitted_path = path.split('/')
+    mkdir = splitted_path.pop
+    dir = open_path(splitted_path)
+    if dir and (newdir = dir.ftp_create(mkdir, true))
+      status(257, '"' + get_quoted_path(newdir) + '" directory created.')
+    else
+      status(550)
+    end
+  end
+  
+  def cmd_pass(pass)
+    thread[:pass] = pass
+    if config[:authentication].call(thread[:user], thread[:pass])
+      thread[:authenticated] = true
+      status(230)
+    else
+      thread[:authenticated] = false
+      not_authorized
+    end
+  end
+  
+  def cmd_pasv(params)
+    if thread[:data_socket]
+      thread[:data_socket].close
+      thread[:data_socket] = nil
+    end
+    thread[:data_socket] = passive_server
+    return status(425) if thread[:data_socket].nil?
+    thread[:passive] = true
+    port = thread[:data_socket].addr[1]
+    port_lo = port & '0x00FF'.hex
+    port_hi = port >> 8
+    ip = thread[:data_socket].addr[3]
+    ip = config[:masquerade_ip] if config[:masquerade_ip]
+    ip = ip.split('.')
+    status(227, "Entering Passive Mode (#{ip[0]},#{ip[1]},#{ip[2]},#{ip[3]},#{port_hi},#{port_lo})")
+  end
+  
+  def cmd_port(ip_port)
+    s = ip_port.split(',')
+    port = s[4].to_i * 256 + s[5].to_i
+    host = s[0..3].join('.')
+    if thread[:data_socket]
+      thread[:data_socket].close
+      thread[:data_socket] = nil
+    end
+    thread[:data_socket] = TCPSocket.new(host, port)
+    thread[:passive] = false
+    status(200, "Passive connection established (#{port})")
+  end
+  
+  def cmd_pwd(params)
+    status(257, "\"#{get_quoted_path(thread[:cwd])}\" is the current directory")
+  end
+  
+  def cmd_rmd(path)
+    dir = open_path(path)
+    if dir && dir.ftp_delete(true)
+      status(250)
+    else
+      status(550, 'Remove directory operation failed.')
+    end
+  end
+  
+  def cmd_quit(params)
+    status(200)
+    thread[:socket].close
+    thread[:socket] = nil
+  end
+
+  def cmd_retr(path)
+    file = open_file(path)
+    if file
+      data_connection do |data_socket|
+        if file.ftp_retrieve(data_socket)
+          status(226, 'Transfer complete')
+        else
+          status(550, 'Failed to open file.')
+        end
+      end      
+    else
+      status(550, 'Failed to open file.')
+    end
+
+    thread[:data_socket].close if thread[:data_socket]
+    thread[:data_socket] = nil    
+  end
+  
+  def cmd_size(path)
+    file = open_file(path)
+    if file
+      status(213, file.ftp_size.to_s)
+    else
+      status(550, 'Could not get file size.')
+    end     
+  end
+  
+  def cmd_stor(path)
+    file = open_file(path)
+    if file
+      status(553, 'Could not create file.')
+      return
+    end
+    unless file
+      splitted_path = path.split('/')
+      filename = splitted_path.pop
+      dir = open_path(splitted_path)
+      file = dir.ftp_create(filename) if dir      
+    end
+    if file
+      data_connection do |data_socket|
+        file.ftp_store(data_socket)
+      end
+      status(226, 'Transfer complete')
+    else
+      status(550, 'Failed to open file.')
+    end
+
+    thread[:data_socket].close if thread[:data_socket]
+    thread[:data_socket] = nil
+  end
+
+  def cmd_rnfr(from_name)
+    file = open_file(from_name)
+    if file
+      @rnfr = file
+      status(350)
+    else
+      status(550, 'Rename from operation failed.')
+    end
+  end
+
+  def cmd_rnto(to_name)
+    if @rnfr
+      @rnfr.ftp_rename(to_name)
+      status(250)
+    else
+      status(550, 'Rename to operation failed.')
+    end
+  end
+  
+  def cmd_syst(params)
+    status(215, 'UNIX')
+  end
+  
+  def cmd_type(type)
+    status(200, 'Type set.')
+  end
+  
+  def cmd_user(user)
+    thread[:user] = user
+    status(331)
+  end
+  
+  def welcome
+    thread[:authenticated] = false
+    thread[:cwd] = config[:root]
+    status(220, 'Microsoft FTP Server ready')
+  end
+  
+  def client_loop
+    welcome
+    while thread[:socket]
+      s = thread[:socket].gets
+      break unless s
+      s.chomp!
+      log.debug "Request: #{s}"
+      params = s.split(' ', 2)
+      command = params.first
+      command.downcase! if command
+      message = "cmd_#{command.to_s}"
+      if self.respond_to?(message, true)
+        if %w[cmd_user cmd_pass].include?(message) || thread[:authenticated]
+          self.send(message, params[1])
+	      else
+          not_authorized
+	      end
+      else
+        not_implemented
+      end
+    end
+  #rescue
+  #  log.error $!
+  ensure
+    thread[:socket].close if thread[:socket] && !thread[:socket].closed?
+    thread[:socket] = nil
+    thread[:data_socket].close if thread[:data_socket] && !thread[:data_socket].closed?
+    thread[:data_socket] = nil
+  end
+ 
+end

data/vendor/dyn-ftp-serv/examples/ftpserv.rb

@@ -0,0 +1,79 @@
+require '../dynftp_server'
+require 'logger'
+
+Thread.abort_on_exception = true
+
+class FSProvider
+  attr_reader :ftp_name, :ftp_size, :ftp_dir, :ftp_date
+
+  def ftp_parent
+    path = @path.split('/')
+    return nil unless path.pop
+    return nil if path.size <= 1
+    return FSProvider.new(path.join('/'))
+  end
+
+  def ftp_list
+    output = Array.new
+    Dir.entries(@path).sort.each do |file|          
+      output << FSProvider.new(@path + (@path == '/'? '': '/') + file)
+    end
+    return output
+  end
+  
+  def ftp_create(name, dir = false)
+    if dir
+      begin
+        Dir.mkdir(@path + '/' + name)
+        return FSProvider.new(@path + '/' + name)
+      rescue
+        return false
+      end
+    else
+      FSProvider.new(@path + '/' + name)
+    end
+    
+  end
+  
+  def ftp_retrieve(output)
+    output << File.new(@path, 'r').read
+  end
+  
+  def ftp_store(input)
+    return false unless File.open(@path, 'w') do |f|
+      f.write input.read
+    end
+    @ftp_size = File.size?(@path)
+    @ftp_date = File.mtime(@path) if File.exists?(@path)
+  end
+  
+  def ftp_delete()
+    return false
+  end
+  
+  def initialize(path)
+    @path = path
+    @ftp_name = path.split('/').last
+    @ftp_name = '/' unless @ftp_name
+    @ftp_dir = File.directory?(path)    
+    @ftp_size = File.size?(path)
+    @ftp_size = 0 unless @ftp_size
+    @ftp_date = Time.now
+    @ftp_date = File.mtime(path) if File.exists?(path)
+  end
+  
+end
+
+
+log  = Logger.new(STDOUT)
+log.datetime_format = "%H:%M:%S"
+log.progname = "ftpserv.rb"
+
+root = FSProvider.new('/')
+auth =
+  lambda do |user,pass|
+    return false unless user.casecmp('anonymous') == 0
+    return true
+  end
+s = DynFTPServer.new(:port => 21, :root => root, :authentication => auth, :logger => log)
+s.mainloop

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: testftpd
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Christian Schulze
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.3
+description: Simple FTP server written in pure Ruby, allowing integration testing
+  of FTP client code without mocks and stubs
+email:
+- christian.schulze@gmail.com
+executables:
+- testftpd
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/testftpd/file_system_provider.rb
+- lib/testftpd/server.rb
+- lib/testftpd/version.rb
+- lib/testftpd.rb
+- vendor/dyn-ftp-serv/CHANGELOG
+- vendor/dyn-ftp-serv/dynftp_server.rb
+- vendor/dyn-ftp-serv/examples/ftpserv.rb
+- vendor/dyn-ftp-serv/LICENSE
+- bin/testftpd
+- spec/fixtures/ftproot/subfolder/test_file1
+- spec/fixtures/ftproot/subfolder/test_file2
+- spec/fixtures/ftproot/test_file
+- spec/fixtures/ftproot/test_file_to_delete
+- spec/fixtures/ftproot/test_file_to_rename
+- spec/fixtures/test_file_to_upload
+- spec/integration/test_ftp_spec.rb
+- spec/spec_helper.rb
+- spec/unit/testftpd/server_spec.rb
+homepage: https://github.com/christian-schulze/testftpd
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: 1.8.25
+requirements: []
+rubyforge_project: testftpd
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Simple FTP server written in pure Ruby
+test_files:
+- spec/fixtures/ftproot/subfolder/test_file1
+- spec/fixtures/ftproot/subfolder/test_file2
+- spec/fixtures/ftproot/test_file
+- spec/fixtures/ftproot/test_file_to_delete
+- spec/fixtures/ftproot/test_file_to_rename
+- spec/fixtures/test_file_to_upload
+- spec/integration/test_ftp_spec.rb
+- spec/spec_helper.rb
+- spec/unit/testftpd/server_spec.rb