simplerpc 0.1.1 → 0.2.0b

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35e03bbef72aa8b10a3ce67964e8ad2ae5a0a59d
-  data.tar.gz: b961f842f95b6b1e9b784bbb287c9a493b9ccb0c
+  metadata.gz: 297f5863f75ffee26a9d5a4d2be51bdf376f282e
+  data.tar.gz: 078eeb27ec40ff2202bb806a9a2a9469910b7284
 SHA512:
-  metadata.gz: c681277ce02e0857e4feb5e7ac937bb13fa28d6f7451914eecfcf46968631c35d2c491210aa89a4cb97bc0fefe3f15ed40ad0e8a492cd57f28a635505c329ed7
-  data.tar.gz: de1c8efba094eea904384d94478f8d891387631cf8bd93684174ef389fa7e7f6c2155fab8bb4c4f5a72ad67c198606ce76a311d494844a6de411da607e23b96c
+  metadata.gz: 437d37efe70e1f4f4d506c44e5ca388f71c7c71eb12590b12081ec8822ba5a325940fa527465d7eb7439be14adb174331068399134f683cfcd320ad58e5ca6df
+  data.tar.gz: 600fb27195f8788c62702167a50b3c82d3c0d95ec6523e8fd31247eaff889dc3188d7b4d2162de2bd92ef027ee5179b24de93bf8ccdd9105ef3691cd9fe6c17b

data/lib/simplerpc/client.rb

@@ -1,44 +1,133 @@
 require 'socket'      # Sockets are in standard library
-require 'simplerpc/serialiser'
 require 'simplerpc/socket_protocol'
 
 module SimpleRPC 
 
+  # Exception thrown when the client fails to connect. 
+  class AuthenticationError < StandardError
+  end
+
   # The SimpleRPC client connects to a server, either persistently on on-demand, and makes
   # calls to its proxy object.
   #
   # Once created, you should be able to interact with the client as if it were the remote
-  # object.
+  # object, i.e.:
+  #
+  #   c = SimpleRPC::Client.new {:hostname => '127.0.0.1', :port => 27045 }
+  #   c.length # 2
+  #   c.call(:dup) # ["thing", "thing2"]
+  #   c.close
+  # 
+  # == Making Requests
+  # 
+  # Requests can be made on the client object as if it were local, and these will be
+  # proxied to the server.  For methods that are clobbered locally (for example '.class',
+  # which will return 'SimpleRPC::Client', you may use #call to send this without local
+  # interaction:
+  #
+  #  c.class         # SimpleRPC::Client
+  #  c.call(:class)  # Array
+  #
+  # The client will throw network errors upon failure, (ERRno::... ), so be sure to catch
+  # these in your application.
+  #
+  # == Modes
+  #
+  # It is possible to use the client in two modes: _always-on_ and _connect-on-demand_.  
+  # The former of these maintains a single socket to the server, and all requests are
+  # sent over this.  Call #connect and #disconnect to control this connection.
+  #
+  # The latter establishes a connection when necessary.  This mode is used whenever the
+  # client is not connected, so is a fallback if always-on fails.  There is a small 
+  # performance hit to reconnecting each time.
+  #
+  # == Serialisation Formats
+  #
+  # By default both client and server use Marshal.  This has proven fast and general,
+  # and is capable of sending data directly over sockets.
+  #
+  # The serialiser also supports MessagePack (the msgpack gem), and this yields a small
+  # performance increase at the expense of generality (restrictions on data type).
+  #
+  # Note that JSON and YAML, though they support reading and writing to sockets, do not 
+  # properly terminate their reads and cause the system to hang.  These methods are
+  # both slow and limited by comparison anyway, and algorithms needed to support their
+  # use require relatively large memory usage.  They may be supported in later versions.
+  #
+  # == Authentication
+  #
+  # Setting the :password and :secret options will cause the client to attempt auth
+  # on connection.  If this process succeeds, the client will then proceed as before,
+  # else the server will forcibly close the socket.  If :fast_auth is on this will cause
+  # some kind of random data loading exception from the serialiser.  If :fast_auth is off (default),
+  # this will throw a SimpleRPC::AuthenticationError exception.
+  #
+  # Clients and servers do not tell one another to use auth (such a system would impact
+  # speed) so the results of using mismatched configurations are undefined.
+  #
+  # The auth process is simple and not particularly secure, but is designed to deter casual
+  # connections and attacks.  It uses a password that is sent encrypted against a salt sent 
+  # by the server to prevent replay attacks.  If you want more reliable security, use an SSH tunnel.
+  #
+  # The performance impact of auth is small, and takes about the same time as a simple
+  # request.  This can be mitigated by using always-on mode.
   #
   class Client
 
-    # Create a new client for the network
-    # 
-    # hostname:: The hostname of the server
-    # port:: The port to connect to
-    # serialiser:: An object supporting load/dump for serialising objects.  Defaults to
-    #              SimpleRPC::Serialiser
-    # timeout:: The socket timeout.  Throws Timeout::TimeoutErrors when exceeded.  Set
-    #           to nil to disable.
-    def initialize(hostname, port, serialiser=Serialiser.new, timeout=nil)
-      @hostname     = hostname
-      @port         = port
-      @serialiser   = serialiser
-      @timeout      = timeout
+    attr_reader :hostname, :port
+    attr_accessor :serialiser, :timeout, :fast_auth
+    attr_writer :password, :secret
+
+    # Create a new client for the network.
+    # Takes an options hash, in which :port is required:
+    #
+    # [:hostname]    The hostname to connect to.  Defaults to localhost
+    # [:port]        The port to connect on.  Required.
+    # [:serialiser]  A class supporting #dump(object, io) and #load(IO), defaults to Marshal.
+    #                I recommend using MessagePack if this is not fast enough
+    # [:timeout]     Socket timeout in seconds.
+    # [:password] The password clients need to connect
+    # [:secret] The encryption key used during password authentication.  
+    #           Should be some long random string that matches the server's.
+    # [:fast_auth] Use a slightly faster auth system that is incapable of knowing if it has failed or not.
+    #              By default this is off.
+    #
+    def initialize(opts = {})
+
+      # Connection details
+      @hostname     = opts[:hostname]   || '127.0.0.1'
+      @port         = opts[:port]
+      raise "Port required" if not @port
+      @timeout      = opts[:timeout]
+
+      # Serialiser.
+      @serialiser   = opts[:serialiser] || Marshal 
+
+      # Auth system
+      if opts[:password] and opts[:secret] then
+        require 'simplerpc/encryption'
+        @password   = opts[:password]
+        @secret     = opts[:secret]
+      
+        # Check for return from auth?
+        @fast_auth  = (opts[:fast_auth] == true)
+      end
 
       @m = Mutex.new
     end
 
-    # Connect to the server,
-    # or do nothing if already connected
+    # Connect to the server.  
+    #
+    # Returns true if connected, or false if not.
+    #
+    # Note that this is only needed if using the client in always-on mode.
     def connect
       @m.synchronize{
         _connect
       }
     end
 
-    # Disconnect from the server
-    # or do nothing if already disconnected
+    # Disconnect from the server.
     def close
       @m.synchronize{
         _disconnect
@@ -51,74 +140,118 @@ module SimpleRPC
     # Is the client currently connected?
     def connected?
       @m.synchronize{
-        not @s == nil
+        _connected?
       }
     end
 
     # Call a method that is otherwise clobbered
-    # by the client object
+    # by the client object, e.g.:
+    #
+    #   client.call(:dup) # return a copy of the server object
+    #
     def call(m, *args)
       method_missing(m, *args)
     end
 
-    # Calls RPC on the remote object
+    # Calls RPC on the remote object.
+    #
+    # You should not need to call this directly.
+    #
     def method_missing(m, *args, &block)
-      valid_call  = false
+
       result      = nil
+      success     = true
 
       @m.synchronize{
-        already_connected = (not (@s == nil))
-        _connect if not already_connected
+        already_connected = _connected?
+        if not already_connected
+          raise Errno::ECONNREFUSED, "Failed to connect" if not _connect
+        end
         # send method name and arity
-        # #puts "c: METHOD: #{m}. ARITY: #{args.length}"
-        _send([m, args.length])
-
-        # receive yey/ney
-        valid_call = _recv
-
-        #puts "=--> #{valid_call}"
+        _send([m, args, already_connected])
 
         # call with args
-        if valid_call then
-          _send( args )
-          result = _recv
-        end
+        success, result = _recv
         
         # Then d/c
         _disconnect if not already_connected
       }
      
-      # If the call wasn't valid, call super
-      if not valid_call then
-        result = super
-      end
-
+      # puts "[c] /calling #{m}..."
+      # If it didn't succeed, treat the payload as an exception
+      raise result if not success 
       return result
+
+    # rescue StandardError => e
+    #   $stderr.puts "-> #{e}, #{e.backtrace.join("--")}"
+    #   case e
+    #   when Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ETIMEDOUT
+    #     c.close
+    #   else
+    #     raise e
+    #   end
     end
 
   private
-    # Connect to the server
-    def _connect
-      @s = TCPSocket.open( @hostname, @port )
-      raise "Failed to connect" if not @s
-    end
+
+
+    # -------------------------------------------------------------------------
+    # Send/Receive
+    #
 
     # Receive data from the server
     def _recv
-      @serialiser.load( SocketProtocol::recv(@s, @timeout) )
+      SocketProtocol::Stream.recv( @s, @serialiser, @timeout )
     end
 
     # Send data to the server
     def _send(obj)
-      SocketProtocol::send(@s, @serialiser.dump(obj), @timeout)
+      SocketProtocol::Stream.send( @s, obj, @serialiser, @timeout )
+    end
+
+    # -------------------------------------------------------------------------
+    # Socket management
+    #
+
+    # Connect to the server
+    def _connect
+      # Connect to the host
+      @s = Socket.tcp( @hostname, @port, nil, nil, :connect_timeout => @timeout )
+      
+      # Disable Nagle's algorithm
+      @s.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+  
+      # if auth is required
+      if @password and @secret
+        salt      = SocketProtocol::Simple.recv( @s, @timeout )
+        challenge = Encryption.encrypt( @password, @secret, salt ) 
+        SocketProtocol::Simple.send( @s, challenge, @timeout )
+        if not @fast_auth
+          if SocketProtocol::Simple.recv( @s, @timeout ) != SocketProtocol::AUTH_SUCCESS
+            @s.close
+            raise AuthenticationError, "Authentication failed" 
+          end
+        end
+      end
+
+      # Check and raise
+      return _connected?
     end
 
     # Disconnect from the server
     def _disconnect
-      return if not @s
-      @s.close
+      return if not _connected?
+
+      # Then underlying socket
+      @s.close if @s and not @s.closed?
       @s = nil
     end
+
+    # Non-mutexed check for connectedness
+    def _connected?
+      @s and not @s.closed?
+    end
+
   end
 
 end

data/lib/simplerpc/encryption.rb

@@ -0,0 +1,46 @@
+
+require 'openssl'
+
+module SimpleRPC
+
+  # Handles openssl-based encryption of authentication details
+  #
+  # The auth system used is not terribly secure, but will guard against
+  # casual attackers.  If you are particularly concerned, turn it off and
+  # use SSH tunnels.
+  #
+  module Encryption
+
+    # How strong to make the AES encryption
+    CIPHER_STRENGTH = 256
+
+    # Encrypt data
+    def self.encrypt( password, secret, salt )
+        # Encrypt with salted key
+        cipher         = OpenSSL::Cipher::AES.new( CIPHER_STRENGTH, :CBC )
+        cipher.encrypt
+        cipher.key     = salt_key( salt, secret )
+        return cipher.update(password) + cipher.final
+    rescue StandardError => e
+      return nil  # Don't allow anyone to deliberately cause lockups
+    end
+
+    # Decrypt data
+    def self.decrypt( raw, secret, salt )
+        # Decrypt raw input
+        decipher      = OpenSSL::Cipher::AES.new( CIPHER_STRENGTH, :CBC )
+        decipher.decrypt
+        decipher.key  = salt_key( salt, secret )
+        return decipher.update(raw) + decipher.final
+    rescue StandardError => e
+      return nil  # Don't allow anyone to deliberately cause lockups
+    end
+
+    # Salt a key by simply adding the two
+    # together
+    def self.salt_key( salt, key )
+      return salt + key
+    end
+
+  end
+end

data/lib/simplerpc/server.rb

@@ -1,85 +1,175 @@
 
 
 require 'socket'               # Get sockets from stdlib
-require 'simplerpc/serialiser'
 require 'simplerpc/socket_protocol'
 
 module SimpleRPC 
 
+
   # SimpleRPC's server.  This wraps an object and exposes its methods to the network.
+  #
+  # i.e.:
+  #
+  #   s = SimpleRPC::Server.new( ["thing", "thing2"], :port => 27045 )
+  #   Thread.new(){ s.listen }
+  #   sleep(10)
+  #   s.close     # Thread-safe
+  #
+  # == Controlling a Server
+  #
+  # The server is thread-safe, and is designed to be run in a thread when blocking on
+  # #listen --- calling #close on a listening server will cause the following chain of
+  # events:
+  #
+  # 1. The current client requests will end
+  # 2. The socket will close
+  # 3. #listen and #close will return (almost) simultaneously 
+  #
+  # == Serialisation Formats
+  #
+  # By default both client and server use Marshal.  This has proven fast and general,
+  # and is capable of sending data directly over sockets.
+  #
+  # The serialiser also supports MessagePack (the msgpack gem), and this yields a small
+  # performance increase at the expense of generality (restrictions on data type).
+  #
+  # Note that JSON and YAML, though they support reading and writing to sockets, do not 
+  # properly terminate their reads and cause the system to hang.  These methods are
+  # both slow and limited by comparison anyway, and algorithms needed to support their
+  # use require relatively large memory usage.  They may be supported in later versions.
+  #
+  # == Authentication
+  #
+  # Setting the :password and :secret options will require authentication to connect.
+  #
+  # Clients and servers do not tell one another to use auth (such a system would impact
+  # speed) so the results of using mismatched configurations are undefined.
+  #
+  # The auth process is simple and not particularly secure, but is designed to deter casual
+  # connections and attacks.  It uses a password that is sent encrypted against a salt sent 
+  # by the server to prevent replay attacks.  If you want more reliable security, use an SSH tunnel.
+  #
+  # The performance impact of auth is small, and takes about the same time as a simple
+  # request.  This can be mitigated by using always-on mode.
+  #
   class Server
 
-    # Create a new server for a given proxy object
+    attr_reader :hostname, :port, :obj, :threaded
+    attr_accessor :verbose_errors, :serialiser, :timeout, :fast_auth
+    attr_writer :password, :secret
+    
+    # Create a new server for a given proxy object.
+    #
+    # The single required parameter, obj, is an object you wish to expose to the 
+    # network.  This is the API that will respond to RPCs.
+    #
+    # Takes an option hash with options:
+    #
+    # [:port] The port on which to listen, or 0 for the OS to set it
+    # [:hostname] The hostname of the interface to listen on (omit for all interfaces)
+    # [:serialiser] A class supporting #load(IO) and #dump(obj, IO) for serialisation.  
+    #               Defaults to Marshal.  I recommend using MessagePack if this is not
+    #               fast enough.  Note that JSON/YAML do not work as they don't send
+    #               terminating characters over the socket.
+    # [:verbose_errors] Report all socket errors from clients (by default these will be quashed).
+    # [:timeout] Socket timeout in seconds.  Default is infinite (nil)
+    # [:threaded] Accept more than one client at once?  Note that proxy object should be thread-safe for this
+    #             Default is single-threaded mode.
+    # [:password] The password clients need to connect
+    # [:secret] The encryption key used during password authentication.  Should be some long random string.
+    # [:salt_size] The size of the string used as a nonce during password auth.  Defaults to 10 chars
+    # [:fast_auth] Use a slightly faster auth system that is incapable of knowing if it has failed or not.
+    #              By default this is off.
     #
-    # obj:: The object to proxy the API for---any ruby object
-    # port:: The port to listen on
-    # hostname:: The ip of the interface to listen on, or nil for all
-    # serialiser:: The serialiser to use
-    # threaded:: Should the server support multiple clients at once?
-    # timeout:: Socket timeout
-    def initialize(obj, port, hostname=nil, serialiser=Serialiser.new, threaded=false, timeout=nil)
-      @obj      = obj 
-      @port     = port
-      @hostname = hostname
+    def initialize(obj, opts = {})
+      @obj                  = obj
+      @port                 = opts[:port].to_i
+      @hostname             = opts[:hostname]
 
       # What format to use.
-      @serialiser = serialiser
+      @serialiser           = opts[:serialiser] || Marshal
 
-      # Silence errors?
-      @silence_errors = true
+      # Silence errors coming from client connections?
+      @verbose_errors       = (opts[:verbose_errors] == true)
+      @fast_auth            = (opts[:fast_auth] == true)
 
       # Should we shut down?
-      @close  = false
+      @close                = false
+      @close_in, @close_out = UNIXSocket.pair
 
       # Connect/receive timeouts
-      @timeout = timeout
+      @timeout              = opts[:timeout]
+
+      # Auth
+      if opts[:password] and opts[:secret] then
+        require 'simplerpc/encryption'
+        @password   = opts[:password]
+        @secret     = opts[:secret]
+        @salt_size  = opts[:salt_size] || 10 # size of salt on key.
+      end
 
       # Threaded or not?
-      @threaded = (threaded == true)
-      @clients = {} if @threaded
-      @m = Mutex.new if @threaded
+      @threaded             = (opts[:threaded] == true)
+      if(@threaded)
+        @clients            = {}
+        @m                  = Mutex.new
+      end
     end
 
-    # Start listening forever
+    # Start listening forever.
+    #
+    # Use threads and .close to stop the server.
+    #
     def listen
       # Listen on one interface only if hostname given
-      if @hostname
-        @s = TCPServer.open( @hostname, @port )
-      else
-        @s = TCPServer.open(@port)
-      end
+      create_server_socket if not @s or @s.closed?
 
       # Handle clients
       loop{
 
         begin
-          if @threaded
-  
-            # Create the thread
-            id = rand.hash
-            thread = Thread.new(id, @m, @s.accept){|id, m, c|  
-              handle_client(c)
+          # Accept in an interruptable manner
+          if( c = interruptable_accept )
+            if @threaded
+    
+              # Create the thread
+              id = rand.hash
+              thread = Thread.new(id, @m, c){|id, m, c|  
+                handle_client(c)
+
+                m.synchronize{
+                  @clients.delete(id)
+                }
+              }
 
-              # puts "#{id} closing 1"
-              m.synchronize{
-                @clients.delete(id)
+              # Add to the client list
+              @m.synchronize{
+                @clients[id] = thread
               }
-              # puts "#{id} closing 2"
-            }
-
-            # Add to the client list
-            @m.synchronize{
-              @clients[id] = thread
-            }
-          else
-            handle_client(@s.accept)
+            else
+              # Handle client 
+              handle_client(c)
+            end
           end
         rescue StandardError => e
-          raise e if not @silence_errors
+          raise e if @verbose_errors
         end
 
         break if @close
       }
+
+      # Wait for threads to end
+      if @threaded then
+        @clients.each{|id, thread|
+          thread.join
+        }
+      end
+
+      # Close socket
+      close_server_sockets
+
+      # Finally, say we've closed
+      @close = false if @close
     end
 
     # Return the number of active clients.
@@ -94,43 +184,146 @@ module SimpleRPC
     def close
       # Ask the loop to close
       @close = true
+      @close_in.putc 'x' # Tell select to close
 
-      # Wait on threads
-      if @threaded then
-        @clients.each{|id, thread|
-          thread.join
-        }
+      # Wait for loop to end 
+      while(@close)
+        sleep(0.1)
       end
     end
 
   private
+
+    # -------------------------------------------------------------------------
+    # Client Management
+    #
+  
+    # Accept with the ability for other 
+    # threads to call close
+    def interruptable_accept
+      c = IO.select([@s, @close_out], nil, nil)
+   
+      # puts "--> #{c}"
+
+      return nil if not c
+      if(c[0][0] == @close_out)  
+        # @close is set, so consume from socket
+        # and return nil
+        @close_out.getc
+        return nil 
+      end
+      return @s.accept if( not @close and c )
+    rescue IOError => e
+      # cover 'closed stream' errors
+      return nil
+    end
+
     # Handle the protocol for client c
     def handle_client(c)
-      m, arity = recv(c)
+      # Disable Nagle's algorithm
+      c.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
-      # Check the call is valid for the proxy object
-      valid_call = (@obj.respond_to?(m) and @obj.method(m).arity == arity)
+      # Encrypted password auth
+      if @password and @secret
+        # Send challenge
+        # XXX: this is notably not crytographically random,
+        #      but it's better than nothing against replay attacks
+        salt = Random.new.bytes( @salt_size )
+        SocketProtocol::Simple.send( c, salt, @timeout )
 
-      send(c, valid_call)
+        # Receive encrypted challenge
+        raw = SocketProtocol::Simple.recv( c, @timeout )
 
-      # Make the call if valid and send the result back
-      if valid_call then
-        args = recv(c)
-        send(c, @obj.send(m, *args) )
+        # D/c if failed
+        if Encryption.decrypt( raw, @secret, salt) != @password
+          SocketProtocol::Simple.send( c, SocketProtocol::AUTH_FAIL, @timeout )   if not @fast_auth
+          c.close
+          return
+        end
+        SocketProtocol::Simple.send( c, SocketProtocol::AUTH_SUCCESS, @timeout )     if not @fast_auth
       end
 
+      # Handle requests
+      persist = true
+      while(not @close and persist) do
+
+        m, args, persist = recv(c)
+        # puts "Method: #{m}, args: #{args}, persist: #{persist}"
+
+        if(m and args) then
+
+          # Record success status
+          result    = nil
+          success   = true
+
+          # Try to make the call, catching exceptions
+          begin
+            result  = @obj.send(m, *args)
+          rescue StandardError => se
+            result  = se
+            success = false
+          end
+
+          # Send over the result
+          # puts "[s] sending result..."
+          send(c, [success, result] )
+        else
+          persist = false
+        end
+
+      end
+        
+      # Close
       c.close
+    rescue StandardError => e
+      case e
+      when Errno::EPIPE, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::ETIMEDOUT
+        c.close
+      else
+        raise e 
+      end
     end
 
+    # -------------------------------------------------------------------------
+    # Send/Receive
+    # 
+
     # Receive data from a client
     def recv(c)
-      @serialiser.load( SocketProtocol::recv(c, @timeout) )
+      SocketProtocol::Stream.recv( c, @serialiser, @timeout )
     end
 
     # Send data to a client
     def send(c, obj)
-      SocketProtocol::send(c, @serialiser.dump(obj), @timeout)
+      SocketProtocol::Stream.send( c, obj, @serialiser, @timeout )
     end
+
+    # -------------------------------------------------------------------------
+    # Socket Management
+    #
+
+    # Creates a new socket with the given timeout
+    def create_server_socket
+      if @hostname 
+        @s = TCPServer.open( @hostname, @port )
+      else
+        @s = TCPServer.open( @port )
+      end
+      @port = @s.addr[1]
+
+      @s.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR, true)
+    end
+
+    # Close the server socket
+    def close_server_sockets
+      return if not @s 
+
+      # Close underlying socket
+      @s.close    if @s and not @s.closed?
+      @s = nil
+    end
+
+
   end
 
 

data/lib/simplerpc/socket_protocol.rb

@@ -1,42 +1,95 @@
-# Low-level protocol specification for SimpleRPC.
-#
-# This defines how data is sent at the socket level, primarily controlling what happens with partial sends/timeouts.
-module SimpleRPC::SocketProtocol
-  
-    # Send already-serialised payload to socket s
-    def self.send(s, payload, timeout=nil)
-      # Send length
-      raise Timeout::TimeoutError if not IO.select(nil, [s], nil, timeout)
-      s.puts(payload.length.to_s)
-
-      # Send rest incrementally
-      #puts "[s] send(#{payload})"
-      len = payload.length
-      while( len > 0 and x = IO.select(nil, [s], nil, timeout) )
-        len -= s.write( payload )
+
+
+module SimpleRPC
+
+
+  # SocketProtocol defines common low-level aspects of data transfer
+  # between client and server.
+  #
+  # In normal use you can safely ignore this class and simply use Client
+  # and Server.
+  #
+  module SocketProtocol
+
+    # Sent when auth succeeds
+    AUTH_SUCCESS = 'C'
+
+    # Sent when auth fails
+    AUTH_FAIL    = 'F'
+
+    # Send objects by streaming them through a socket using
+    # a serialiser such as Marshal.
+    #
+    # Fast and with low memory requirements, but is inherently
+    # unsafe (arbitrary code execution) and doesn't work with
+    # some serialisers.
+    #
+    # SimpleRPC uses this library for calls, and uses SocketProtocol::Simple
+    # for auth challenges (since it is safer)
+    #
+    module Stream
+
+      # Send using a serialiser writing through the socket
+      def self.send( s, obj, serialiser, timeout=nil )
+        raise Errno::ETIMEDOUT if not IO.select([], [s], [], timeout)
+        return serialiser.dump( obj, s )
       end
-      raise Timeout::TimeoutError if not x
-      #puts "[s] sent(#{payload})"
+
+      # Recieve using a serialiser reading from the socket
+      def self.recv( s, serialiser, timeout=nil )
+        raise Errno::ETIMEDOUT if not IO.select([s], [], [], timeout)
+        return serialiser.load( s )
+      end
+
     end
 
-    # Receive raw data from socket s.
-    def self.recv(s, timeout=nil)
-      # Read the length of the data
-      raise Timeout::TimeoutError if not IO.select([s], nil, nil, timeout)
-      len = s.gets.chomp.to_i
-
-      # Then read the rest incrementally
-      buf = ""
-      while( len > 0 and x = IO.select([s], nil, nil, timeout) )
-        #puts "[s (#{len})]"
-        x = s.read(len)
-        len -= x.length
-        buf += x
+
+    # Sends string buffers back and forth using a simple protocol.
+    # 
+    # This method is significantly slower, but significantly more secure,
+    # than SocketProtocol::Stream, and is used for the auth handshake.
+    #
+    module Simple
+
+      # Send a buffer
+      def self.send( s, buf, timeout=nil )
+          # Dump into buffer
+          buflen = buf.length
+
+          # Send buffer length
+          raise Errno::ETIMEDOUT if not IO.select([], [s], [], timeout)
+          s.puts(buflen)
+
+          # Send buffer
+          sent = 0
+          while(sent < buflen and (x = IO.select([], [s], [], timeout))) do
+            sent += s.write( buf[sent..-1] )
+          end
+          raise Errno::ETIMEDOUT if not x
+
+      end
+
+      # Receive a buffer
+      def self.recv( s, timeout=nil )
+          raise Errno::ETIMEDOUT if not IO.select([s], [], [], timeout)
+          buflen = s.gets.to_s.chomp.to_i
+
+          return nil if buflen <= 0
+
+          buf = ""
+          recieved = 0
+          while( recieved < buflen and (x = IO.select([s], [], [], timeout)) ) do
+            str = s.read( buflen - recieved )
+            buf += str
+            recieved += str.length
+          end
+          raise Errno::ETIMEDOUT if not x
+
+          return buf
       end
-      raise Timeout::TimeoutError if not x
 
-      return buf
-      #puts "[s] recv(#{buf})"
     end
 
+  end
+
 end

data/lib/simplerpc.rb

@@ -0,0 +1,21 @@
+
+require 'simplerpc/server'
+require 'simplerpc/client'
+require 'simplerpc/serialiser'
+
+# SimpleRPC is a very simple RPC library for ruby, designed to be as fast as possible whilst still
+# retaining a simple API.
+#
+# It connects a client to a server which wraps an object, exposing its API over the network socket.
+# All data to/from the server is serialised using a serialisation object that is passed to the 
+# client/server.
+#
+# Author:: Stephen Wattam
+#
+# This module simply contains version information,
+# and including it includes all other project files
+module SimpleRPC
+
+  VERSION = "0.2.0b"
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplerpc
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0b
 platform: ruby
 authors:
 - Stephen Wattam
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-26 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies: []
 description: A very simple and fast RPC library
 email: stephenwattam@gmail.com
@@ -17,15 +17,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/simplerpc/client.rb
-- lib/simplerpc/socket_protocol.rb
-- lib/simplerpc/serialiser.rb
 - lib/simplerpc/server.rb
+- lib/simplerpc/encryption.rb
+- lib/simplerpc/socket_protocol.rb
+- ./lib/simplerpc.rb
 - LICENSE
 homepage: http://stephenwattam.com/projects/simplerpc
 licenses:
-- Beer
+- Beerware
 metadata: {}
-post_install_message: Have fun Cing RPs :-)
+post_install_message: Thanks for installing SimpleRPC!
 rdoc_options: []
 require_paths:
 - lib
@@ -36,9 +37,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.0

data/lib/simplerpc/serialiser.rb

@@ -1,67 +0,0 @@
-
-module SimpleRPC 
-
-  # This class wraps three possible serialisation systems, providing a common interface to them all.
-  #
-  # It's not a necessary part of SimpleRPC---you may use any object that supports load/dump---but it is
-  # rather handy.
-  class Serialiser
-
-    SUPPORTED_METHODS = %w{marshal json msgpack yaml}.map{|s| s.to_sym}
-
-    # Create a new Serialiser with the given method.  Optionally provide a binding to have
-    # the serialisation method execute within another context, i.e. for it to pick up
-    # on various libraries and classes (though this will impact performance somewhat).
-    #
-    # Supported methods are:
-    #
-    # :marshal:: Use ruby's Marshal system.  A good mix of speed and generality.
-    # :yaml:: Use YAML.  Very slow but very general
-    # :msgpack:: Use MessagePack gem.  Very fast but not very general (limited data format support)
-    # :json::  Use JSON.  Also slow, but better for interoperability than YAML.
-    #
-    def initialize(method = :marshal, binding=nil)
-      @method   = method
-      @binding  = nil
-      raise "Unrecognised serialisation method" if not SUPPORTED_METHODS.include?(method)
-
-      # Require prerequisites and handle msgpack not installed-iness.
-      case method
-        when :msgpack
-          begin 
-            gem "msgpack", "~> 0.5"
-          rescue Gem::LoadError => e
-            $stderr.puts "The :msgpack serialisation method requires the MessagePack gem (msgpack)."
-            $stderr.puts "Please install it or use another serialisation method."
-            raise e
-          end
-          require 'msgpack'
-          @cls = MessagePack
-        when :yaml
-          require 'yaml'
-          @cls = YAML
-        when :json
-          require 'json'
-          @cls = JSON
-        else
-          # marshal is alaways available
-          @cls = Marshal
-      end
-    end
-
-    # Serialise to a string
-    def dump(obj)
-      return eval("#{@cls.to_s}.dump(obj)", @binding) if @binding
-      return @cls.send(:dump, obj)
-    end
-
-    # Deserialise from a string
-    def load(bits)
-      return eval("#{@cls.to_s}.load(bits)", @binding) if @binding
-      return @cls.send(:load, bits)
-    end
-
-  end
-
-end
-