raval 0.0.1

data/lib/raval.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+require 'raval/app'
+require 'raval/server'
+
+module Raval
+  LBRK = "\r\n"
+end

data/lib/raval/active_socket.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+require 'celluloid/io'
+require 'socket'
+
+module Raval
+  # In Active FTP mode, the client opens a listening data socket on their host
+  # and we connect to it.
+  #
+  # A different class is used when operating in passive FTP mode. They both
+  # have a #read and #write method, so the quack like each other in the ways
+  # that matter.
+  class ActiveSocket
+    include Celluloid::IO
+
+    def initialize(host, port)
+      @host, @port = host, port
+      @socket = nil
+    end
+
+    def connect
+      unless @socket
+        @socket = ::TCPSocket.new(@host, @port)
+      end
+    end
+
+    def read
+      connect unless @socket
+      @socket.readpartial(4096)
+    rescue EOFError, Errno::ECONNRESET
+      close
+      nil
+    end
+
+    def write(data)
+      connect unless @socket
+      @socket.write(data)
+    end
+
+    def connected?
+      @socket != nil
+    end
+
+    def close
+      @socket.close if @socket
+      @socket = nil
+    end
+  end
+end

data/lib/raval/app.rb

@@ -0,0 +1,137 @@
+# coding: utf-8
+
+module Raval
+
+  # Holds the logic for booting a raval server and configuring the
+  # process as required, binding to a port, writing a pid file, etc.
+  #
+  # Use it like so:
+  #
+  #    Raval::App.start(:port => 3000)
+  #
+  # Options:
+  #
+  #     :driver - the driver class that implements persistance
+  #     :driver_opts - an optional Hash of options to be passed to the driver
+  #                    constructor
+  #     :host - the host IP to listen on. [default: 127.0.0.1]
+  #     :port - the TCP port to listen on [default: 21]
+  #     :pid_file - a path to write the process pid to. Useful for monitoring
+  #     :user - the user ID to change the process owner to
+  #     :group - the group ID to change the process owner to
+  #     :name - an optional name to place in the process description
+  class App
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def self.start(options = {})
+      self.new(options).start
+    end
+
+    def start
+      update_procline
+
+      puts "Starting ftp server on 0.0.0.0:#{port}"
+      Raval::Server.supervise(host,port, driver, driver_opts)
+
+      change_gid
+      change_uid
+      write_pid
+      setup_signal_handlers
+      sleep # for ever
+    end
+
+    private
+
+    def name
+      @options[:name]
+    end
+
+    def host
+      @options.fetch(:host, "127.0.0.1")
+    end
+
+    def port
+      @options.fetch(:port, 21)
+    end
+
+    def driver_opts
+      @options[:driver_opts]
+    end
+
+    def driver
+      @options.fetch(:driver)
+    rescue KeyError
+      raise ArgumentError, "the :driver option must be provided"
+    end
+
+    def uid
+      if @options[:user]
+        begin
+          detail = Etc.getpwnam(@options[:user])
+          return detail.uid
+        rescue
+          $stderr.puts "user must be nil or a real account" if detail.nil?
+        end
+      end
+    end
+
+    def gid
+      if @options[:group]
+        begin
+          detail = Etc.getgrnam(@options[:group])
+          return detail.gid
+        rescue
+          $stderr.puts "group must be nil or a real group" if detail.nil?
+        end
+      end
+    end
+
+    def pid_file
+      @options[:pid_file]
+    end
+
+    def write_pid
+      if pid_file
+        File.open(pid_file, "w") { |io| io.write pid }
+      end
+    end
+
+    def update_procline
+      if name
+        $0 = "raval ftpd [#{name}]"
+      else
+        $0 = "raval"
+      end
+    end
+
+    def change_gid
+      if gid && Process.gid == 0
+        Process.gid = gid
+      end
+    end
+
+    def change_uid
+      if uid && Process.euid == 0
+        Process::Sys.setuid(uid)
+      end
+    end
+
+    def setup_signal_handlers
+=begin
+      trap('QUIT') do
+        EM.stop
+      end
+      trap('TERM') do
+        EM.stop
+      end
+      trap('INT') do
+        EM.stop
+      end
+=end
+    end
+
+  end
+end

data/lib/raval/connection.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+module Raval
+  # wraps a raw TCP socket and simplifies working with FTP style data.
+  #
+  # FTP commands and responses are always a single line ending in a line break,
+  # so make it easy to read and write single lines.
+  class Connection
+
+    BUFFER_SIZE = 1024
+
+    attr_reader :port,   :host
+    attr_reader :myport, :myhost
+
+    def initialize(handler, socket)
+      @socket, @handler = socket, handler
+      _, @port, @host = socket.peeraddr
+      _, @myport, @myhost = socket.addr
+      handler.new_connection(self)
+      puts "*** Received connection from #{host}:#{port}"
+    end
+
+    def send_data(str)
+      @socket.write(str)
+    end
+
+    def send_response(code, message)
+      @socket.write("#{code} #{message}#{Raval::LBRK}")
+    end
+
+    # Close the connection
+    def close
+      @socket.close
+    end
+
+    def read_commands
+      input = ""
+      while true
+        input << @socket.readpartial(BUFFER_SIZE)
+        match = input.match(/(^.+\r\n)/)
+        if match
+          line  = match[1]
+          input = input[line.bytesize, line.bytesize]
+          @handler.receive_line(line)
+        end
+      end
+    end
+
+  end
+end

data/lib/raval/handler.rb

@@ -0,0 +1,549 @@
+# coding: utf-8
+
+require 'raval/active_socket'
+require 'raval/passive_socket'
+require 'raval/list_formatter'
+require 'stringio'
+require 'tempfile'
+
+module Raval
+  # implement the FTP wire protocol, deferring the users driver when interaction
+  # with the persistence layer is required. Nothing in this class is network
+  # aware, it should remain ignorant of where the FTP connection is from and
+  # assume the connection will handle it.
+  #
+  # A new instance of this class is created for each active FTP connection, so
+  # it's OK to store connection specific state in instance variables.
+  class Handler
+
+    COMMANDS = %w[quit type user retr stor eprt port cdup cwd dele rmd pwd
+                  list size syst mkd pass xcup xpwd xcwd xrmd rest allo nlst
+                  pasv epsv help noop mode rnfr rnto stru mdtm]
+
+    REQUIRE_AUTH  = %w[cdup xcup cwd xcwd eprt epsv mode nlst list mdtm pasv port
+                       pwd xpwd retr size stor stru syst type]
+    REQUIRE_PARAM = %w[cwd xcwd eprt mdtm mode pass port retr size stor stru
+                       type user]
+
+    attr_reader :connection, :name_prefix
+
+    def initialize(driver)
+      @driver = driver
+    end
+
+    def new_connection(connection)
+      @mode   = :binary
+      @user   = nil
+      @name_prefix = "/"
+      @connection = connection
+      @connection.send_response(220, "FTP server (raval) ready")
+    end
+
+    def receive_line(line)
+      cmd, param = parse_request(line)
+
+      # if the command is contained in the whitelist, and there is a method
+      # to handle it, call it. Otherwise send an appropriate response to the
+      # client
+      if REQUIRE_AUTH.include?(cmd) && !logged_in?
+        @connection.send_response(530, "Not logged in")
+      elsif REQUIRE_PARAM.include?(cmd) && param.nil?
+        @connection.send_response(553, "action aborted, required param missing")
+      elsif COMMANDS.include?(cmd) && self.respond_to?("cmd_#{cmd}".to_sym, true)
+        self.__send__("cmd_#{cmd}".to_sym, param)
+      else
+        @connection.send_response(500, "Sorry, I don't understand #{cmd.upcase}")
+      end
+    end
+
+    private
+
+    def cmd_allo(param)
+      @connection.send_response(202, "Obsolete")
+    end
+
+    # handle the HELP FTP command by sending a list of available commands.
+    def cmd_help(param)
+      @connection.send_response("214-", "The following commands are recognized.")
+      commands = COMMANDS
+      str = ""
+      commands.sort.each_slice(3) { |slice|
+        str += "     " + slice.join("\t\t") + Raval::LBRK
+      }
+      @connection.send_response(str, "")
+      @connection.send_response(214, "End of list.")
+    end
+
+    # the original FTP spec had various options for hosts to negotiate how data
+    # would be sent over the data socket, In reality these days (S)tream mode
+    # is all that is used for the mode - data is just streamed down the data
+    # socket unchanged.
+    #
+    def cmd_mode(param)
+      if param.upcase.eql?("S")
+        @connection.send_response(200, "OK")
+      else
+        @connection.send_response(504, "MODE is an obsolete command")
+      end
+    end
+
+    # handle the NOOP FTP command. This is essentially a ping from the client
+    # so we just respond with an empty 200 message.
+    def cmd_noop(param)
+      @connection.send_response(200, "")
+    end
+
+    # handle the QUIT FTP command by closing the connection
+    def cmd_quit(param)
+      @connection.send_response(221, "Bye")
+      @connection.close
+    end
+
+    # like the MODE and TYPE commands, stru[cture] dates back to a time when the FTP
+    # protocol was more aware of the content of the files it was transferring, and
+    # would sometimes be expected to translate things like EOL markers on the fly.
+    #
+    # These days files are sent unmodified, and F(ile) mode is the only one we
+    # really need to support.
+    def cmd_stru(param)
+      if param.upcase.eql?("F")
+        @connection.send_response(200, "OK")
+      else
+        @connection.send_response(504, "STRU is an obsolete command")
+      end
+    end
+
+    # return the name of the server
+    def cmd_syst(param)
+      @connection.send_response(215, "UNIX Type: L8")
+    end
+
+    # like the MODE and STRU commands, TYPE dates back to a time when the FTP
+    # protocol was more aware of the content of the files it was transferring, and
+    # would sometimes be expected to translate things like EOL markers on the fly.
+    #
+    # Valid options were A(SCII), I(mage), E(BCDIC) or LN (for local type). Since
+    # we plan to just accept bytes from the client unchanged, I think Image mode is
+    # adequate. The RFC requires we accept ASCII mode however, so accept it, but
+    # ignore it.
+    def cmd_type(param)
+      if param.upcase.eql?("A")
+        @connection.send_response(200, "Type set to ASCII")
+      elsif param.upcase.eql?("I")
+        @connection.send_response(200, "Type set to binary")
+      else
+        @connection.send_response(500, "Invalid type")
+      end
+    end
+
+    # handle the USER FTP command. This is a user attempting to login.
+    # we simply store the requested user name as an instance variable
+    # and wait for the password to be submitted before doing anything
+    def cmd_user(param)
+      @connection.send_response(500, "Already logged in") and return unless @user.nil?
+      @requested_user = param
+      @connection.send_response(331, "OK, password required")
+    end
+
+    # handle the PASS FTP command. This is the second stage of a user logging in
+    def cmd_pass(param)
+      @connection.send_response(202, "User already logged in") and return unless @user.nil?
+      @connection.send_response(530, "password with no username") and return if @requested_user.nil?
+
+      if @driver.authenticate(@requested_user, param)
+        @name_prefix = "/"
+        @user = @requested_user
+        @requested_user = nil
+        @connection.send_response(230, "OK, password correct")
+      else
+        @user = nil
+        @connection.send_response(530, "incorrect login. not logged in.")
+      end
+    end
+
+    # Passive FTP. At the clients request, listen on a port for an incoming
+    # data connection. The listening socket is opened on a random port, so
+    # the host and port is sent back to the client on the control socket.
+    #
+    def cmd_pasv(param)
+      host, port = start_passive_socket
+
+      p1, p2 = *port.divmod(256)
+      host_with_commas = host.split(".").join(",")
+      port_with_commas = "#{p1},#{p2}"
+      message = "Entering Passive Mode (#{host_with_commas},#{port_with_commas})"
+
+      @connection.send_response(227, message)
+    end
+
+    # listen on a port, see RFC 2428
+    #
+    def cmd_epsv(param)
+      host, port = start_passive_socket
+
+      send_response "229 Entering Extended Passive Mode (|||#{port}|)"
+    end
+
+    # Active FTP. An alternative to Passive FTP. The client has a listening socket
+    # open, waiting for us to connect and establish a data socket. Attempt to
+    # open a connection to the host and port they specify and save the connection,
+    # ready for either end to send something down it.
+    def cmd_port(param)
+      nums = param.split(',')
+      port = nums[4].to_i * 256 + nums[5].to_i
+      host = nums[0..3].join('.')
+      close_datasocket
+      start_active_socket(host, port)
+    end
+
+    # open a data connection to the client on the requested port. See RFC 2428
+    def cmd_eprt(param)
+      delim = param[0,1]
+      m, af, host, port = *param.match(/#{delim}(.+?)#{delim}(.+?)#{delim}(.+?)#{delim}/)
+      port = port.to_i
+      close_datasocket
+
+      if af.to_i != 1 && ad.to_i != 2
+        @connection.send_response(522, "Network protocol not supported, use (1,2)")
+      else
+        start_active_socket(host, port)
+      end
+    end
+
+    # go up a directory, really just an alias
+    def cmd_cdup(param)
+      cmd_cwd("..")
+    end
+    alias cmd_xcup cmd_cdup
+
+    # change directory
+    def cmd_cwd(param)
+      path = build_path(param)
+
+      if @driver.change_dir(path)
+        @name_prefix = path
+        @connection.send_response(250, "Directory changed to #{path}")
+      else
+        send_permission_denied
+      end
+    end
+
+    # As per RFC1123, XCWD is a synonym for CWD
+    alias cmd_xcwd cmd_cwd
+
+    # make directory
+    def cmd_mkd(param)
+      send_unauthorised and return unless logged_in?
+      send_param_required and return if param.nil?
+
+      if @driver.make_dir(build_path(param))
+        @connection.send_response(257, "Directory created")
+      else
+        send_action_not_taken
+      end
+    end
+
+    # return the current directory
+    def cmd_pwd(param)
+      @connection.send_response(257, "\"#{@name_prefix}\" is the current directory")
+    end
+
+    # As per RFC1123, XPWD is a synonym for PWD
+    alias cmd_xpwd cmd_pwd
+
+    # delete a directory
+    def cmd_rmd(param)
+      send_unauthorised and return unless logged_in?
+      send_param_required and return if param.nil?
+
+      if @driver.delete_dir(build_path(param))
+        @connection.send_response(250, "Directory deleted.")
+      else
+        send_action_not_taken
+      end
+    end
+
+    # As per RFC1123, XRMD is a synonym for RMD
+    alias cmd_xrmd cmd_rmd
+
+    # return a listing of the current directory, one per line, each line
+    # separated by the standard FTP EOL sequence. The listing is returned
+    # to the client over a data socket.
+    #
+    def cmd_nlst(param)
+      @connection.send_response(150, "Opening ASCII mode data connection for file list")
+
+      files = @driver.dir_contents(build_path(param))
+      formatter = ListFormatter.new(files)
+      send_outofband_data(formatter.short)
+    end
+
+    # return a detailed list of files and directories
+    def cmd_list(param)
+      @connection.send_response(150, "Opening ASCII mode data connection for file list")
+
+      param = '' if param.to_s == '-a'
+
+      files = @driver.dir_contents(build_path(param))
+      formatter = ListFormatter.new(files)
+      send_outofband_data(formatter.detailed)
+    end
+
+    # delete a file
+    def cmd_dele(param)
+      send_unauthorised and return unless logged_in?
+      send_param_required and return if param.nil?
+
+      path = build_path(param)
+
+      if @driver.delete_file(path)
+        @connection.send_response(250, "File deleted")
+      else
+        send_action_not_taken
+      end
+    end
+
+    # resume downloads
+    def cmd_rest(param)
+      @connection.send_response(500, "Feature not implemented")
+    end
+
+    # send a file to the client
+    def cmd_retr(param)
+      path = build_path(param)
+
+      io = @driver.get_file(path)
+      if io
+        @connection.send_response(150, "Data transfer starting #{io.size} bytes")
+        send_outofband_data(io)
+      else
+        @connection.send_response(551, "file not available")
+      end
+    end
+
+    # rename a file
+    def cmd_rnfr(param)
+      send_unauthorised and return unless logged_in?
+      send_param_required and return if param.nil?
+
+      @from_filename = build_path(param)
+      @connection.send_response(350, "Requested file action pending further information.")
+    end
+
+    # rename a file
+    def cmd_rnto(param)
+      send_unauthorised and return unless logged_in?
+      send_param_required and return if param.nil?
+
+      if @driver.rename(@from_filename, build_path(param))
+        @connection.send_response(250, "File renamed.")
+      else
+        send_action_not_taken
+      end
+    end
+
+    # return the size of a file in bytes
+    def cmd_size(param)
+      bytes = @driver.bytes(build_path(param))
+      if bytes
+        @connection.send_response(213, bytes)
+      else
+        @connection.send_response(450, "file not available")
+      end
+    end
+
+    # return the last modified time of a file
+    #
+    def cmd_mdtm(param)
+      time = @driver.modified_time(build_path(param))
+      if time
+        @connection.send_response(213, "#{time.strftime("%Y%m%d%H%M%S")}")
+      else
+        @connection.send_response(450, "file not available")
+      end
+    end
+
+    # save a file from a client
+    def cmd_stor(param)
+      path = build_path(param)
+
+      if @driver.respond_to?(:put_file_streamed)
+        cmd_stor_streamed(path)
+      elsif @driver.respond_to?(:put_file)
+        cmd_stor_tempfile(path)
+      else
+        raise "driver MUST respond to put_file OR put_file_streamed"
+      end
+    end
+
+    def cmd_stor_streamed(target_path)
+      if @datasocket
+        @connection.send_response(150, "Data transfer starting")
+        @driver.put_file_streamed(target_path, @datasocket) do |bytes|
+          if bytes
+            @connection.send_response(226, "OK, received #{bytes} bytes")
+          else
+            send_action_not_taken
+          end
+        end
+      else
+        @connection.send_response(425, "Error establishing connection")
+      end
+    end
+
+    def cmd_stor_tempfile(target_path)
+      Tempfile.open("raval") do |tmpfile|
+        tmpfile.binmode
+
+        @connection.send_response(150, "Data transfer starting")
+        while chunk = @datasocket.read
+          tmpfile.write(chunk)
+        end
+        tmpfile.flush
+        tmpfile.close
+        bytes = @driver.put_file(target_path, tmpfile.path)
+        if bytes
+          @connection.send_response(226, "OK, received #{bytes} bytes")
+        else
+          send_action_not_taken
+        end
+      end
+    end
+
+    def build_path(filename = nil)
+      if filename && filename[0,1] == "/"
+        path = File.expand_path(filename)
+      elsif filename && filename != '-a'
+        path = File.expand_path("#{@name_prefix}/#{filename}")
+      else
+        path = File.expand_path(@name_prefix)
+      end
+      path.gsub(/\/+/,"/")
+    end
+
+    # send data to the client across the data socket.
+    #
+    def send_outofband_data(data)
+      wait_for_datasocket do |datasocket|
+        if datasocket.nil?
+          @connection.send_response(425, "Error establishing connection")
+          return
+        end
+
+        if data.is_a?(Array)
+          data = data.join(LBRK) << LBRK
+        end
+        data = StringIO.new(data) if data.kind_of?(String)
+
+        # blocks until all data is sent
+        begin
+          bytes = 0
+          data.each do |line|
+            datasocket.write(line)
+            bytes += line.bytesize
+          end
+          @connection.send_response(226, "Closing data connection, sent #{bytes} bytes")
+        rescue => e
+          puts e.inspect
+        ensure
+          close_datasocket
+          data.close if data.respond_to?(:close)
+        end
+      end
+    end
+
+    def start_active_socket(host, port)
+      # close any existing data socket
+      close_datasocket
+
+      @datasocket = ActiveSocket.new(host, port)
+      @datasocket.async.connect
+      wait_for_datasocket do
+        @connection.send_response(200, "Connection established (#{port})")
+      end
+    rescue => e
+      puts "Error opening data connection to #{host}:#{port}"
+      puts e.inspect
+      @connection.send_response(425, "Data connection failed")
+    end
+
+    def start_passive_socket
+      # close any existing data socket
+      close_datasocket
+
+      # open a listening socket on the appropriate host
+      # and on a random port
+      @datasocket = PassiveSocket.new(@connection.myhost)
+
+      [@connection.myhost, @datasocket.port]
+    end
+
+    # split a client's request into command and parameter components
+    def parse_request(data)
+      data.strip!
+      space = data.index(" ")
+      if space
+        cmd = data[0, space]
+        param = data[space+1, data.length - space]
+        param = nil if param.strip.size == 0
+      else
+        cmd = data
+        param = nil
+      end
+
+      [cmd.downcase, param]
+    end
+
+    def close_datasocket
+      if @datasocket
+        @datasocket.close
+        @datasocket.terminate
+        @datasocket = nil
+      end
+
+      # stop listening for data socket connections, we have one
+      #if @listen_sig
+      #  PassiveSocket.stop(@listen_sig)
+      #  @listen_sig = nil
+      #end
+    end
+
+    # waits for the data socket to be established
+    def wait_for_datasocket(interval = 0.1, &block)
+      if (@datasocket.nil? || !@datasocket.connected?) && interval < 25
+        sleep interval
+        wait_for_datasocket(interval * 2, &block)
+        return
+      end
+      if @datasocket.connected?
+        yield @datasocket
+      else
+        yield nil
+      end
+    end
+
+    def logged_in?
+      @user.nil? ? false : true
+    end
+
+    def send_param_required
+      @connection.send_response(553, "action aborted, required param missing")
+    end
+
+    def send_permission_denied
+      @connection.send_response(550, "Permission denied")
+    end
+
+    def send_action_not_taken
+      @connection.send_response(550, "Action not taken")
+    end
+
+    def send_illegal_params
+      @connection.send_response(553, "action aborted, illegal params")
+    end
+
+    def send_unauthorised
+      @connection.send_response(530, "Not logged in")
+    end
+  end
+end