ftpd 2.0.1 → 2.0.2

data/features/support/test_server_files.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module TestServerFiles
-
-  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 set_mtime(path, mtime)
-    full_path = temp_path(path)
-    File.utime(File.atime(full_path), mtime, full_path)
-  end
-
-  def add_directory(path)
-    full_path = temp_path(path)
-    mkdir_p full_path
-  end
-
-  def has_file?(path)
-    full_path = temp_path(path)
-    File.exists?(full_path)
-  end
-
-  def has_file_with_contents_of?(path)
-    expected_contents = @templates[File.basename(path)]
-    all_paths.any? do |path|
-      File.open(path, 'rb', &:read) == expected_contents
-    end
-  end
-
-  def files_named_like(name)
-    all_paths.select do |path|
-      path.include?(name)
-    end
-  end
-
-  def has_directory?(path)
-    full_path = temp_path(path)
-    File.directory?(full_path)
-  end
-
-  def file_contents(path)
-    full_path = temp_path(path)
-    File.open(full_path, 'rb', &:read)
-  end
-
-  def temp_path(path)
-    File.expand_path(path, temp_dir)
-  end
-
-  def all_paths
-    Dir[temp_path('**/*')]
-  end
-
-end

data/rake_tasks/cucumber.rake

@@ -1,9 +0,0 @@
-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

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

data/rake_tasks/jeweler.rake

@@ -1,52 +0,0 @@
-# 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 = '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

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

data/rake_tasks/test.rake

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

data/rake_tasks/yard.rake

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

data/spec/command_sequence_checker_spec.rb

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

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

data/spec/connection_tracker_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('spec_helper', File.dirname(__FILE__))
-
-module Ftpd
-
-  describe ConnectionTracker do
-
-    before(:all) do
-      Thread.abort_on_exception = true
-    end    
-
-    # Create a mock socket with the given peer address
-
-    def socket_bound_to(source_ip)
-      socket = double TCPSocket
-      peeraddr = Socket.pack_sockaddr_in(0, source_ip)
-      allow(socket).to receive(:getpeername) {peeraddr}
-      socket
-    end
-
-    subject(:connection_tracker) {ConnectionTracker.new}
-
-    describe '#connections' do
-
-      let(:socket) {socket_bound_to('127.0.0.1')}
-
-      context '(session ends normally)' do
-
-        it 'should track the total number of connection' do
-          expect(connection_tracker.connections).to eq 0
-          connection_tracker.start_track socket
-          expect(connection_tracker.connections).to eq 1
-          connection_tracker.stop_track socket
-          expect(connection_tracker.connections).to eq 0
-        end
-
-      end
-
-    end
-
-    describe '#connections_for' do
-
-      it 'should track the number of connections for an ip' do
-        socket1 = socket_bound_to('127.0.0.1')
-        socket2 = socket_bound_to('127.0.0.2')
-        expect(connection_tracker.connections_for(socket1)).to eq 0
-        expect(connection_tracker.connections_for(socket2)).to eq 0
-        connection_tracker.start_track socket1
-        expect(connection_tracker.connections_for(socket1)).to eq 1
-        expect(connection_tracker.connections_for(socket2)).to eq 0
-        connection_tracker.stop_track socket1
-        expect(connection_tracker.connections_for(socket1)).to eq 0
-        expect(connection_tracker.connections_for(socket2)).to eq 0
-      end
-
-    end
-
-    describe '#known_ip_count' do
-
-      let(:socket) {socket_bound_to('127.0.0.1')}
-
-      it 'should forget about an IP that has no connection' do
-        expect(connection_tracker.known_ip_count).to eq 0
-        connection_tracker.start_track socket
-        expect(connection_tracker.known_ip_count).to eq 1
-        connection_tracker.stop_track socket
-        expect(connection_tracker.known_ip_count).to eq 0
-      end
-
-    end
-
-    describe '#track' do
-
-      let(:socket) {socket_bound_to('127.0.0.1')}
-
-      context '(session ends normally)' do
-        specify do
-          expect(connection_tracker.connections_for(socket)).to eq 0
-          connection_tracker.track(socket) do
-            expect(connection_tracker.connections_for(socket)).to eq 1
-          end
-          expect(connection_tracker.connections_for(socket)).to eq 0
-        end
-      end
-
-      context '(session ends with exception)' do
-        specify do
-          expect(connection_tracker.connections_for(socket)).to eq 0
-          connection_tracker.track(socket) { raise } rescue
-          expect(connection_tracker.connections_for(socket)).to eq 0
-        end
-      end
-
-    end
-
-  end
-
-end

data/spec/data_server_factory_spec.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require File.expand_path('spec_helper', File.dirname(__FILE__))
-
-module Ftpd
-  describe DataServerFactory do
-
-    it "creates a socket bound to 127.0.0.1" do
-      factory = DataServerFactory.make("127.0.0.1", nil)
-      tcp_server = factory.make_tcp_server
-      expect(tcp_server.addr[3]).to eq "127.0.0.1"
-    end
-
-    it "creates a socket bound to 127.0.0.2" do
-      factory = DataServerFactory.make("127.0.0.2", nil)
-      tcp_server = factory.make_tcp_server
-      expect(tcp_server.addr[3]).to eq "127.0.0.2"
-    end
-
-    context "with no port range" do
-
-      it "creates a socket bound to an ephemeral port" do
-        interface = "0.0.0.0"
-        factory = DataServerFactory.make(interface, nil)
-        ports = (1..10).map do
-          tcp_server = factory.make_tcp_server
-          begin
-            tcp_server.addr[1]
-          ensure
-            tcp_server.close
-          end
-        end
-        expect(ports.uniq.size).to be > 1
-        ports.each do |port|
-          expect(port).to be_between(1024, 65535)
-        end
-      end
-
-    end
-
-    context "with a port range" do
-
-      let(:interface) { "127.0.0.1" }
-      
-      def get_unused_port
-        server = TCPServer.new(interface, 0)
-        port = server.addr[1]
-        server.close
-        port
-      end
-
-      def use_port(port)
-        server = TCPServer.new(interface, port)
-        begin
-          yield
-        ensure
-          server.close
-        end
-      end
-
-      it "creates a socket bound to an ephemeral port" do
-        ports = (1..10).map { get_unused_port }
-        factory = DataServerFactory.make(interface, ports)
-        10.times do
-          tcp_server = factory.make_tcp_server
-          begin
-            port = tcp_server.addr[1]
-            expect(ports).to include(port)
-          ensure
-            tcp_server.close
-          end
-        end
-      end
-
-      it "skips a port that is already in use" do
-        ports = (1..2).map { get_unused_port }
-        use_port(ports[0]) do
-          factory = DataServerFactory.make(interface, ports)
-          10.times do
-            tcp_server = factory.make_tcp_server
-            begin
-              port = tcp_server.addr[1]
-              expect(port).to eq ports[1]
-            ensure
-              tcp_server.close
-            end
-          end
-        end
-      end
-
-      it "uses a random ephemeral port when all configured ports are in use" do
-        ports = [ get_unused_port ]
-        use_port(ports[0]) do
-          factory = DataServerFactory.make(interface, ports)
-          tcp_server = factory.make_tcp_server
-          port = tcp_server.addr[1]
-          expect(port).to_not eq ports[0]
-        end
-      end
-
-    end
-
-  end
-end