em-ftpd-memory 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 59b7c1d4a65d038d0a2addbbccbf1697a1f4e6c4
-  data.tar.gz: 605868d7a3280ff3f5b0ad062acee5f31b8a97cb
+  metadata.gz: ff070a000cded7f1c145979f7a4c42285e2c1075
+  data.tar.gz: f09bce2a5fdf592df680dd9c76512cfd0423940b
 SHA512:
-  metadata.gz: f2d538c602e0060ebcc469f81bb8d33a583b8a825e13ea060583bbb270535e8aec86080757536b48bd096fb90af20c0ee6eadad6e5c84e7c2e1497c4bdb904f7
-  data.tar.gz: d811d57df20890c04e1687c8a32cd3b0b88680a705fd34d70bd3ee7533b29c23f143d73b221c7c639a7c7876662c17b4a3cd42e7d3f0fcac79cd15227e346a5d
+  metadata.gz: 4384dee7ef945d52725be5732013ab356e54a7d1cf07833a971ffee061405864a1dce0e91c453e95f6643f96f7f2e07a9b96574c8edc072d12b6f2841c898914
+  data.tar.gz: 4b5da1d0cdbc510f8824043b7322a842df89117c98aabca89613809286e333562714adeacca34a4b505154ad79d6e3c352d4855ed6b80369b0c919ac873139b0

data/README.md

@@ -28,20 +28,32 @@ Or install it yourself as:
       "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"])
+	# 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

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.5"
+  spec.version       = "0.0.6"
   spec.authors       = ["chrislee35"]
   spec.email         = ["rubygems@chrislee.dhs.org"]
   spec.summary       = %q{Memory-based backing store for em-ftpd}

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

@@ -2,7 +2,7 @@ require 'em-ftpd'
 require 'digest/md5'
 
 module EM::FTPD::Memory
-  class User < Struct.new(:name, :credential); end
+  class User < Struct.new(:name, :algo, :credential); end
   class InvalidPasswordAlgorithmError < StandardError; end
   class NoSuchUserError < StandardError; end
   class InvalidCredentialError < StandardError; end
@@ -12,24 +12,23 @@ module EM::FTPD::Memory
 
   class Authenticator
     @@realms = Hash.new
-    def self.getAuthenticatorByRealm(realm, options = {})
+    def self.getAuthenticatorByRealm(realm)
       if @@realms[realm].nil?
-        @@realms[realm] = Authenticator.new(options)
+        @@realms[realm] = Authenticator.new
       end
       #puts "returning Authenticator of realm #{realm}"
       @@realms[realm]
     end
   
-    def initialize(options = {})
+    def initialize
       @users = Hash.new
-      @pwalgo = options["pwalgo"] || "plain"
-      @pwalgo = "#{@pwalgo}_authentication".to_sym
-      unless self.respond_to?(@pwalgo)
-        raise InvalidPasswordAlgorithmError.new
-      end
     end
   
     def <<(user)
+      unless self.respond_to?("#{user.algo}_authentication".to_sym)
+        raise InvalidPasswordAlgorithmError.new
+      end
+      user.algo = "#{user.algo}_authentication".to_sym
       @users[user.name] = user
     end
   
@@ -41,7 +40,7 @@ module EM::FTPD::Memory
       if @users[username].nil?
         raise NoSuchUserError.new
       end
-      self.send(@pwalgo, username, credential)
+      self.send(@users[username].algo, username, credential)
     end
   
     def plain_authentication(username, credential)

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

@@ -41,10 +41,8 @@ module EM::FTPD::Memory
     end
 
 
-# TODO: support groups
-    
     def initialize
-      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
+      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :group => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
     end
 
     def exist?(path)
@@ -68,13 +66,13 @@ module EM::FTPD::Memory
       true
     end
     
-    def change_dir(path, user = nil)
+    def change_dir(path, user = nil, groups = [])
       item = get_item(path)
-      item.directory && use_allowed?(path, :list, user)
+      item.directory && use_allowed?(path, :list, user, groups)
     end
     
-    def list_files(path, user = nil)
-      return [] unless use_allowed?(path, :list, user)
+    def list_files(path, user = nil, groups = [])
+      return [] unless use_allowed?(path, :list, user, groups)
       item = get_item(path)
       if item.directory
         return item.contents.values
@@ -82,28 +80,28 @@ module EM::FTPD::Memory
       return []
     end
     
-    def file_size(path, user = nil)
-      return false unless use_allowed?(path, :size, user)
+    def file_size(path, user = nil, groups = [])
+      return false unless use_allowed?(path, :size, user, groups)
       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)
+    def modified_time(path, user = nil, groups = [])
+      return nil unless use_allowed?(path, :time, user, groups)
       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)
+    def file_contents(path, user = nil, groups = [])
+      return false unless use_allowed?(path, :read, user, groups)
       item = get_item(path)
       item.contents || false
     end
     
-    def create_file(path, data, user = "nobody")
-      return false unless use_allowed?(path, :create, user)
+    def create_file(path, data, user = "nobody", groups = [])
+      return false unless use_allowed?(path, :create, user, groups)
       dirname = File.dirname(path)
       basename = File.basename(path)
       dir = get_item(dirname)
@@ -123,8 +121,8 @@ module EM::FTPD::Memory
       end
     end
     
-    def delete_file(path, user = nil)
-      return false unless use_allowed?(path, :delete, user)
+    def delete_file(path, user = nil, groups = [])
+      return false unless use_allowed?(path, :delete, user, groups)
       dirname = File.dirname(path)
       basename = File.basename(path)
       dir = get_item(dirname)
@@ -135,10 +133,10 @@ module EM::FTPD::Memory
       false
     end
     
-    def delete_dir(path, user = nil)
+    def delete_dir(path, user = nil, groups = [])
       dir = get_item(path)
       if dir and dir.directory and dir.contents.empty?
-        return false unless use_allowed?(path, :delete, user)
+        return false unless use_allowed?(path, :delete, user, groups)
         dirname = File.dirname(path)
         basename = File.basename(path)
         parent = get_item(dirname)
@@ -148,10 +146,10 @@ module EM::FTPD::Memory
       false
     end
     
-    def create_dir(path, user = "nobody")
+    def create_dir(path, user = "nobody", groups = [])
       dir = get_item(path)
       if dir.nil?
-        return false unless use_allowed?(path, :create, user)
+        return false unless use_allowed?(path, :create, user, groups)
         dirname = File.dirname(path)
         basename = File.basename(path)
         parent = get_item(dirname)
@@ -163,13 +161,13 @@ module EM::FTPD::Memory
       return false
     end
     
-    def rename(from, to, user = nil)
+    def rename(from, to, user = nil, groups = [])
       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)
+      return false unless use_allowed?(from, :delete, user, groups)
+      return false unless use_allowed?(to, :create, user, groups)
       
       from_dirname = File.dirname(from)
       from_basename = File.basename(from)
@@ -186,30 +184,38 @@ module EM::FTPD::Memory
     end
     
     def destroy
-      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
+      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :group => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
       GC.start
     end
     
-    def set_permissions(path, permissions, user = nil)
+    def set_permissions(path, permissions, user = nil, groups = [])
       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)
+      if use_allowed?(path, :chmod, user, groups)
         item.permissions = permissions
         return true
       end
       false
     end
     
-    def set_owner(path, owner, user = nil)
+    def set_owner(path, owner, user = nil, groups = [])
       item = get_item(path)
       return false unless item and owner and owner.class == String
       return false unless user and user == "root"
       item.owner = owner
       true
     end
+    
+    def set_group(path, group, user = nil, groups = [])
+      item = get_item(path)
+      return false unless item and group and group.class == String
+      return false unless user and user == "root"
+      return false unless groups.index(group)
+      item.group = group
+    end
 
     #private
     
@@ -224,7 +230,7 @@ module EM::FTPD::Memory
       cur
     end
     
-    def use_allowed?(path, use, username)
+    def use_allowed?(path, use, username, groups = [])
       return true if username == 'root'
       
       dirname = File.dirname(path)
@@ -234,17 +240,17 @@ module EM::FTPD::Memory
       dirname.split(/\//).each do |dir|
         next if dir == '/'
         cwd << dir
-        return false unless allowed?(cwd, "rx", username)
+        return false unless allowed?(cwd, "rx", username, groups)
         cwd << '/'
       end
       
       case use
       when :read
-        return allowed?(path, 'r', username)
+        return allowed?(path, 'r', username, groups)
       when :write
-        return allowed?(path, 'w', username)
+        return allowed?(path, 'w', username, groups)
       when :list
-        return allowed?(path, 'rx', username)
+        return allowed?(path, 'rx', username, groups)
       when :size
         return true # since we've already checked everything
       when :time
@@ -253,15 +259,15 @@ module EM::FTPD::Memory
         item = get_item(path)
         return item.owner == username
       when :delete
-        return allowed?(dirname, "rwx", username)
+        return allowed?(dirname, "rwx", username, groups)
       when :create
-        return allowed?(dirname, "rwx", username)
+        return allowed?(dirname, "rwx", username, groups)
       else
         return false
       end
     end
     
-    def allowed?(path, required_permissions, username)
+    def allowed?(path, required_permissions, username, groups)
       item = get_item(path)
       return false unless item
       permissions = item.permissions || 'rwxrwxrwx'
@@ -269,6 +275,8 @@ module EM::FTPD::Memory
         perms = permissions[6,3]
       elsif item.owner == username
         perms = permissions[0,3]
+      elsif groups.index(item.group)
+        perms = permissions[3,3]
       else
         perms = permissions[6,3]
       end

data/test/test_authenticator.rb

@@ -12,22 +12,15 @@ include EM::FTPD::Memory
 
 class TestAuthenticator < Minitest::Test
   def test_invalid_pwalgo
-    options = {
-      "pwalgo" => "nogood",
-      "authentication_realm" => "invalid"
-    }
     assert_raises(InvalidPasswordAlgorithmError) do
-      Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+      auth = Authenticator.getAuthenticatorByRealm(__method__)
+      auth << User.new("test", "nogood", "test")
     end
   end
     
   def test_plain_login
-    options = {
-      "pwalgo" => "plain",
-      "authentication_realm" => "plain"
-    }
-    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
-    auth << User.new("test", "test")
+    auth = Authenticator.getAuthenticatorByRealm(__method__)
+    auth << User.new("test", "plain", "test")
     assert_raises(NoSuchUserError) do
       auth.authenticate("jerk", "noway")
     end
@@ -40,12 +33,8 @@ class TestAuthenticator < Minitest::Test
   end
   
   def test_time_based_login
-    options = {
-      "pwalgo" => "timed_md5",
-      "authentication_realm" => "time_based"
-    }
-    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
-    auth << User.new("test", "test")
+    auth = Authenticator.getAuthenticatorByRealm(__method__)
+    auth << User.new("test", "timed_md5", "test")
     assert_raises(NoSuchUserError) do
       auth.authenticate("jerk", "noway")
     end
@@ -85,12 +74,8 @@ class TestAuthenticator < Minitest::Test
   end
   
   def test_otp_login
-    options = {
-      "pwalgo" => "otp",
-      "authentication_realm" => "otp"
-    }
-    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
-    auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
+    auth = Authenticator.getAuthenticatorByRealm(__method__)
+    auth << User.new("test", "otp", "test1\ntest2\ntest3\ntest4\ntest5")
     assert_raises(NoSuchUserError) do
       auth.authenticate("jerk", "noway")
     end

data/test/test_ftpd-memory.rb

@@ -14,18 +14,12 @@ include EM::FTPD::Memory
 
 class TestFTPDMemory < Minitest::Test
   def test_example
-    options = {
-      "filesystem_name" => "boss",
-      "authentication_realm" => "georgia",
-      "pwalgo" => "otp",
-      
-    }
     # set up the authentication
-    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    auth = Authenticator.getAuthenticatorByRealm("georgia")
     # add a test user
-    auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
+    auth << User.new("test", "otp", "test1\ntest2\ntest3\ntest4\ntest5")
     # create the filesystem
-    fs = FileSystem.getFileSystem(options["filesystem_name"])
+    fs = FileSystem.getFileSystem("boss")
     # add a pub folder
     fs.create_dir("/pub", 'root')
     # add a file to the pub folder as root
@@ -47,9 +41,13 @@ class TestFTPDMemory < Minitest::Test
       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)
+      auth << User.new(username, "plain", username)
     end
     
+    options = {
+      "filesystem_name" => "boss",
+      "authentication_realm" => "georgia"
+    }
     EM.run {
       EventMachine::start_server("0.0.0.0", 2021, EM::FTPD::Server, EM::FTPD::Memory::Driver, options)
       EM::Timer.new(0.1) do

data/test/test_memory_filesystem.rb

@@ -190,6 +190,14 @@ class TestMemoryFilesystem < Minitest::Test
     refute(fs.set_permissions("/pub/pub2/pub3", "rwx......", "jem"))
     assert(fs.set_permissions("/pub/pub2", "rwxr.xr.x", "root"))
     assert(fs.set_permissions("/pub/pub2/pub3", "rwx......", "jem"))
+    
+    assert(fs.create_dir("/group_test", "root"))
+    assert(fs.set_group("/group_test", "test", "root", ["test"]))
+    assert(fs.set_permissions("/group_test", "rwxr.x...", "root"))
+    assert(fs.create_file("/group_test/test", "test/helper.rb", "root"))
+    assert_equal(0, fs.list_files("/group_test", "jem", ["nottest"]).length)
+    assert_equal(1, fs.list_files("/group_test", "jem", ["test", "other", "punkbands"]).length)
+    
   end
 
 end

metadata

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