homefs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd9b532279081ee10b0b4d63e5bf21e93f7316bf
+  data.tar.gz: 9bf006b0347c6e0a67f3b5e22de6bc2e3d16e916
+SHA512:
+  metadata.gz: f011c0e7dd3ce87b40d9acdda973c3f1f931680ba6f57da40129b8cbe159c9fba6811d07dc93cd3cf5b08ec8c4b1de970c2c8ca635b0089df48d40b47c99c3c5
+  data.tar.gz: 5737dba4cc80076d2c99c8fea79ba9b4fdd0ef33b1f78bbf9230b30b2d5069885b829481d4e66b91e9013d0b180b6706e2d9dca8ba9e531fef4f0653bf15f3b7

data/bin/homefs

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'homefs'
+require 'rb-inotify'
+require 'fileutils'
+
+if ARGV.size < 2
+    warn "Usage:\n\t#{File.basename($0)} relative_directory mountpoint [options...]"
+    exit 1
+end
+
+# Return immediately
+if fork
+    exit 0
+end
+
+reldir = ARGV.shift
+
+fs = HomeFS.new(reldir)
+
+# Shut up
+$stdout = File.open("/dev/null", "w")
+$stderr = File.open("/dev/null", "w")
+
+pid = fork
+if pid
+    # The child process will be the one actually handling the FuseFS,
+    # so we want to exit as soon as it dies
+    trap 'CLD' do
+        exit 0
+    end
+
+    # Set a watch for /etc/passwd, and update our hash of UIDs => homedirs
+    # when it changes
+    notifier = INotify::Notifier.new
+    notifier.watch('/etc/passwd', :modify) do
+        # Send a signal to the child process; it will catch USR1 and update
+        # the homedirs hash
+        Process::kill('USR1', pid)
+    end
+    notifier.run
+else
+    # Here we trap the signal to be sent to us by our parent
+    # when /etc/passwd changes and update our hash accordingly
+    trap 'USR1' do
+        fs.read_passwd
+    end
+end
+
+# We set allow_other, because this filesystem doesn't really make sense
+# without it (why direct different users to different places if only one
+# user can access the filesystem?).
+FuseFS.main(ARGV + ["-o", "allow_other"]) { fs }

data/lib/homefs/homefs.rb

@@ -0,0 +1,172 @@
+require 'rfusefs'
+
+class HomeFS
+    def initialize(path)
+        @relpath = path
+        @dirlinks = Hash.new
+        read_passwd
+    end
+
+    def read_passwd
+        # Here we map each line in /etc/passwd to an array,
+        # which Hash interprets as a key, value pair.
+        @homedirs = Hash[
+          File.readlines('/etc/passwd').map do |line|
+              next if line.strip.empty?
+              values = line.split(':')
+              # UID, home directory
+              [Integer(values[2]), values[5]]
+          end
+        ]
+    end
+
+    def homepath(path = nil)
+        uid = FuseFS.reader_uid
+        basepath = @homedirs[uid]
+        # basepath shouldn't ever be nil, but fail gracefully just
+        # in case.
+        raise Errno::ENOENT if basepath == nil
+        if path
+            "#{basepath}/#{@relpath}/#{path}"
+        else
+            "#{basepath}/#{@relpath}"
+        end
+    end
+
+    def mode_mask(file, mask, check_ids = true)
+        stat = File.stat(file)
+        # First digit: setuid (4), setgid (2), sticky bit (1)
+        # Second, third, and fourth digits: user, group, and
+        # world permissions for read (4), write (2), execute (1)
+        # (see `man chmod` for more)
+        fmode = stat.mode
+        if check_ids
+            fuid, fgid = stat.uid, stat.gid
+            uid, gid = FuseFS.reader_uid, FuseFS.reader_gid
+            # Zero out the third digit (in octal).
+            # We could use a constant here, but this works
+            # for a mask of any length
+            if uid != fuid
+                mask &= ~(mask & 0700)
+            end
+            if gid != fgid
+                mask &= ~(mask & 0070)
+            end
+        end
+        fmode & mask != 0
+    end
+
+    def rename(from_path, to_path)
+        FileUtils.mv(homepath(from_path), homepath(to_path))
+    end
+
+    def touch(path, modtime)
+        File.utime(modtime, modtime, homepath(path))
+    end
+
+    def rmdir(path)
+        FileUtils.rmdir(homepath(path))
+    end
+
+    def can_rmdir?(path)
+        File.writable?(homepath(path))
+    end
+
+    def mkdir(path)
+        FileUtils.mkdir(homepath(path))
+    end
+
+    def can_mkdir?(path)
+        writable?(File.dirname(homepath(path)))
+    end
+
+    def delete(path)
+        FileUtils.rm(homepath(path))
+    end
+
+    def can_delete?(path)
+        writable?(File.dirname(homepath(path)))
+    end
+
+    def write_to(path, str)
+        File.open(homepath(path), "wb") {|file| file.write(str) }
+    end
+
+    def writable?(path)
+        mode_mask(path, 0222)
+    end
+
+    def can_write?(path)
+        hpath = homepath(path)
+        if File.exist?(hpath)
+            writable?(hpath)
+        else
+            # FIXME: We don't support sticky bits
+            writable?(File.dirname(hpath))
+        end
+    end
+
+    def times(path)
+        atime = File.atime(homepath(path))
+        mtime = File.mtime(homepath(path))
+        ctime = File.ctime(homepath(path))
+        [atime, mtime, ctime]
+    end
+
+    def executable?(path)
+        mode_mask(homepath(path), 0111)
+    end
+
+    def read_file(path)
+        File.open(homepath(path), "rb") do |file|
+            file.read
+        end
+    end
+
+    def contents(path)
+        Dir.new(homepath(path)).to_a
+    end
+
+    def size(path)
+        File.size(homepath(path))
+    end
+
+    def file?(path)
+        File.file?(homepath(path))
+    end
+
+    def directory?(path)
+        File.directory?(homepath(path))
+    end
+
+    def raw_open(path, mode, rfusefs = nil)
+        mode = case mode
+               when "rw" then File::RDWR | File::CREAT | File::BINARY
+               when "r"  then File::RDONLY | File::BINARY
+               when "w"  then File::WRONLY | File::CREAT | File::BINARY
+               end
+        File.open(homepath(path), mode)
+    end
+
+    def raw_read(path, offset, size, raw = nil)
+        raw ||= raw_open(path, "r")
+        raw.seek(offset, :SET)
+        raw.read(size)
+    end
+
+    def raw_sync(path, datasync, raw = nil)
+        return if raw.nil? # Should we sync anyway?
+        raw.fdatasync
+    end
+
+    def raw_close(path, raw = nil)
+        return if raw.nil? # ???
+        raw.close
+    end
+
+    def raw_write(path, off, sz, buf, raw = nil)
+        raw ||= File.open(path, "w")
+        raw.seek(off, :SET)
+        raw.write(buf[0...sz])
+    end
+end

data/lib/homefs.rb

@@ -0,0 +1 @@
+require 'homefs/homefs'

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: homefs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dylan Frese
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-26 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  FuseFS currently written in Ruby that directs filesystem
+                      calls to a directory relative to the calling user's home
+                      directory.
+email: dmfrese@gmail.com
+executables:
+- homefs
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/homefs
+- lib/homefs.rb
+- lib/homefs/homefs.rb
+homepage: 
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: FUSE Filesystem
+test_files: []
+has_rdoc: