nfs-rb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f440d90e6bd9cfea1f685053754eb92315be08eae3ee3dbe3e836a53aaef8876
+  data.tar.gz: d1825c075ce0958424a316b09dd3ea62a0390f63b384f623f614f9e340b0828e
+SHA512:
+  metadata.gz: 64b46c26a4c0d7750c3a3fb1c9620d7dba015e867d1a0a010307d0cb6594e05b2aaad53e1f4ca6bda2b51b9e4da2787db6c96855892514a3dbbbe8149aaf7f41
+  data.tar.gz: c9f2d5dac95a9628faf95855d1338e44275a431c1802fe3843b413d8ceb2e277a45d85e243f07b844eb2d443f26f11f3d6f135445a3fadd19ae632849407f76b

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 1.0.0
+* Birthday!

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'pry-byebug'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec', '~> 3.0'
+end

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Cameron Dutro
+
+Adapted from code originally written by Brian Ollenberger, available at https://github.com/bollenberger/nfs. No license accompanied the original code.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+## nfs-rb
+
+An NFS v2 server implemented in pure Ruby.
+
+Adapted from code written by Brian Ollenberger, available [here](https://github.com/bollenberger/nfs).
+
+## What is NFS?
+
+NFS, or "Network File System," is a protocol developed by Sun Microsystems in the 1980s that allows a filesystem to be accessed remotely over a network. MacOS, Windows, and Linux natively support mounting NFS volumes such that they appear alongside normal directories in the operating system's user interface.
+
+## Running the Server
+
+First, install the gem by running `gem install nfs-rb`, or add it to your Gemfile.
+
+Start the server with the default options by running `nfs-rb`. The various options can be seen by running `nfs-rb --help`:
+
+```
+Usage: nfs-rb [options]
+    -d, --dir [DIR]         The directory to serve. Defaults to the current directory.
+        --host [HOST]       The host to bind to. Defaults to 127.0.0.1.
+    -p, --port [PORT]       The port to bind to. Defaults to 2049.
+    -u, --udp               Communicate using UDP (default is TCP).
+    -v, --verbose           Enable verbose logging
+    -h, --help              Prints this help message
+```
+
+The server can also be started and managed in your Ruby code:
+
+```ruby
+require 'nfs'
+
+server = NFS::Server.new(
+  dir: '.',
+  host: '127.0.0.1',
+  port: 2049,
+  protocol: :tcp  # or :udp
+)
+
+# start server, return immediately
+server.start
+
+# start server, join to current thread
+server.join
+
+# shut server down
+server.shutdown
+```
+
+## Mounting
+
+Once the server is started, mount it using the following command.
+
+```bash
+mount -t nfs -o \
+  rsize=8192,wsize=8192,timeo=1,nfsvers=2,proto=tcp,\
+  retry=1,port=1234,mountport=1234,hard,intr,nolock \
+  127.0.0.1:/ path/to/mount/location
+```
+
+You should then be able to navigate to /path/to/mount/location and see a listing of all the files available on the networked filesystem.
+
+## Running Tests
+
+Run `bundle exec rspec` to run the test suite.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: https://github.com/camertron
+* Brian Ollenberger: https://github.com/bollenberger

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require 'nfs'
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/bin/nfs-rb

@@ -0,0 +1,52 @@
+#! /usr/bin/env ruby
+
+require 'optparse'
+require 'nfs'
+require 'logger'
+
+options = {}
+default_dir = '.'
+default_host = '127.0.0.1'
+default_port = 2049
+default_protocol = :tcp
+default_log_level = Logger::INFO
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: nfs-rb [options]"
+
+  opts.on('-d', '--dir [DIR]', 'The directory to serve. Defaults to the current directory.') do |dir|
+    options[:dir] = dir
+  end
+
+  opts.on('-h', '--host [HOST]', "The host to bind to. Defaults to #{default_host}.") do |host|
+    options[:host] = host
+  end
+
+  opts.on('-p', '--port [PORT]', "The port to bind to. Defaults to #{default_port}.") do |port|
+    options[:port] = port
+  end
+
+  opts.on('-u', '--udp', 'Communicate using UDP (default is TCP).') do
+    options[:protocol] = :udp
+  end
+
+  opts.on('-v', '--verbose', 'Enable verbose logging') do |log_level|
+    options[:log_level] = Logger::DEBUG
+  end
+
+  opts.on('-h', '--help', 'Prints this help message') do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!
+
+options[:dir] ||= default_dir
+options[:host] ||= default_host
+options[:port] ||= default_port
+options[:protocol] ||= default_protocol
+
+NFS.logger.level = options.delete(:log_level) || default_log_level
+NFS.logger.info("Starting NFS server on #{options[:host]}:#{options[:port]}, serving from '#{options[:dir]}'")
+NFS::Server.new(**options).join

data/lib/nfs.rb

@@ -0,0 +1,17 @@
+module NFS
+  class << self
+    attr_accessor :logger
+  end
+
+  autoload :DefaultLogger, 'nfs/default_logger'
+  autoload :FileProxy,     'nfs/file_proxy'
+  autoload :Filehandle,    'nfs/filehandle'
+  autoload :Mount,         'nfs/mount'
+  autoload :NFS,           'nfs/nfs'
+  autoload :Handler,       'nfs/handler'
+  autoload :Server,        'nfs/server'
+  autoload :SUNRPC,        'nfs/sunrpc'
+  autoload :XDR,           'nfs/xdr'
+end
+
+NFS.logger = NFS::DefaultLogger.new(STDOUT)

data/lib/nfs/default_logger.rb

@@ -0,0 +1,13 @@
+require 'logger'
+
+module NFS
+  class DefaultLogger < Logger
+    def initialize(*args)
+      super
+
+      self.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime} nfs-rb]  #{severity} -- : #{msg}\n"
+      end
+    end
+  end
+end

data/lib/nfs/file_proxy.rb

@@ -0,0 +1,117 @@
+module NFS
+  class FileProxy < ::File
+    class << self
+      def new(*args, &block)
+        super(*args, &block)._nfs_setup
+      end
+
+      def open(*args)
+        f = super(*args)._nfs_setup
+
+        if block_given?
+          begin
+            return yield(f)
+          ensure
+            f.close
+          end
+        end
+
+        f
+      end
+    end
+
+    def _nfs_setup
+      @absolute_path = File.expand_path(path)
+      @looked_up = {}
+      self
+    end
+
+    def create(name, mode, uid, gid)
+      f = nil
+
+      begin
+        f = self.class.new(_lookup(name), File::RDWR | File::CREAT, mode)
+      rescue
+        f = self.class.new(_lookup(name), File::RDONLY | File::CREAT, mode)
+      end
+
+      stat = f.lstat
+
+      @looked_up[[stat.ino, name]] = f
+
+      [f, stat]
+    end
+
+    def _lookup(name)
+      File.expand_path(name, @absolute_path)
+    end
+
+    def lookup(name)
+      f = nil
+
+      begin
+        f = self.class.new(_lookup(name), File::RDWR)
+      rescue
+        f = self.class.new(_lookup(name), File::RDONLY)
+      end
+
+      stat = f.lstat
+      key = [stat.ino, name]
+
+      if @looked_up.include?(key)
+        @looked_up[key]
+      else
+        @looked_up[key] = f
+      end
+    end
+
+    def delete(name)
+      File.delete(_lookup(name))
+    end
+
+    def rename(from_name, to_dir, to_name)
+      File.rename(_lookup(from_name), to_dir._lookup(to_name))
+    end
+
+    def link(dir, name)
+      File.link(@absolute_path, dir._lookup(name))
+    end
+
+    def symlink(name, to_name)
+      File.symlink(to_name, _lookup(name))
+    end
+
+    def readlink
+      File.readlink(@absolute_path)
+    end
+
+    def mkdir(name, mode, uid, gid)
+      path = _lookup(name)
+      Dir.mkdir(path, mode)
+
+      f = self.class.new(path)
+      #f.chown(uid, gid)
+
+      stat = f.lstat
+      @looked_up[[stat.ino, name]] = f
+
+      [f, stat]
+    end
+
+    def rmdir(name)
+      Dir.delete(_lookup(name))
+    end
+
+    def unlink(name)
+      File.unlink(_lookup(name))
+    end
+
+    def entries
+      Dir.entries(@absolute_path)
+    end
+
+    def utime(atime, mtime)
+      File.utime(atime, mtime, @absolute_path)
+    end
+  end
+end

data/lib/nfs/filehandle.rb

@@ -0,0 +1,24 @@
+module NFS
+  class Filehandle < ::String
+    def initialize
+      super("\0".b * NFS::FHSIZE)
+    end
+
+    def increment!
+      size.times do |i|
+        self[i] += 1
+        return self if self[i] != 0
+      end
+
+      self
+    end
+
+    def [](idx)
+      getbyte(idx)
+    end
+
+    def []=(idx, newval)
+      setbyte(idx, newval)
+    end
+  end
+end

data/lib/nfs/handler.rb

@@ -0,0 +1,570 @@
+module NFS
+  class Handler
+    def initialize(root = nil, fsid = 0)
+      @mount_prog = Mount::MOUNTPROG.dup
+      @mount_vers = Mount::MOUNTVERS
+      @nfs_prog = NFS::NFS_PROGRAM.dup
+      @nfs_vers = NFS::NFS_VERSION
+
+      @exports = {}
+      @fh_table = {}
+      @file_objects = {}
+      @next_fh = Filehandle.new
+
+      @fsid = fsid
+
+      if !root.nil?
+        export('/', root)
+      end
+
+      define_mount_procedures
+      define_nfs_procedures
+
+      instance_eval(&block) if block_given?
+    end
+
+    def programs
+      [@mount_prog, @nfs_prog]
+    end
+
+    def export(path, file)
+      @exports[path] = add_filehandle(file)
+    end
+
+    def add_filehandle(file)
+      if @file_objects.include?(file)
+        @file_objects[file]
+      else
+        @next_fh.dup.tap do |fh|
+          @fh_table[fh] = file
+          @file_objects[file] = fh
+          @next_fh.increment!
+        end
+      end
+    end
+
+    def handle_errors
+      begin
+        yield
+      rescue Errno::EPERM
+        { :_discriminant => :NFSERR_PERM }
+      rescue Errno::ENOENT
+        { _discriminant: :NFSERR_NOENT }
+      rescue Errno::EIO
+        { _discriminant: :NFSERR_IO }
+      rescue Errno::ENXIO
+        { _discriminant: :NFSERR_NXIO }
+      rescue Errno::EACCES
+        { _discriminant: :NFSERR_ACCES }
+      rescue Errno::EEXIST
+        { _discriminant: :NFSERR_EXIST }
+      rescue Errno::ENODEV
+        { _discriminant: :NFSERR_NODEV }
+      rescue Errno::ENOTDIR
+        { _discriminant: :NFSERR_NOTDIR }
+      rescue Errno::EISDIR
+        { _discriminant: :NFSERR_ISDIR }
+      rescue Errno::EINVAL
+        { _discriminant: :NFSERR_INVAL }
+      rescue Errno::EFBIG
+        { _discriminant: :NFSERR_FBIG }
+      rescue Errno::ENOSPC
+        { _discriminant: :NFSERR_NOSPC }
+      rescue Errno::EROFS
+        { _discriminant: :NFSERR_ROFS }
+      rescue Errno::ENAMETOOLONG
+        { _discriminant: :NFSERR_NAMETOOLONG }
+      rescue Errno::ENOTEMPTY
+        { _discriminant: :NFSERR_NOTEMPTY }
+      rescue Errno::EDQUOT
+        { _discriminant: :NFSERR_DQUOT }
+      rescue Errno::ESTALE
+        { _discriminant: :NFSERR_STALE }
+      rescue => e
+        # LOG
+        ::NFS.logger.error(e.message)
+        ::NFS.logger.error(e.backtrace.join("\n"))
+        { _discriminant: :NFSERR_IO }
+      end
+    end
+
+    def define_mount_procedures
+      @mount_prog.on_call(@mount_vers, :MNT) do |arg, auth, verf|
+        if @exports.include?(arg)
+          ::NFS.logger.info("MNT #{arg}")
+
+          {
+            _discriminant: :NFS_OK,
+            fhs_fhandle: {
+              data: @exports[arg]
+            }
+          }
+        else
+          { _discriminant: :NFSERR_ACCES }
+        end
+      end
+
+      @mount_prog.on_call(@mount_vers, :DUMP) do |arg, auth, verf|
+        ::NFS.logger.info('DUMP')
+        nil
+      end
+
+      @mount_prog.on_call(@mount_vers, :UMNT) do |arg, auth, verf|
+        ::NFS.logger.info("UMNT #{arg}")
+      end
+
+      @mount_prog.on_call(@mount_vers, :UMNTALL) do |arg, auth, verf|
+        ::NFS.logger.info("UMNTALL #{arg}")
+      end
+
+      export = proc do |arg, auth, verf|
+        ::NFS.logger.info('EXPORT')
+        result = nil
+
+        @exports.each_key do |name|
+          result = {
+            ex_dir: name,
+            ex_groups: nil,
+            ex_next: result
+          }
+        end
+
+        result
+      end
+
+      @mount_prog.on_call(@mount_vers, :EXPORT, &export)
+      @mount_prog.on_call(@mount_vers, :EXPORTALL, &export)
+    end
+
+    # Convert Ruby Stat object to an NFS fattr
+    def convert_attrs(attrs)
+      type = :NFNON
+      mode = attrs.mode
+
+      if attrs.file?
+        type = :NFREG
+        mode |= NFS::MODE_REG
+      elsif attrs.directory?
+        type = :NFDIR
+        mode |= NFS::MODE_DIR
+      elsif attrs.blockdev?
+        type = :NFBLK
+        mode |= NFS::MODE_BLK
+      elsif attrs.chardev?
+        type = :NFCHR
+        mode |= NFS::MODE_CHR
+      elsif attrs.symlink?
+        type = :NFLNK
+        mode |= NFS::MODE_LNK
+      elsif attrs.socket?
+        type = :NFSOCK
+        mode |= NFS::MODE_SOCK
+      end
+
+      {
+        type: type,
+        mode: mode,
+        nlink: attrs.nlink,
+        uid: attrs.uid,
+        gid: attrs.gid,
+        size: attrs.size,
+        blocksize: attrs.blksize,
+        rdev: attrs.rdev,
+        blocks: attrs.blocks,
+        fsid: @fsid,
+        fileid: attrs.ino,
+        atime: {
+          seconds: attrs.atime.tv_sec,
+          useconds: attrs.atime.tv_usec
+        },
+        mtime: {
+          seconds: attrs.mtime.tv_sec,
+          useconds: attrs.mtime.tv_usec
+        },
+        ctime: {
+          seconds: attrs.ctime.tv_sec,
+          useconds: attrs.ctime.tv_usec
+        }
+      }
+    end
+
+    def define_nfs_procedures
+      @nfs_prog.on_call(@nfs_vers, :GETATTR) do |arg, auth, verf|
+        handle_errors do
+          f = @fh_table[arg[:data]]
+          attrs = f.lstat
+
+          ::NFS.logger.info("GETATTR #{f.path}")
+
+          {
+            _discriminant: :NFS_OK,
+            attributes: convert_attrs(attrs)
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :SETATTR) do |arg, auth, verf|
+        changes = []
+
+        handle_errors do
+          f = @fh_table[arg[:file][:data]]
+          attrs = convert_attrs(f.lstat)
+
+          # Get -1 represented as an unsigned integer. The sattr fields
+          # are -1 to represent that they should not be changed.
+          neg_one = 4294967295
+
+          # Start with the mode. Setattr won't change the type of a file
+          # and apparently some NFS clients don't set the type, so mask
+          # that part out to keep what we have already.
+          if arg[:attributes][:mode] != neg_one
+            attrs[:mode] &= ~07777
+            attrs[:mode] |= 07777 & arg[:attributes][:mode]
+
+            new_mode = arg[:attributes][:mode] & 07777
+            changes << "mode: #{new_mode.to_s(8).rjust(5, '0')}"
+            f.chmod(new_mode)
+          end
+
+          # Next do the UID and GID
+          if arg[:attributes][:uid] != neg_one or
+            arg[:attributes][:gid] != neg_one
+
+            uid = arg[:attributes][:uid]
+            gid = arg[:attributes][:gid]
+
+            if uid == neg_one
+              uid = attrs[:uid]
+            end
+
+            if gid == neg_one
+              gid = attrs[:gid]
+            end
+
+            attrs[:uid] = uid
+            attrs[:gid] = gid
+
+            changes << "uid: #{uid}"
+            changes << "gid: #{gid}"
+
+            f.chown(uid, gid)
+          end
+
+          # Set size (truncate)
+          if arg[:attributes][:size] != neg_one
+            attrs[:size] = arg[:attributes][:size]
+            changes << "size: #{attrs[:size]}"
+            f.truncate(arg[:attributes][:size])
+          end
+
+          # Set time
+          if arg[:attributes][:atime][:seconds] != neg_one or
+            arg[:attributes][:mtime][:seconds] != neg_one
+
+            atime = arg[:attributes][:atime]
+            mtime = arg[:attributes][:mtime]
+
+            if atime[:seconds] == neg_one
+              atime = attrs[:atime]
+            end
+
+            if mtime[:seconds] == neg_one
+              mtime = attrs[:mtime]
+            end
+
+            attrs[:atime] = atime
+            attrs[:mtime] = mtime
+
+            atime = Time.at(atime[:seconds], atime[:useconds])
+            mtime = Time.at(mtime[:seconds], mtime[:useconds])
+
+            changes << "atime: #{atime}"
+            changes << "mtime: #{mtime}"
+
+            f.utime(atime, mtime)
+          end
+
+          ::NFS.logger.info("SETATTR #{f} #{changes.join(', ')}")
+
+          {
+            _discriminant: :NFS_OK,
+            attributes: attrs
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :ROOT) do |arg, auth, verf|
+        ::NFS.logger.info('ROOT')
+        # obsolete
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :LOOKUP) do |arg, auth, verf|
+        handle_errors do
+          f = @fh_table[arg[:dir][:data]].lookup(arg[:name])
+          ::NFS.logger.info("LOOKUP #{f.path}")
+          fh = add_filehandle(f)
+          attrs = f.lstat
+
+          result = {
+            _discriminant: :NFS_OK,
+            diropres: {
+              file: {
+                data: fh
+              },
+              attributes: convert_attrs(attrs)
+            }
+          }
+
+          result
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :READLINK) do |arg, auth, verf|
+        handle_errors do
+          f = @fh_table[arg[:data]]
+          ::NFS.logger.info("READLINK #{f.path}")
+          result = f.readlink
+
+          {
+            _discriminant: :NFS_OK,
+            data: result
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :READ) do |arg, auth, verf|
+        handle_errors do
+          f = @fh_table[arg[:file][:data]]
+          ::NFS.logger.info("READ #{f.path}")
+          attrs = f.lstat
+          f.pos = arg[:offset]
+          result = f.read(arg[:count])
+
+          {
+            _discriminant: :NFS_OK,
+            reply: {
+              attributes: convert_attrs(attrs),
+              data: result
+            }
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :WRITECACHE) do |arg, auth, verf|
+        ::NFS.logger.info('WRITECACHE')
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :WRITE) do |arg, auth, verf|
+
+        handle_errors do
+          f = @fh_table[arg[:file][:data]]
+          ::NFS.logger.info("WRITE #{f.path}")
+          f.pos = arg[:offset]
+          f.write(arg[:data])
+          f.flush
+          attrs = f.lstat
+
+          {
+            _discriminant: :NFS_OK,
+            attributes: convert_attrs(attrs)
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :CREATE) do |arg, auth, verf|
+        handle_errors do
+          dir = @fh_table[arg[:where][:dir][:data]]
+          name = arg[:where][:name]
+          ::NFS.logger.info("CREATE #{name}")
+
+          f, attrs = dir.create(
+            name,
+            arg[:attributes][:mode], arg[:attributes][:uid],
+            arg[:attributes][:gid]
+          )
+
+          fh = add_filehandle(f)
+
+          {
+            _discriminant: :NFS_OK,
+            diropres: {
+              file: {
+                data: fh
+              },
+              attributes: convert_attrs(attrs)
+            }
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :REMOVE) do |arg, auth, verf|
+        (handle_errors do
+          dir = @fh_table[arg[:dir][:data]]
+          name = arg[:name]
+          ::NFS.logger.info("REMOVE #{name}")
+          dir.unlink(name)
+
+          { _discriminant: :NFS_OK }
+        end)[:_discriminant]
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :RENAME) do |arg, auth, verf|
+        (handle_errors do
+          from_dir = @fh_table[arg[:from][:dir][:data]]
+          from_name = arg[:from][:name]
+          to_dir = @fh_table[arg[:to][:dir][:data]]
+          to_name = arg[:to][:name]
+
+          ::NFS.logger.info(
+            "RENAME #{File.join(from_dir.path, from_name)} -> #{File.join(to_dir.path, to_name)}"
+          )
+
+          from_dir.rename(from_name, to_dir, to_name)
+
+          { _discriminant: :NFS_OK }
+        end)[:_discriminant]
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :LINK) do |arg, auth, verf|
+        (handle_errors do
+          from = @fh_table[arg[:from][:data]]
+          to_dir = @fh_table[arg[:to][:dir][:data]]
+          to_name = arg[:to][:name]
+
+          ::NFS.logger.info("LINK #{from.path} -> #{File.join(to_dir.path, to_name)}")
+
+          from.link(to_dir, to_name)
+
+          { _discriminant: :NFS_OK }
+        end)[:_discriminant]
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :SYMLINK) do |arg, auth, verf|
+        (handle_errors do
+          dir = @fh_table[arg[:from][:dir][:data]]
+          name = arg[:from][:name]
+          to_name = arg[:to]
+          attrs = arg[:attributes]
+
+          ::NFS.logger.info("SYMLINK #{File.join(dir.path, name)} -> #{to_name}")
+
+          dir.symlink(name, to_name)
+
+          { _discriminant: :NFS_OK }
+        end)[:_discriminant]
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :MKDIR) do |arg, auth, verf|
+        handle_errors do
+          dir = @fh_table[arg[:where][:dir][:data]]
+          name = arg[:where][:name]
+
+          ::NFS.logger.info("MKDIR #{name}")
+
+          f, attrs = dir.mkdir(name, arg[:attributes][:mode],
+            arg[:attributes][:uid], arg[:attributes][:gid])
+
+          fh = add_filehandle(f)
+
+          {
+            _discriminant: :NFS_OK,
+            diropres: {
+              file: {
+                data: fh
+              },
+              attributes: convert_attrs(attrs)
+            }
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :RMDIR) do |arg, auth, verf|
+        (handle_errors do
+          dir = @fh_table[arg[:dir][:data]]
+          name = arg[:name]
+          ::NFS.logger.info("RMDIR #{name}")
+          dir.rmdir(name)
+
+          { _discriminant: :NFS_OK}
+        end)[:_discriminant]
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :READDIR) do |arg, auth, verf|
+        handle_errors do
+          dir = @fh_table[arg[:dir][:data]]
+          ::NFS.logger.info("READDIR #{dir.path}")
+
+          cookie = arg[:cookie]
+          count = arg[:count]
+
+          need_bytes = 16 + 12
+
+          entries = dir.entries
+
+          result_entries = nil
+          last_entry = nil
+
+          while cookie < entries.size && need_bytes < count
+            need_bytes += NFS::Filename.encode(entries[cookie]).size
+
+            next_entry = {
+              fileid: 1,
+              name: entries[cookie],
+              cookie: cookie
+            }
+
+            if not last_entry.nil?
+              last_entry[:nextentry] = next_entry
+              last_entry = next_entry
+            end
+
+            if result_entries.nil?
+              result_entries = next_entry
+              last_entry = next_entry
+            end
+
+            cookie += 1
+            need_bytes += 16
+          end
+
+          eof = :TRUE
+
+          if need_bytes > count
+            eof = :FALSE
+          end
+
+          if not last_entry.nil?
+            last_entry[:nextentry] = nil
+          end
+
+          {
+            _discriminant: :NFS_OK,
+            reply: {
+              entries: result_entries,
+              eof: eof
+            }
+          }
+        end
+      end
+
+      @nfs_prog.on_call(@nfs_vers, :STATFS) do |arg, auth, verf|
+        ::NFS.logger.info('STATFS')
+
+        handle_errors do
+          {
+            _discriminant: :NFS_OK,
+            reply: {
+              tsize: 1024,
+              bsize: 1024,
+              blocks: 100,
+              bfree: 100,
+              bavail: 100
+            }
+          }
+        end
+      end
+    end
+
+    attr_reader :root
+  end
+end