em-ftpd-memory 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f956464e630343b641be99ed93084dcb2a611315
-  data.tar.gz: 29590d20f13333be333625911bd2e926b72f8d00
+  metadata.gz: 59b7c1d4a65d038d0a2addbbccbf1697a1f4e6c4
+  data.tar.gz: 605868d7a3280ff3f5b0ad062acee5f31b8a97cb
 SHA512:
-  metadata.gz: 478ecd65ede2e791ce9e15379feecc04766b5e5896ca9c77cc3a8b885df3dc4d408dd233cd48c3674d3463a989124b3d107b19bdedf6d0892eadbc3050d6131e
-  data.tar.gz: 88f9881f706324244c08740de23803f298e14b52ff57ee4d88b7a2b43c46b957b4f9744e369721b343a77766197eb8e05b9aa9d1f3b054aeeba985e8bfb963c2
+  metadata.gz: f2d538c602e0060ebcc469f81bb8d33a583b8a825e13ea060583bbb270535e8aec86080757536b48bd096fb90af20c0ee6eadad6e5c84e7c2e1497c4bdb904f7
+  data.tar.gz: d811d57df20890c04e1687c8a32cd3b0b88680a705fd34d70bd3ee7533b29c23f143d73b221c7c639a7c7876662c17b4a3cd42e7d3f0fcac79cd15227e346a5d

data/README.md

@@ -28,11 +28,23 @@ Or install it yourself as:
       "pwalgo" => "otp",
       
     }
-    auth = EM::FTPD::Memory::Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
-    auth << EM::FTPD::Memory::User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
-    fs = EM::FTPD::Memory::FileSystem.getFileSystemByName(options["filesystem_name"])
-    fs.create_dir("/pub")
-    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
+    fs = FileSystem.getFileSystem(options["filesystem_name"])
+    fs.create_dir("/pub", 'root')
+    fs.create_file("/pub/helper.rb", "test/helper.rb", 'root')
+    fs.set_permissions("/pub", 'rwxr.xr.x', "root")
+    fs.create_dir("/uploads", 'root')
+    fs.set_permissions("/uploads", "rwxrwxrwx", "root")
+    
+    fs.create_dir("/users", 'root')
+    fs.set_permissions("/users", "rwxr.xr.x", "root")
+    ["hiro", "miyako", "pilar"].each do |username|
+      fs.create_dir("/users/#{username}", 'root')
+      fs.set_permissions("/users/#{username}", "rwx......", "root")
+      fs.set_owner("/users/#{username}", username, 'root')
+      auth << User.new(username, username)
+    end
     
     EM.run {
       EventMachine::start_server("0.0.0.0", 2021, EM::FTPD::Server, EM::FTPD::Memory::Driver, options)

data/em-ftpd-memory.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "em-ftpd-memory"
-  spec.version       = "0.0.4"
+  spec.version       = "0.0.5"
   spec.authors       = ["chrislee35"]
   spec.email         = ["rubygems@chrislee.dhs.org"]
   spec.summary       = %q{Memory-based backing store for em-ftpd}

data/lib/em/ftpd/memory/filesystem.rb

@@ -1,6 +1,22 @@
 module EM::FTPD::Memory
   class InvalidPermissionsError < StandardError; end
   
+  class MemoryDirectoryItem
+    ATTRS = [:name, :owner, :group, :size, :time, :permissions, :directory, :contents]
+    attr_accessor(*ATTRS)
+
+    def initialize(options)
+      options.each do |attr, value|
+        self.send("#{attr}=", value)
+      end
+      @size ||= 0
+      @time ||= Time.now
+      @owner ||= "nobody"
+      @group ||= "nogroup"
+      raise ArgumentError.new("MemoryDirectoryItem requires a :name") unless @name
+    end
+  end
+  
   class FileSystem
     @@filesystems = Hash.new
     def self.getFileSystem(name)
@@ -23,61 +39,84 @@ module EM::FTPD::Memory
         end
       end
     end
+
+
+# TODO: support groups
     
-    def initialize()
-      @root_entry = EM::FTPD::DirectoryItem.new(:name => 'root', :directory => true, :size => 0, :permissions => 'rwxrwxrwx', :owner => 'root', :group => 'root')
-      @root = {
-        '/' => Array.new
-      }
-      @contents = Hash.new
+    def initialize
+      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
     end
 
     def exist?(path)
-      is_dir(path) || is_file(path)
+      item = get_item(path)
+      if item
+        return true
+      else
+        return false
+      end
+    end
+    
+    def is_dir?(path)
+      item = get_item(path)
+      return false unless item and item.directory
+      true
+    end
+    
+    def is_file?(path)
+      item = get_item(path)
+      return false unless item and not item.directory
+      true
     end
     
     def change_dir(path, user = nil)
-      is_dir(path) && use_allowed?(path, :list, user)
+      item = get_item(path)
+      item.directory && use_allowed?(path, :list, user)
     end
     
     def list_files(path, user = nil)
       return [] unless use_allowed?(path, :list, user)
-      @root[path] || [] # should this return false?
+      item = get_item(path)
+      if item.directory
+        return item.contents.values
+      end
+      return []
     end
     
     def file_size(path, user = nil)
       return false unless use_allowed?(path, :size, user)
-      f = get_file(path)
+      f = get_item(path)
       return false unless f
       f.size
     end
     
     def modified_time(path, user = nil)
       return nil unless use_allowed?(path, :time, user)
-      f = get_file(path)
+      f = get_item(path)
       return nil unless f
       f.time
     end
     
     def file_contents(path, user = nil)
       return false unless use_allowed?(path, :read, user)
-      # nil || false => false
-      @contents[path] || false
+      item = get_item(path)
+      item.contents || false
     end
     
     def create_file(path, data, user = "nobody")
       return false unless use_allowed?(path, :create, user)
       dirname = File.dirname(path)
       basename = File.basename(path)
-      if is_dir(dirname)
+      dir = get_item(dirname)
+      if dir and dir.directory
+        item = get_item(path)
         contents = File.open(data,'r').read
-        f = get_file(path)
-        if f
-          f.size = contents.length
-        else
-          @root[dirname] << EM::FTPD::DirectoryItem.new(:name => basename, :directory => false, :size => contents.length)
+        permissions = "rwxrwxrwx" # FIXME
+        if item # overwrite
+          item.contents = contents
+          item.size = contents.length
+        else # create new
+          dir.contents[basename] = MemoryDirectoryItem.new(:name => basename, :owner => user, :size => contents.length, :contents => contents, :permissions => permissions)
         end
-        @contents[path] = contents
         return true
       else
         return false
@@ -85,37 +124,39 @@ module EM::FTPD::Memory
     end
     
     def delete_file(path, user = nil)
-      if is_file(path)
-        return false unless use_allowed?(path, :delete, user)
-        dirname = File.dirname(path)
-        basename = File.basename(path)
-        @root[dirname].reject! {|file| file.directory == false && file.name == basename}
-        @contents.delete(path)
+      return false unless use_allowed?(path, :delete, user)
+      dirname = File.dirname(path)
+      basename = File.basename(path)
+      dir = get_item(dirname)
+      if dir and dir.directory and dir.contents[basename]
+        dir.contents.delete(basename)
         return true
       end
       false
     end
     
     def delete_dir(path, user = nil)
-      if is_dir(path) && @root[path].empty?
+      dir = get_item(path)
+      if dir and dir.directory and dir.contents.empty?
         return false unless use_allowed?(path, :delete, user)
-        @root.delete(path)
         dirname = File.dirname(path)
         basename = File.basename(path)
-        @root[dirname].reject! {|file| file.directory == true && file.name == basename}
+        parent = get_item(dirname)
+        parent.contents.delete(basename)
         return true
       end
       false
     end
     
     def create_dir(path, user = "nobody")
-      if not exist?(path)
+      dir = get_item(path)
+      if dir.nil?
         return false unless use_allowed?(path, :create, user)
         dirname = File.dirname(path)
         basename = File.basename(path)
-        if is_dir(dirname)
-          @root[path] = Array.new
-          @root[dirname] << EM::FTPD::DirectoryItem.new(:name => basename, :directory => true, :size => 0)
+        parent = get_item(dirname)
+        if parent and parent.directory
+          parent.contents[basename] = MemoryDirectoryItem.new(:name => basename, :directory => true, :owner => user, :contents => Hash.new)
           return true
         end
       end
@@ -123,8 +164,10 @@ module EM::FTPD::Memory
     end
     
     def rename(from, to, user = nil)
-      return false if exist?(to)
-      return false unless exist?(from)
+      titem = get_item(to)
+      return false if titem
+      fitem = get_item(from)
+      return false unless fitem
       return false unless use_allowed?(from, :delete, user)
       return false unless use_allowed?(to, :create, user)
       
@@ -133,86 +176,52 @@ module EM::FTPD::Memory
       to_dirname = File.dirname(to)
       to_basename = File.basename(to)
       
-      if from_dirname == to_dirname
-        @root[from_dirname].find {|file| file.name == from_basename}.name = to_basename
-      else
-        entry = @root[from_dirname].find {|file| file.name == from_basename}
-        @root[from_dirname] -= [entry]
-        entry.name = to_basename
-        @root[to_dirname] << entry
-      end
+      dir1 = get_item(from_dirname)
+      dir2 = get_item(to_dirname)
+      fitem.name = to_basename
+      dir2.contents[to_basename] = fitem
+      dir1.contents.delete(from_basename)
       
-      if is_dir(from)
-        @root[to] = @root[from]
-        @root.delete(from)
-      else
-        # @contents[to] points to the same reference/pointer as @contents[from]
-        # i.e., this is not a copy, they point to the same object
-        @contents[to] = @contents[from]
-        @contents.delete(from)
-      end
       return true
     end
     
     def destroy
-      @root.each_key do |d|
-        @root.delete(d)
-      end
-      @contents.each_key do |f|
-        @contents.delete(f)
-      end
+      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
       GC.start
     end
     
     def set_permissions(path, permissions, user = nil)
-      return false unless exist?(path)
+      item = get_item(path)
+      return false unless item
       raise InvalidPermissionsError.new if permissions.nil?
       raise InvalidPermissionsError.new(permissions.to_s) unless permissions.class == String
       raise InvalidPermissionsError.new(permissions) unless permissions =~ /^[r\.][w\.][x\.][r\.][w\.][x\.][r\.][w\.][x\.]$/
       if use_allowed?(path, :chmod, user)
-        entry = get_entry(path)
-        entry.permissions = permissions
+        item.permissions = permissions
         return true
       end
       false
     end
     
     def set_owner(path, owner, user = nil)
-      return false unless exist?(path) and owner and owner.class == String
-      entry = get_entry(path)
+      item = get_item(path)
+      return false unless item and owner and owner.class == String
       return false unless user and user == "root"
-      return false unless entry
-      entry.owner = owner
+      item.owner = owner
       true
     end
 
-    #private 
-    
-    def get_entry(path)
-      return @root_entry if path == '/'
-      dirname = File.dirname(path)
-      basename = File.basename(path)
-      if is_dir(dirname)
-        return @root[dirname].find {|entry| entry.name == basename}
-      end
-      nil
-    end
+    #private
     
-    def get_file(path)
-      dirname = File.dirname(path)
-      basename = File.basename(path)
-      if is_dir(dirname)
-        return @root[dirname].find {|file| file.directory == false && file.name == basename}
+    def get_item(path)
+      cur = @root
+      path.split(/\//).each do |part|
+        next if part == ""
+        raise ArgumentError.new("Use of . and .. are forbidden") if part == "." or part == ".."
+        cur = cur.contents[part]
+        return nil if cur.nil?
       end
-      nil
-    end
-    
-    def is_file(path)
-      @contents[path] || false
-    end
-    
-    def is_dir(path)
-      @root[path] != nil
+      cur
     end
     
     def use_allowed?(path, use, username)
@@ -241,8 +250,8 @@ module EM::FTPD::Memory
       when :time
         return true # since we've already checked everything
       when :chmod
-        entry = get_entry(path)
-        return entry.owner == username
+        item = get_item(path)
+        return item.owner == username
       when :delete
         return allowed?(dirname, "rwx", username)
       when :create
@@ -253,12 +262,12 @@ module EM::FTPD::Memory
     end
     
     def allowed?(path, required_permissions, username)
-      entry = get_entry(path)
-      permissions = entry.permissions || 'rwxrwxrwx'
-      return false unless entry
+      item = get_item(path)
+      return false unless item
+      permissions = item.permissions || 'rwxrwxrwx'
       if username.nil?
         perms = permissions[6,3]
-      elsif entry.owner == username
+      elsif item.owner == username
         perms = permissions[0,3]
       else
         perms = permissions[6,3]

data/test/test_ftpd-memory.rb

@@ -20,11 +20,35 @@ class TestFTPDMemory < Minitest::Test
       "pwalgo" => "otp",
       
     }
+    # set up the authentication
     auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    # add a test user
     auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
+    # create the filesystem
     fs = FileSystem.getFileSystem(options["filesystem_name"])
-    fs.create_dir("/pub")
-    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    # add a pub folder
+    fs.create_dir("/pub", 'root')
+    # add a file to the pub folder as root
+    fs.create_file("/pub/helper.rb", "test/helper.rb", 'root')
+    # chmod 755 /pub
+    fs.set_permissions("/pub", 'rwxr.xr.x', "root")
+    # create /uploads as root
+    fs.create_dir("/uploads", 'root')
+    # chmod 777 /uploads
+    fs.set_permissions("/uploads", "rwxrwxrwx", "root")
+    # create /users as root
+    fs.create_dir("/users", 'root')
+    # chmod 755 /users
+    fs.set_permissions("/users", "rwxr.xr.x", "root")
+    # create a personal directory for hiro, miyako, and pilar, (and add their test user)
+    ["hiro", "miyako", "pilar"].each do |username|
+      fs.create_dir("/users/#{username}", 'root')
+      # set the permissions so that no one else can access it
+      fs.set_permissions("/users/#{username}", "rwx......", "root")
+      # set the owner to the user
+      fs.set_owner("/users/#{username}", username, 'root')
+      auth << User.new(username, username)
+    end
     
     EM.run {
       EventMachine::start_server("0.0.0.0", 2021, EM::FTPD::Server, EM::FTPD::Memory::Driver, options)

data/test/test_memory_filesystem.rb

@@ -23,70 +23,76 @@ class TestMemoryFilesystem < Minitest::Test
   
   def test_file_creation
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_file("/helper.rb", "test/helper.rb")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    assert(fs.create_file("/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/helper.rb"))
-    refute(fs.is_dir("/helper.rb"))
-    assert(fs.is_file("/helper.rb"))
+    refute(fs.is_dir?("/helper.rb"))
+    assert(fs.is_file?("/helper.rb"))
     assert_equal(169, fs.file_size("/helper.rb"))
     FileSystem.destroyFileSystem(__method__)
   end
   
   def test_file_deletion
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_file("/helper.rb", "test/helper.rb")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    assert(fs.create_file("/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/helper.rb"))
-    refute(fs.is_dir("/helper.rb"))
-    assert(fs.is_file("/helper.rb"))
+    refute(fs.is_dir?("/helper.rb"))
+    assert(fs.is_file?("/helper.rb"))
     assert_equal(169, fs.file_size("/helper.rb"))
-    fs.delete_file("/helper.rb")
+    assert(fs.delete_file("/helper.rb"))
     refute(fs.exist?("/helper.rb"))
     FileSystem.destroyFileSystem(__method__)
   end
   
   def test_create_directory
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_dir("/pub")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    
+    assert(fs.create_dir("/pub"))
     assert(fs.exist?("/pub"))
-    assert(fs.is_dir("/pub"))
-    refute(fs.is_file("/pub"))
+    assert(fs.is_dir?("/pub"))
+    refute(fs.is_file?("/pub"))
     
-    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/pub/helper.rb"))
     assert_equal(169, fs.file_size("/pub/helper.rb"))
-    fs.delete_file("/pub/helper.rb")
+    assert(fs.delete_file("/pub/helper.rb"))
     refute(fs.exist?("/pub/helper.rb"))
     FileSystem.destroyFileSystem(__method__)
   end
   
   def test_delete_directory
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_dir("/pub")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    assert(fs.create_dir("/pub"))
     assert(fs.exist?("/pub"))
-    assert(fs.is_dir("/pub"))
-    refute(fs.is_file("/pub"))
+    assert(fs.is_dir?("/pub"))
+    refute(fs.is_file?("/pub"))
     
-    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.create_file("/pub/helper.rb", "test/helper.rb", "root"))
     assert(fs.exist?("/pub/helper.rb"))
-    assert_equal(169, fs.file_size("/pub/helper.rb"))
-    refute(fs.delete_dir("/pub"))
-    fs.delete_file("/pub/helper.rb")
+    assert_equal(169, fs.file_size("/pub/helper.rb", "root"))
+    refute(fs.delete_dir("/pub", "root"))
+    assert(fs.delete_file("/pub/helper.rb", "root"))
     refute(fs.exist?("/pub/helper.rb"))
-    assert(fs.delete_dir("/pub"))
+    assert(fs.delete_dir("/pub", "root"))
     refute(fs.exist?("/pub"))
     FileSystem.destroyFileSystem(__method__)
   end
   
   def test_file_rename
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_dir("/pub")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    assert(fs.create_dir("/pub"))
     assert(fs.exist?("/pub"))
-    assert(fs.is_dir("/pub"))
-    refute(fs.is_file("/pub"))
+    assert(fs.is_dir?("/pub"))
+    refute(fs.is_file?("/pub"))
     
-    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/pub/helper.rb"))
     assert_equal(169, fs.file_size("/pub/helper.rb"))
-    fs.rename("/pub/helper.rb", "/pub/helper.txt")
+    assert(fs.rename("/pub/helper.rb", "/pub/helper.txt"))
     refute(fs.exist?("/pub/helper.rb"))
     assert(fs.exist?("/pub/helper.txt"))
     assert_equal(169, fs.file_size("/pub/helper.txt"))
@@ -96,19 +102,20 @@ class TestMemoryFilesystem < Minitest::Test
   
   def test_file_move_between_directories
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_dir("/pub")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    assert(fs.create_dir("/pub"))
     assert(fs.exist?("/pub"))
-    assert(fs.is_dir("/pub"))
-    refute(fs.is_file("/pub"))
-    fs.create_dir("/pub2")
+    assert(fs.is_dir?("/pub"))
+    refute(fs.is_file?("/pub"))
+    assert(fs.create_dir("/pub2"))
     assert(fs.exist?("/pub2"))
-    assert(fs.is_dir("/pub2"))
-    refute(fs.is_file("/pub2"))
+    assert(fs.is_dir?("/pub2"))
+    refute(fs.is_file?("/pub2"))
     
-    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/pub/helper.rb"))
     assert_equal(169, fs.file_size("/pub/helper.rb"))
-    fs.rename("/pub/helper.rb", "/pub2/helper.txt")
+    assert(fs.rename("/pub/helper.rb", "/pub2/helper.txt"))
     refute(fs.exist?("/pub/helper.rb"))
     assert(fs.exist?("/pub2/helper.txt"))
     assert_equal(169, fs.file_size("/pub2/helper.txt"))
@@ -118,23 +125,24 @@ class TestMemoryFilesystem < Minitest::Test
   
   def test_rename_directory
     fs = FileSystem.getFileSystem(__method__)
-    fs.create_dir("/pub")
+    assert(fs.set_permissions("/", "rwxrwxrwx", "root"))
+    assert(fs.create_dir("/pub"))
     assert(fs.exist?("/pub"))
-    assert(fs.is_dir("/pub"))
-    refute(fs.is_file("/pub"))
-    fs.create_dir("/pub2")
+    assert(fs.is_dir?("/pub"))
+    refute(fs.is_file?("/pub"))
+    assert(fs.create_dir("/pub2", "root"))
     assert(fs.exist?("/pub2"))
-    assert(fs.is_dir("/pub2"))
-    refute(fs.is_file("/pub2"))
-    fs.create_file("/pub3", "test/helper.rb")
+    assert(fs.is_dir?("/pub2"))
+    refute(fs.is_file?("/pub2"))
+    assert(fs.create_file("/pub3", "test/helper.rb"))
     assert(fs.exist?("/pub3"))
-    refute(fs.is_dir("/pub3"))
-    assert(fs.is_file("/pub3"))
+    refute(fs.is_dir?("/pub3"))
+    assert(fs.is_file?("/pub3"))
     assert_equal(169, fs.file_size("/pub3"))
     
     refute(fs.rename("/pub", "/pub2"))
     refute(fs.rename("/pub", "/pub3"))
-    assert(fs.delete_file("/pub3"))
+    assert(fs.delete_file("/pub3", "root"))
     assert(fs.rename("/pub", "/pub3"))
     
     FileSystem.destroyFileSystem(__method__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: em-ftpd-memory
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - chrislee35
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-16 00:00:00.000000000 Z
+date: 2015-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-ftpd