investtools-ftpd 1.0.1

data/lib/ftpd/gets_peer_address.rb

@@ -0,0 +1,41 @@
+require_relative "gets_peer_address"
+
+module Ftpd
+
+  module GetsPeerAddress
+
+    # Obtain the IP that the client connected _from_.
+    #
+    # How this is done depends upon which type of socket (SSL or not)
+    # and what version of Ruby.
+    #
+    # * SSL socket
+    #   * #peeraddr.  Uses BasicSocket.do_not_reverse_lookup.
+    # * Ruby 1.8.7
+    #   * #peeraddr, which does not take the "reverse lookup"
+    #     argument, relying instead using
+    #     BasicSocket.do_not_reverse_lookup.
+    #   * #getpeername, which does not do a reverse lookup.  It is a
+    #     little uglier than #peeraddr.
+    # * Ruby >=1.9.3
+    #   * #peeraddr, which takes the "reverse lookup" argument.
+    #   * #getpeername - same as 1.8.7
+    #
+    # @return [String] IP address
+
+    def peer_ip(socket)
+      if socket.respond_to?(:getpeername)
+        # Non SSL
+        sockaddr = socket.getpeername
+        port, host = Socket.unpack_sockaddr_in(sockaddr)
+        host
+      else
+        # SSL
+        BasicSocket.do_not_reverse_lookup = true
+        socket.peeraddr.last
+      end
+    end
+
+  end
+
+end

data/lib/ftpd/insecure_certificate.rb

@@ -0,0 +1,16 @@
+module Ftpd
+
+  # This mixin provides an insecure SSL certificate.  This certificate
+  # should only be used for testing.
+
+  module InsecureCertificate
+
+    # The path of an insecure SSL certificate.
+
+    def insecure_certfile_path
+      File.expand_path('../../insecure-test-cert.pem',
+                       File.dirname(__FILE__))
+    end
+
+  end
+end

data/lib/ftpd/list_format/eplf.rb

@@ -0,0 +1,74 @@
+module Ftpd
+  module ListFormat
+
+    # Easily Parsed LIST Format (EPLF) Directory formatter
+    # See: {http://cr.yp.to/ftp/list/eplf.html}
+
+    class Eplf
+
+      extend Forwardable
+
+      # Create a new formatter for a file object
+      # @param file_info [FileInfo]
+
+      def initialize(file_info)
+        @file_info = file_info
+      end
+
+      # Return the formatted directory entry.
+      # For example:
+      #   +i8388621.48598,m824253270,r,s612, 514.html
+      # Note: The calling code adds the \r\n
+
+      def to_s
+        "+%s\t%s" % [facts, filename]
+      end
+
+      private
+
+      def facts
+        [
+          retrievable_fact,
+          cwd_target_fact,
+          size_fact,
+          mtime_fact,
+          identifier_fact,
+        ].compact.join(',')
+      end
+
+      def retrievable_fact
+        'r' if retrievable?
+      end
+
+      def cwd_target_fact
+        '/' if cwd_target?
+      end
+
+      def size_fact
+        "s#{@file_info.size}" if retrievable?
+      end
+
+      def mtime_fact
+        "m#{@file_info.mtime.to_i}"
+      end
+
+      def identifier_fact
+        "i#{@file_info.identifier}" if @file_info.identifier
+      end
+
+      def filename
+        File.basename(@file_info.path)
+      end
+
+      def retrievable?
+        @file_info.file?
+      end
+
+      def cwd_target?
+        @file_info.directory?
+      end
+
+    end
+
+  end
+end

data/lib/ftpd/list_format/ls.rb

@@ -0,0 +1,154 @@
+module Ftpd
+  module ListFormat
+
+    # Directory formatter that approximates the output of "ls -l"
+
+    class Ls
+
+      extend Forwardable
+
+      # Create a new formatter for a file object
+      # @param file_info [FileInfo]
+
+      def initialize(file_info)
+        @file_info = file_info
+      end
+
+      # Return the formatted directory entry, for example:
+      #   -rw-r--r-- 1 user     group    Mar  3 08:38 foo
+
+      def to_s
+        '%s%s %d %-8s %-8s %8d %s %s' % [
+          file_type,
+          file_mode_letters,
+          @file_info.nlink,
+          @file_info.owner,
+          @file_info.group,
+          @file_info.size,
+          format_time(@file_info.mtime),
+          filename,
+        ]
+      end
+
+      private
+
+      SIX_MONTHS = 180 * 24 * 60 * 60
+
+      def filename
+        File.basename(@file_info.path)
+      end
+
+      def file_type
+        FileType.letter(@file_info.ftype)
+      end
+
+      def file_mode_letters
+        FileMode.new(@file_info.mode).letters
+      end
+
+      def self.format_time(mtime)
+        age = Time.now - mtime
+        format = '%b %e ' + if age < 0 || age > SIX_MONTHS
+                              ' %Y'
+                            else
+                              '%H:%M'
+                            end
+        mtime.strftime(format)
+      end
+      def_delegator self, :format_time
+
+      # Map file type strings to ls file type letters
+
+      class FileType
+
+        # Map a file type string to a file type letter.
+        # @param ftype [String] file type as returned by File::Stat#ftype
+        # @return [String] File type letter
+
+        def self.letter(ftype)
+          case ftype
+          when 'file'
+            '-'
+          when 'directory'
+            'd'
+          when 'characterSpecial'
+            'c'
+          when 'blockSpecial'
+            'b'
+          when 'fifo'
+            'p'
+          when 'link'
+            'l'
+          when 'socket'
+            's'
+          else  # 'unknown', etc.
+            '?'
+          end
+        end
+
+      end
+
+      # Map file mode bits into ls style file mode letters
+
+      class FileMode
+
+        # @param mode [Integer] File mode bits, as returned by
+        #   File::Stat#mode
+
+        def initialize(mode)
+          @mode = mode
+        end
+
+        # Return the mode bits as ls style letters.
+        # For example, "-rw-r--r--"
+
+        def letters
+          [
+            triad(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE, SET_UID, 'Ss'),
+            triad(GROUP_READ, GROUP_WRITE, GROUP_EXECUTE, SET_GID, 'Ss'),
+            triad(OTHER_READ, OTHER_WRITE, OTHER_EXECUTE, STICKY, 'Tt'),
+          ].join
+        end
+
+        private
+
+        def bit(bit_number)
+          @mode >> bit_number & 1
+        end
+
+        def triad(read_bit, write_bit, execute_bit, special_bit, special_letters)
+          execute_chars = if bit(special_bit) != 0
+                            special_letters
+                          else
+                            '-x'
+                          end
+          [
+            pick_char('-r', read_bit),
+            pick_char('-w', write_bit),
+            pick_char(execute_chars, execute_bit),
+          ]
+        end
+
+        def pick_char(s, bit_number)
+          s[bit(bit_number), 1]
+        end
+
+        OTHER_EXECUTE = 0
+        OTHER_WRITE = 1
+        OTHER_READ = 2
+        GROUP_EXECUTE = 3
+        GROUP_WRITE = 4
+        GROUP_READ = 5
+        OWNER_EXECUTE = 6
+        OWNER_WRITE = 7
+        OWNER_READ = 8
+        STICKY = 9
+        SET_GID = 10
+        SET_UID = 11
+
+      end
+
+    end
+
+  end
+end

data/lib/ftpd/list_path.rb

@@ -0,0 +1,28 @@
+module Ftpd
+
+  # Functions for manipulating LIST and NLST arguments
+
+  module ListPath
+
+    # Turn the argument to LIST/NLST into a path
+    #
+    # @param argument [String] The argument, or nil if not present
+    # @return [String] The path
+    #
+    # Although compliant with the spec, this function does not do
+    # these things that traditional Unix FTP servers do:
+    #
+    # * Allow multiple paths
+    # * Handle switches such as "-a"
+    #
+    # See: http://cr.yp.to/ftp/list.html sections "LIST parameters"
+    # and "LIST wildcards"
+
+    def list_path(argument)
+      argument ||= '.'
+      argument = '' if argument =~ /^-/
+      argument
+    end
+
+  end
+end

data/lib/ftpd/null_logger.rb

@@ -0,0 +1,22 @@
+module Ftpd
+
+  # A logger that does not log.
+  # Quacks enough like a Logger to fool Ftpd.
+
+  class NullLogger
+
+    def self.stub(method_name)
+      define_method method_name do |*args|
+      end
+    end
+
+    stub :unknown
+    stub :fatal
+    stub :error
+    stub :warn
+    stub :info
+    stub :debug
+
+  end
+
+end

data/lib/ftpd/protocols.rb

@@ -0,0 +1,60 @@
+module Ftpd
+
+  # With the commands EPORT and EPSV, the client sends a protocol code
+  # to indicate whether it wants an IPV4 or an IPV6 connection.  This
+  # class contains functions related to that protocol code.
+
+  class Protocols
+
+    module Codes
+      IPV4 = 1
+      IPV6 = 2
+    end
+    include Codes
+
+    # @param socket [TCPSocket, OpenSSL::SSL::SSLSocket] The socket.
+    #   It doesn't matter whether it's the server socket (the one on
+    #   which #accept is called), or the socket returned by #accept.
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    # Can the socket support a connection in the indicated protocol?
+    #
+    # @param protocol_code [Integer] protocol code
+
+    def supports_protocol?(protocol_code)
+      protocol_codes.include?(protocol_code)
+    end
+
+    # What protocol codes does the socket support?
+    #
+    # @return [Array<Integer>] List of protocol codes
+
+    def protocol_codes
+      [
+        (IPV4 if supports_ipv4?),
+        (IPV6 if supports_ipv6?),
+      ].compact
+    end
+
+    private
+
+    def supports_ipv4?
+      @socket.local_address.ipv4? || ipv6_dual_stack?
+    end
+
+    def supports_ipv6?
+      @socket.local_address.ipv6?
+    end
+
+    def ipv6_dual_stack?
+      v6only = @socket.getsockopt(Socket::IPPROTO_IPV6,
+                                  Socket::IPV6_V6ONLY).unpack('i')
+      v6only == [0]
+    end
+
+  end
+
+end

data/lib/ftpd/read_only_disk_file_system.rb

@@ -0,0 +1,22 @@
+module Ftpd
+
+  # A disk file system that does not allow any modification (writes,
+  # deletes, etc.)
+
+  class ReadOnlyDiskFileSystem
+
+    include DiskFileSystem::Base
+    include DiskFileSystem::List
+    include DiskFileSystem::Read
+
+    # Make a new instance to serve a directory.  data_dir should be an
+    # absolute path.
+
+    def initialize(data_dir)
+      set_data_dir data_dir
+      translate_exception SystemCallError
+    end
+
+  end
+
+end

data/lib/ftpd/server.rb

@@ -0,0 +1,139 @@
+module Ftpd
+  class Server
+
+    include Memoizer
+
+    # The interface to bind to (e.g. "127.0.0.1", "0.0.0.0",
+    # "10.0.0.12", "::1", "::", etc.).  Defaults to "127.0.0.1"
+    #
+    # Set this before calling #start.
+    #
+    # @return [String]
+
+    attr_accessor :interface
+
+    # The port to bind to.  Defaults to 0, which causes an ephemeral
+    # port to be used.  When bound to an ephemeral port, use
+    # #bound_port to find out which port was actually bound to.
+    #
+    # Set this before calling #start.
+    #
+    # @return [String]
+
+    attr_accessor :port
+
+    def initialize
+      @interface = '127.0.0.1'
+      @port = 0
+      @stopping = false
+    end
+
+    # The port the server is bound to.  Must not be called until after
+    # #start is called.
+    #
+    # @return [Integer]
+
+    def bound_port
+      @server_socket.addr[1]
+    end
+
+    # The calling thread will suspend execution until the server is
+    # stopped.
+
+    def join
+      raise 'Server is not started!' if @server_thread.nil?
+      @server_thread.join
+    end
+
+    # Start the server.  This creates the server socket, and the
+    # thread to service it.
+
+    def start
+      @server_socket = make_server_socket
+      @server_thread = make_server_thread
+    end
+
+    # Stop the server.  This closes the server socket, which in turn
+    # stops the thread.
+
+    def stop
+      @stopping = true
+      begin
+        @server_socket.shutdown
+      rescue Errno::ENOTCONN
+      end
+      @server_socket.close
+    end
+
+    private
+
+    def make_server_socket
+      return TCPServer.new(@interface, @port)
+    end
+
+    def make_server_thread
+      Thread.new do
+        Thread.abort_on_exception = true
+        loop do
+          begin
+            begin
+              socket = accept
+            rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINVAL
+              IO.select([@server_socket])
+              sleep(0.2)
+              retry
+            rescue Errno::EBADF, Errno::ENOTSOCK
+              raise unless @stopping
+              @stopping = false
+              break
+            end
+            start_session socket
+          rescue IOError
+            break
+          end
+        end
+      end
+    end
+
+    def start_session(socket)
+      if allow_session?(socket)
+        start_session_thread socket
+      else
+        deny_session socket
+        close_socket socket
+      end
+    end
+
+    def allow_session?(socket)
+      true
+    end
+
+    def deny_session socket
+    end
+
+    def start_session_thread(socket)
+      Thread.new do
+        begin
+          session socket
+        rescue OpenSSL::SSL::SSLError => e
+        ensure
+          close_socket socket
+        end
+      end
+    end
+
+    def accept
+      @server_socket.accept
+    end
+
+    def close_socket(socket)
+      if socket.respond_to?(:shutdown)
+        socket.shutdown rescue nil
+        socket.read rescue nil
+      end
+    ensure
+      socket.close
+    end
+
+  end
+end