investtools-ftpd 1.0.1

data/lib/ftpd/temp_dir.rb

@@ -0,0 +1,22 @@
+module Ftpd
+
+  # Create temporary directories that will be removed when the program
+  # exits.
+
+  module TempDir
+
+    # Create a temporary directory, returning its path.  When the
+    # program exists, the directory (and its contents) are removed.
+
+    def make
+      Dir.mktmpdir.tap do |path|
+        at_exit do
+          FileUtils.rm_rf path
+          Dir.rmdir path if File.exists?(path)
+        end
+      end
+    end
+    module_function :make
+
+  end
+end

data/lib/ftpd/tls_server.rb

@@ -0,0 +1,111 @@
+require_relative 'server'
+
+module Ftpd
+  class TlsServer < Server
+
+    # Whether or not to do TLS, and which flavor.
+    #
+    # One of:
+    # * :off
+    # * :explicit
+    # * :implicit
+    #
+    # Notes:
+    # * Defaults to :off
+    # * Set this before calling #start.
+    # * If other than :off, then #certfile_path must be set.
+    #
+    # @return [Symbol]
+
+    attr_accessor :tls
+
+    # The path of the SSL certificate to use for TLS.  Defaults to nil
+    # (no SSL certificate).
+    #
+    # Set this before calling #start.
+    #
+    # @return [String]
+
+    attr_accessor :certfile_path
+
+    # Create a new TLS server.
+
+    def initialize
+      super
+      @tls = :off
+    end
+
+    private
+
+    def make_server_socket
+      socket = super
+      if tls_enabled?
+        socket = OpenSSL::SSL::SSLServer.new(socket, ssl_context);
+        socket.start_immediately = false
+      end
+      socket
+    end
+
+    def accept
+      socket = @server_socket.accept
+      if tls_enabled?
+        add_missing_methods_to_socket socket
+        add_tls_methods_to_socket socket
+      end
+      socket
+    end
+
+    def ssl_context
+      unless @certfile_path
+        raise ArgumentError, ":certfile required if tls enabled"
+      end
+      context = OpenSSL::SSL::SSLContext.new
+      File.open(@certfile_path) do |certfile|
+        context.cert = OpenSSL::X509::Certificate.new(certfile)
+        certfile.rewind
+        context.key = OpenSSL::PKey::RSA.new(certfile)
+      end
+      context
+    end
+    memoize :ssl_context
+
+    # Add to the TLS socket some methods that regular socket has, but TLS socket is missing
+
+    def add_missing_methods_to_socket(socket)
+
+      def socket.local_address
+        @io.local_address
+      end
+
+    end
+
+    # Add to the TLS sockets some methods of our own invention that
+    # make life a little easier.
+
+    def add_tls_methods_to_socket(socket)
+      context = @ssl_context
+      class << socket
+
+        def ssl_context
+          context
+        end
+
+        def encrypted?
+          !!cipher
+        end
+
+        def encrypt
+          accept
+        end
+
+      end
+    end
+
+    private
+
+    def tls_enabled?
+      @tls != :off
+    end
+
+  end
+end

data/lib/ftpd/translate_exceptions.rb

@@ -0,0 +1,68 @@
+module Ftpd
+
+  # This module translates exceptions to FileSystemError exceptions.
+  #
+  # A disk file system (such as Ftpd::DiskFileSystem) is expected to
+  # raise only FileSystemError exceptions, but many common operations
+  # result in other exceptions such as SystemCallError.  This module
+  # aids a disk driver in translating exceptions to FileSystemError
+  # exceptions.
+  #
+  # In your file system, driver, include this module:
+  #
+  #     module MyDiskDriver
+  #       include Ftpd::TranslateExceptions
+  #
+  # in your constructor, register the exceptions that should be translated:
+  #
+  #       def initialize
+  #         translate_exception SystemCallError
+  #       end
+  #
+  # And register methods for translation:
+  #
+  #       def read(ftp_path)
+  #          ...
+  #       end
+  #       translate_exceptions :read
+
+  module TranslateExceptions
+
+    include Memoizer
+
+    def self.included(includer)
+      includer.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Cause the named method to translate exceptions.
+
+      def translate_exceptions(method_name)
+        original_method = instance_method(method_name)
+        define_method method_name do |*args, &block|
+          exception_translator.translate_exceptions do
+            original_method.bind(self).call *args, &block
+          end
+        end
+      end
+
+    end
+
+    # Add exception class e to the list of exceptions to be
+    # translated.
+
+    def translate_exception(e)
+      exception_translator.register_exception e
+    end
+
+    private
+
+    def exception_translator
+      ExceptionTranslator.new
+    end
+    memoize :exception_translator
+
+  end
+
+end

data/rake_tasks/cucumber.rake

@@ -0,0 +1,9 @@
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new 'test:features' do |t|
+  t.fork = true
+  t.cucumber_opts = '--format progress'
+end
+
+task 'test:cucumber' => ['test:features']
+task 'cucumber' => ['test:features']

data/rake_tasks/default.rake

@@ -0,0 +1 @@
+task :default => [:test]

data/rake_tasks/jeweler.rake

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'jeweler'
+
+README_PATH = File.expand_path('../README.md', File.dirname(__FILE__))
+
+def remove_markdown_link(description)
+  regex = %r{
+    \[
+      ([^\]]+)
+    \]
+    (
+      \[\d+\] |
+      \([^)]+\)
+    )
+  }x
+  description = description.gsub(regex, '\1')
+end
+
+def remove_badges(description)
+  description.gsub(/^\[!.*\n/, '')
+end
+
+def join_lines(description)
+  description.gsub(/\n/, ' ').strip
+end
+
+def extract_description_from_readme
+  readme = File.open(README_PATH, 'r', &:read)
+  description = readme[/^# FTPD.*\n+((?:.*\n)+?)\n*##/i, 1]
+  unless description
+    raise 'Unable to extract description from readme'
+  end
+  description = remove_badges(description)
+  description = remove_markdown_link(description)
+  description = join_lines(description)
+  description
+end
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see
+  # http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = 'investtools-ftpd'
+  gem.homepage = 'http://github.com/wconrad/ftpd'
+  gem.license = 'MIT'
+  gem.summary = %Q{Pure Ruby FTP server library}
+  gem.description = extract_description_from_readme
+  gem.email = 'wconrad@yagni.com'
+  gem.authors = ['Wayne Conrad']
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new

data/rake_tasks/spec.rake

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new 'test:spec'
+task :spec => ['test:spec']

data/rake_tasks/test.rake

@@ -0,0 +1,2 @@
+desc 'Run all tests'
+task :test => ['test:spec', 'test:cucumber']

data/rake_tasks/yard.rake

@@ -0,0 +1,3 @@
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+end

data/spec/command_sequence_checker_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Ftpd
+  describe CommandSequenceChecker do
+
+    let(:sequence_error_verification) do
+      lambda {|e| e.code == 503 && e.message == "Bad sequence of commands"}
+    end
+    subject(:checker) {CommandSequenceChecker.new}
+
+    context 'initial' do
+
+      it 'accepts any command' do
+        checker.check 'NOOP'
+      end
+
+    end
+
+    context 'when a specific command is expected' do
+      
+      before(:each) {checker.expect 'PASS'}
+
+      it 'accepts that command' do
+        checker.check 'PASS'
+      end
+
+      it 'rejects any other command' do
+        expect {
+          checker.check 'NOOP'
+        }.to raise_error(FtpServerError, &sequence_error_verification)
+      end
+
+    end
+
+    context 'after the expected command has arrived' do
+
+      before(:each) do
+        checker.expect 'PASS'
+        checker.check 'PASS'
+      end
+
+      it 'accepts any other command' do
+        checker.check 'NOOP'
+      end
+
+    end
+
+    context 'after a command is rejected' do
+
+      before(:each) do
+        checker.expect 'PASS'
+        expect {
+          checker.check 'NOOP'
+        }.to raise_error(FtpServerError, &sequence_error_verification)
+      end
+
+      it 'accepts any other command' do
+        checker.check 'NOOP'
+      end
+
+    end
+
+    context 'when a command must be expected' do
+
+      before(:each) do
+        checker.must_expect 'PASS'
+      end
+
+      it 'rejects that command if not expected' do
+        expect {
+          checker.check 'PASS'
+        }.to raise_error(FtpServerError, &sequence_error_verification)
+      end
+
+      it 'accepts that command when it is accepted' do
+        checker.expect 'PASS'
+        checker.check 'PASS'
+      end
+
+    end
+
+  end
+end

data/spec/connection_throttle_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+module Ftpd
+
+  describe ConnectionThrottle do
+
+    let(:socket) {double TCPSocket}
+    let(:connections) {0}
+    let(:connections_for_socket) {0}
+    let(:connection_tracker) do
+      double ConnectionTracker, :connections => connections
+    end
+    subject(:connection_throttle) do
+      ConnectionThrottle.new(connection_tracker)
+    end
+
+    before(:each) do
+      allow(connection_tracker).to receive(:connections)
+      .and_return(connections)
+      allow(connection_tracker).to receive(:connections_for)
+      .with(socket)
+      .and_return(connections_for_socket)
+    end
+
+    it 'should have defaults' do
+      expect(connection_throttle.max_connections).to be_nil
+      expect(connection_throttle.max_connections_per_ip).to be_nil
+    end
+
+    describe '#allow?' do
+
+      context '(total connections)' do
+        
+        let(:max_connections) {50}
+
+        before(:each) do
+          connection_throttle.max_connections = max_connections
+          connection_throttle.max_connections_per_ip = 2 * max_connections
+        end
+
+        context 'almost at maximum connections' do
+          let(:connections) {max_connections - 1}
+          specify {expect(connection_throttle.allow?(socket)).to be_truthy}
+        end
+
+        context 'at maximum connections' do
+          let(:connections) {max_connections}
+          specify {expect(connection_throttle.allow?(socket)).to be_falsey}
+        end
+
+        context 'above maximum connections' do
+          let(:connections) {max_connections + 1}
+          specify {expect(connection_throttle.allow?(socket)).to be_falsey}
+        end
+
+      end
+
+      context '(per ip)' do
+        
+        let(:max_connections_per_ip) {5}
+
+        before(:each) do
+          connection_throttle.max_connections = 2 * max_connections_per_ip
+          connection_throttle.max_connections_per_ip = max_connections_per_ip
+        end
+
+        context 'almost at maximum connections for ip' do
+          let(:connections_for_socket) {max_connections_per_ip - 1}
+          specify {expect(connection_throttle.allow?(socket)).to be_truthy}
+        end
+
+        context 'at maximum connections for ip' do
+          let(:connections_for_socket) {max_connections_per_ip}
+          specify {expect(connection_throttle.allow?(socket)).to be_falsey}
+        end
+
+        context 'above maximum connections for ip' do
+          let(:connections_for_socket) {max_connections_per_ip + 1}
+          specify {expect(connection_throttle.allow?(socket)).to be_falsey}
+        end
+
+      end
+
+    end
+
+    describe '#deny' do
+      
+      let(:socket) {StringIO.new}
+
+      it 'should send a "too many connections" message' do
+        connection_throttle.deny socket
+        expect(socket.string).to eq "421 Too many connections\r\n"
+      end
+
+    end
+
+  end
+
+end