nfs-rb 1.0.0

data/lib/nfs/sunrpc/client.rb

@@ -0,0 +1,77 @@
+module NFS
+  module SUNRPC
+    module Client
+      @@xid = 0
+      @@xid_mutex = Mutex.new
+
+      def method_missing(name, *args)
+        procedure = @version.get_procedure(name)
+
+        if procedure.nil?
+          raise NoMethodError, name.to_s
+        end
+
+        if args.size == 0
+          args = [nil]
+        end
+
+        if args.size != 1
+          raise ArgumentError
+        end
+
+        xid = nil
+
+        @@xid_mutex.synchronize do
+          xid = @@xid
+          @@xid += 1
+        end
+
+        message = RpcMsg.encode({
+          xid: xid,
+          body: {
+            _discriminant: :CALL,
+            cbody: {
+              rpcvers: 2,
+              prog: @program.number,
+              vers: @version.number,
+              proc: procedure.number,
+              cred: {
+                flavor: :AUTH_NULL,
+                body: ''
+              },
+              verf: {
+                flavor: :AUTH_NULL,
+                body: ''
+              }
+            }
+          }
+        }) + procedure.encode(args[0])
+
+        # This will return the result object or raise an exception that
+        # contains the cause of the error.
+        sendrecv(message) do |result|
+          envelope = RpcMsg.decode(result)
+
+          if envelope[:xid] == xid
+            if envelope[:body][:_discriminant] != :REPLY
+              raise envelope.inspect
+            end
+
+            if envelope[:body][:rbody][:_discriminant] != :MSG_ACCEPTED
+              raise envelope[:body][:rbody].inspect
+            end
+
+            if envelope[:body][:rbody][:areply][:reply_data][:_discriminant] != :SUCCESS
+
+              raise envelope[:body][:rbody][:areply][:reply_data].inspect
+            end
+
+            procedure.decode(result)
+          else
+            false # false means keep giving us received messages to inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nfs/sunrpc/procedure.rb

@@ -0,0 +1,56 @@
+module NFS
+  module SUNRPC
+    class Procedure
+      attr_reader :number
+
+      def initialize(number, returntype, argtype, &block)
+        @number = number
+        @returntype, @argtype = returntype, argtype
+        @block = block
+      end
+
+      def dup
+        Procedure.new(@number, @returntype, @argtype, &@block)
+      end
+
+      def on_call(&block)
+        @block = block
+      end
+
+      def encode(arg)
+        @argtype.encode(arg)
+      end
+
+      def decode(value)
+        @returntype.decode(value)
+      end
+
+      def call(arg, cred, verf)
+        begin
+          arg_object = @argtype.decode(arg)
+        rescue
+          raise GarbageArguments
+        end
+
+        # Undefined procedures are also unavailable, even if the XDR says it's
+        # there. Define your procedures and this won't happen.
+        if @block.nil?
+          raise ProcedureUnavailable
+        end
+
+        result_object = @block.call(arg_object, cred, verf)
+        result = nil
+
+        begin
+          result = @returntype.encode(result_object)
+        rescue => e
+          NFS.logger.error(e.message)
+          NFS.logger.error(e.backtrace.join("\n"))
+          raise IgnoreRequest
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/nfs/sunrpc/program.rb

@@ -0,0 +1,58 @@
+module NFS
+  module SUNRPC
+    class Program
+      attr_reader :number, :low, :high
+
+      def initialize(number, &block)
+        @number = number
+        @versions = {}
+        @low = @high = nil
+        instance_eval(&block) if block_given?
+      end
+
+      def dup
+        self.class.new(@number).tap do |p|
+          @versions.each_pair do |number, version|
+            p.add_version(number, version.dup)
+          end
+        end
+      end
+
+      def add_version(number, ver)
+        if @low.nil? or number < @low
+          @low = number
+        end
+
+        if @high.nil? or number > @high
+          @high = number
+        end
+
+        @versions[number] = ver
+      end
+
+      def version(ver, &block)
+        add_version(ver, Version.new(ver, &block))
+      end
+
+      def get_version(ver)
+        @versions[ver]
+      end
+
+      def each_version(&block)
+        @versions.each_value(&block)
+      end
+
+      def on_call(ver, procedure_name, &block)
+        @versions[ver].on_call(procedure_name, &block)
+      end
+
+      def call(ver, procedure, arg, cred, verf)
+        if !@versions.include?(ver)
+          raise ProgramMismatch.new(2, 2)
+        end
+
+        @versions[ver].call(procedure, arg, cred, verf)
+      end
+    end
+  end
+end

data/lib/nfs/sunrpc/server.rb

@@ -0,0 +1,119 @@
+module NFS
+  module SUNRPC
+    class Server
+      def host
+        @server.addr[2]
+      end
+
+      def port
+        @server.addr[1]
+      end
+
+      def join
+        if !@thread.nil?
+          @thread.join
+        end
+      end
+
+      def start
+        if @thread.nil?
+          @thread.start
+        end
+      end
+
+      def shutdown
+        Thread.kill(@thread)
+        @thread = nil
+        @server.shutdown
+      rescue Errno::ENOTCONN
+      end
+
+      private
+
+      def run_procedure(data)
+        begin
+          xid, program_num, version_num, procedure_num, cred,
+            verf = decode_envelope(data)
+
+          program = @programs[program_num]
+
+          if program.nil?
+            raise ProgramUnavailable
+          else
+            result = program.call(
+              version_num, procedure_num, data, cred, verf
+            )
+
+            create_success_envelope(xid, result)
+          end
+        rescue IgnoreRequest, RequestDenied, AcceptedError => e
+          return e.encode(xid)
+        end
+      end
+
+      def decode_envelope(data)
+        envelope = nil
+
+        begin
+          envelope = RpcMsg.decode(data)
+        rescue
+          raise IgnoreRequest
+        end
+
+        if envelope[:body][:_discriminant] != :CALL
+          raise IgnoreRequest
+        end
+
+        if envelope[:body][:cbody][:rpcvers] != 2
+          raise RpcMismatch.new(2, 2, envelope[:xid])
+        end
+
+        cbody = envelope[:body][:cbody]
+
+        [
+          envelope[:xid],
+          cbody[:prog],
+          cbody[:vers],
+          cbody[:proc],
+          cbody[:cred],
+          cbody[:verf]
+        ]
+      end
+
+      def create_success_envelope(xid, result)
+        RpcMsg.encode({
+          xid: xid,
+          body: {
+            _discriminant: :REPLY,
+            rbody: {
+              _discriminant: :MSG_ACCEPTED,
+              areply: {
+                verf: {
+                  flavor: :AUTH_NULL,
+                  body: ''
+                },
+                reply_data: {
+                  _discriminant: :SUCCESS,
+                  results: ''
+                }
+              }
+            }
+          }
+        }) + result
+      end
+
+      def hash_programs(programs)
+        case programs
+          when Hash
+            programs
+          when Array
+            programs.each_with_object({}) do |program, result|
+              result[program.number] = program
+            end
+          else
+            { programs.number => programs }
+        end
+      end
+    end
+  end
+end

data/lib/nfs/sunrpc/tcp_server.rb

@@ -0,0 +1,41 @@
+require 'socket'
+require 'thread'
+
+module NFS
+  module SUNRPC
+    class TCPServer < Server
+      def initialize(programs, port = nil, host = '127.0.0.1')
+        @server = ::TCPServer.new(host, port)
+        @programs = hash_programs(programs)
+
+        @thread = Thread.new do
+          loop do
+            Thread.new(@server.accept) do |socket|
+              loop do
+                frame = socket.recv(4).unpack1('N')
+                len = frame & ~0x80000000
+                break unless len
+
+                data = socket.recv(len)
+                result = run_procedure(data)
+
+                if !result.nil?
+                  result = [result.length | (128 << 24)].pack('N') + result
+                  socket.send(result, 0)
+                end
+              end
+            end
+          end
+        end
+
+        if block_given?
+          begin
+            yield(self)
+          ensure
+            shutdown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nfs/sunrpc/udp_server.rb

@@ -0,0 +1,42 @@
+require 'socket'
+require 'thread'
+
+module NFS
+  module SUNRPC
+    class UDPServer < Server
+      def initialize(programs, port = nil, host = '127.0.0.1')
+        @socket = UDPSocket.open
+        @socket.bind(host, port)
+        socketmutex = Mutex.new
+        @programs = hash_programs(programs)
+
+        @thread = Thread.new do
+          loop do
+            request = @socket.recvfrom(UDPClient::UDPRecvMTU)
+            data = request[0]
+            port = request[1][1]
+            host = request[1][3]
+
+            Thread.new do
+              result = run_procedure(data)
+
+              if !result.nil?
+                socketmutex.synchronize do
+                  @socket.send(result, 0, host, port)
+                end
+              end
+            end
+          end
+        end
+
+        if block_given?
+          begin
+            yield(self)
+          ensure
+            shutdown
+          end
+        end
+      end
+    end
+  end
+end

data/lib/nfs/sunrpc/version.rb

@@ -0,0 +1,55 @@
+module NFS
+  module SUNRPC
+    class Version
+      attr_reader :number
+
+      def initialize(number, &block)
+        @number = number
+        @procedures = {}
+        @procedure_names = {}
+
+        # Add the customary null procedure by default.
+        procedure XDR::Void.new, :NULL, 0, XDR::Void.new do
+          # do nothing
+        end
+
+        instance_eval(&block) if block_given?
+      end
+
+      def dup
+        Version.new(@number).tap do |v|
+          @procedure_names.each_pair do |name, procedure|
+            v.add_procedure(name, procedure.number, procedure.dup)
+          end
+        end
+      end
+
+      def add_procedure(name, number, newproc)
+        @procedures[number] = newproc
+        @procedure_names[name] = newproc
+      end
+
+      # The name is required, but just for documentation.
+      def procedure(returntype, name, number, argtype, &block)
+        newproc = Procedure.new(number, returntype, argtype, &block)
+        add_procedure(name, number, newproc)
+      end
+
+      def get_procedure(procedure_name)
+        @procedure_names[procedure_name]
+      end
+
+      def on_call(procedure_name, &block)
+        @procedure_names[procedure_name].on_call(&block)
+      end
+
+      def call(p, arg, cred, verf)
+        unless @procedures.include?(p)
+          raise ProcedureUnavailable
+        end
+
+        @procedures[p].call(arg, cred, verf)
+      end
+    end
+  end
+end