pione 0.1.0

data/lib/pione/patch/uri-patch.rb

@@ -0,0 +1,66 @@
+# URI extention for PIONE system.
+# @api private
+module URI
+  # Installs a new scheme.
+  def self.install_scheme(name, klass)
+    @@schemes[name] = klass
+  end
+
+  class Generic
+    # Returns true if the scheme is supportted by PIONE system.
+    # @return [Boolean]
+    #   true if the scheme is supportted by PIONE system
+    def pione?
+      false
+    end
+
+    # Returns true if the path represents a directory.
+    # @return [Boolean]
+    #   true if the path represents a directory
+    def directory?
+      path[-1] == '/'
+    end
+
+    # Returns true if the path represents a file.
+    # @return [Boolean]
+    #   true if the path represents a file
+    def file?
+      not(directory?)
+    end
+
+    # Converts the uri into directory form.
+    # @return [Generic]
+    #   directory path form
+    def as_directory
+      if directory?
+        self
+      else
+        self.clone.tap{|s| s.path = s.path + "/"}
+      end
+    end
+  end
+
+  class Parser
+    alias :orig_split :split
+
+    # Handles to split special schemes's URI.
+    def split(uri)
+      scheme = uri.split(":").first
+
+      # special schemes
+      case scheme
+      when "local"
+        path = uri[6..-1]
+        return [scheme, nil, nil, nil, nil, path, nil, nil, nil]
+      when "broadcast"
+        rest = uri[10..-1]
+        if rest == "//"
+          return [scheme, nil, nil, nil, nil, nil, nil, nil, nil]
+        end
+      end
+
+      # other case
+      return orig_split(uri)
+    end
+  end
+end

data/lib/pione/relay/receiver-socket.rb

@@ -0,0 +1,69 @@
+module Pione
+  module Relay
+    class ReceiverSocket < DRb::DRbTCPSocket
+      class ReceiverSocketError < StandardError; end
+
+      @@table = {}
+
+      def self.table
+        @@table
+      end
+
+      # Parses special URI for reverse scheme.
+      def self.parse_uri(uri)
+        if uri =~ /^receiver:\/\/(.*?):(\d+)(\?(.*))?$/
+          host = $1
+          port = $2.to_i
+          option = $4
+          [host, port, option]
+        else
+          raise(DRb::DRbBadScheme, uri) unless uri =~ /^receiver:/
+          raise(DRb::DRbBadURI, 'can\'t parse uri:' + uri)
+        end
+      end
+
+      # Raises an error. You cannnot open receiver socket on caller side.
+      def self.open(uri, config)
+        raise DRb::DRbBadScheme.new(uri)
+      end
+
+      # Creates a fake connection.
+      # @api private
+      def self.open_server(uri, config)
+        # reverse socket needs URI always
+        raise ArgumentError.new("You should specify receiver URI.") unless uri
+
+        # get config
+        host, port, option = parse_uri(uri)
+
+        # retrieve socket by rev_id
+        key = "%s:%s" % [host, port]
+        unless @@table.has_key?(key)
+          raise ReceiverSocketError.new("No socket for %s." % uri)
+        end
+        socket = @@table[key]
+
+        # create an instance with relay socket
+        return self.new(uri, socket, config)
+      end
+
+      # Raises an error because the socket cannot accept.
+      def accept
+        raise ReceiverSocketError.new("ReceiverSocket cannnot accept connections.")
+      end
+
+      def close
+      end
+
+      def alive?
+        true
+      end
+
+      def set_socket(*args)
+      end
+    end
+
+    # install the protocol
+    DRb::DRbProtocol.add_protocol(ReceiverSocket)
+  end
+end

data/lib/pione/relay/relay-account-db.rb

@@ -0,0 +1,55 @@
+module Pione
+  module Relay
+    class RelayAccountDB
+      extend Forwardable
+
+      Account = Struct.new(:name, :digest)
+
+      def_delegator :@table, "[]"
+
+      def initialize(path)
+        raise TypeError.new(path) unless path.kind_of?(Pathname)
+        @path = path
+        @table = read_database
+      end
+
+      def add(realm, name, password)
+        # stretching x 1000
+        digest = (1..1000).inject("") {|hash, _|
+          Digest::SHA512.hexdigest("%s:%s:%s" % [hash, name, password])
+        }
+        @table[realm] = Account.new(name, digest)
+      end
+
+      def delete(realm)
+        @table.delete(realm)
+        save
+      end
+
+      def realms
+        @table.keys
+      end
+
+      def save
+        @path.open("w+", 0600) do |f|
+          @table.each do |realm, account|
+            f.puts "%s:%s:%s" % [realm, account.name, account.digest] if realm and account
+          end
+        end
+      end
+
+      private
+
+      def read_database
+        if @path.exist?
+          @path.readlines.inject({}) do |tbl, line|
+            realm, name, digest = line.chomp.split(":")
+            tbl.tap{ tbl.store(realm, Account.new(name, digest)) }
+          end
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/pione/relay/relay-client-db.rb

@@ -0,0 +1,53 @@
+module Pione
+  module Relay
+    class RelayClientDB
+      def initialize(path)
+        raise TypeError.new(path) unless path.kind_of?(Pathname)
+        @path = path
+        @table = read_database
+      end
+
+      def auth(uuid, name, response)
+        Digest::SHA512.hexdigest("%s:%s" % [uuid, @table[name]]) == response
+      end
+
+      def add(name, password)
+        # stretching x 1000
+        @table[name] = (1..1000).inject("") {|hash, _|
+          Digest::SHA512.hexdigest("%s:%s:%s" % [hash, name, password])
+        }
+      end
+
+      def delete(name)
+        @table.delete(name)
+        save
+      end
+
+      def names
+        @table.keys
+      end
+
+      def save
+        @path.open("w+", 0600) do |f|
+          @table.each do |name, digest|
+            f.puts "%s:%s" % [name, digest] if name and digest
+          end
+        end
+      end
+
+      private
+
+      def read_database
+        if @path.exist?
+          @path.readlines.inject({}) do |tbl, line|
+            name, digest = line.chomp.split(":")
+            tbl.tap{ tbl.store(name, digest) }
+          end
+        else
+          {}
+        end
+      end
+    end
+  end
+end
+

data/lib/pione/relay/relay-socket.rb

@@ -0,0 +1,215 @@
+module Pione
+  module Relay
+    # RelaySocket is connection layer between PIONE client and PIONE relay.
+    class RelaySocket < DRb::DRbSSLSocket
+      # AuthError is an error for relay authentication failure.
+      class AuthError < StandardError; end
+
+      # ProxyError is raised when proxy server cannot start.
+      class ProxyError < StandardError; end
+
+      # BadMessage is an error for protocol violation.
+      class BadMessage < Exception; end
+
+      def self.parse_uri(uri)
+        if uri =~ /^relay:\/\/(.*?)(:(\d+))?(\?(.*))?$/
+          host = $1
+          port = $3 ? $3.to_i : Global.relay_port
+          option = $5
+          return host, port, option
+        else
+          raise DRb::DRbBadScheme.new(uri) unless uri =~ /^relay:/
+          raise DRb::DRbBadURI.new('can\'t parse uri:' + uri)
+        end
+      end
+
+      # Opens the socket on pione-client.
+      def self.open(uri, config)
+        host, port, option = parse_uri(uri)
+        host.untaint
+        port.untaint
+
+        # make tcp connection with SSL
+        soc = TCPSocket.open(host, port)
+        ssl_conf = DRb::DRbSSLSocket::SSLConfig.new(config)
+        ssl_conf.setup_ssl_context
+        ssl = ssl_conf.connect(soc)
+
+        if Global.show_communication
+          puts "you connected relay socket to %s" % uri
+        end
+
+        # auth like HTTP's digest method
+        begin
+          Timeout.timeout(Global.relay_client_auth_timeout_sec) do
+            realm = ssl.gets.chomp
+            uuid = ssl.gets.chomp
+            account = Global.relay_account_db[realm] || (raise AuthError.new("unknown realm: %s" % realm))
+            name = account.name
+            digest = account.digest
+            response = "%s:%s" % [name, Digest::SHA512.hexdigest("%s:%s" % [uuid, digest])]
+            ssl.puts(response)
+            unless ssl.read(3).chomp == "OK"
+              raise AuthError.new("authentication failed")
+            end
+          end
+        rescue AuthError => e
+          raise e
+        rescue Timeout::Error
+          raise AuthError.new("authentication timeout")
+        end
+
+        if Global.show_communication
+          puts "you succeeded relay authentication: %s" % uri
+        end
+
+        # create receiver socket
+        ReceiverSocket.table["%s:%s" % [host, port]] = ssl
+        Global.relay_receiver = DRb::DRbServer.new(
+          "receiver://%s:%s" % [host, port],
+          Global.relay_tuple_space_server
+        )
+
+        # create an instance
+        return self.new(uri, ssl, ssl_conf, true)
+      end
+
+      # Opens relay server port for clients.
+      # @api private
+      def self.open_server(uri, config)
+        # parse URI
+        uri = 'relay://:%s' % Global.relay_port unless uri
+        host, port, option = parse_uri(uri)
+
+        # rebuild URI
+        if host.size == 0
+          host = getservername
+          soc = open_server_inaddr_any(host, port)
+        else
+          soc = TCPServer.open(host, port)
+        end
+        port = soc.addr[1] if port == 0
+        new_uri = "relay://#{host}:#{port}"
+
+        # prepare SSL
+        ssl_conf = DRb::DRbSSLSocket::SSLConfig.new(config).tap do |conf|
+          conf.setup_certificate
+          conf.setup_ssl_context
+        end
+
+        # create instance
+        self.new(new_uri, soc, ssl_conf, false)
+      end
+
+      def self.uri_option(uri, config)
+        host, port, option = parse_uri(uri)
+        return "relay://#{host}:#{port}", option
+      end
+
+      # Accepts pione-clients on server side.
+      # @api private
+      def accept
+        begin
+          # accept loop
+          while true
+            soc = @socket.accept
+            break if (@acl ? @acl.allow_socket?(soc) : true)
+            soc.close
+          end
+
+          if Global.show_communication
+            puts "someone connected to relay socket..."
+          end
+
+          # build ssl
+          ssl = @config.accept(soc)
+
+          # relay auth like HTTP's digest method
+          ssl.puts(Global.relay_realm)
+          uuid = Util.generate_uuid
+          ssl.puts(uuid)
+          if msg = ssl.gets
+            name, digest = msg.chomp.split(":")
+            unless Global.relay_client_db.auth(uuid, name, digest)
+              raise AuthError.new(name)
+            end
+            ssl.puts "OK"
+
+            if Global.show_communication
+              puts "succeeded authentication for %s" % name
+            end
+
+            # setup transmitter_id
+            transmitter_id = Util.generate_uuid
+
+            # save ssl socket as receiver side with transmitter_id
+            TransmitterSocket.receiver_socket[transmitter_id] = ssl
+
+            # open and save tcp socket with transmitter_id
+            Global.relay_transmitter_proxy_side_port_range.each do |port|
+              begin
+                tcp_socket = TCPServer.new("localhost", port)
+                TransmitterSocket.proxy_socket[transmitter_id] = tcp_socket
+                break
+              rescue
+              end
+            end
+
+            # create servers
+            transmitter_server = create_transmitter_server(transmitter_id)
+            proxy_server = create_proxy_server(transmitter_id)
+
+            # start to provide the proxy server
+            TupleSpaceProvider.instance.add_tuple_space_server(
+              DRb::DRbObject.new_with_uri(proxy_server.uri)
+            )
+
+            # create instance
+            self.class.new(uri, ssl, @config, true)
+          else
+            raise BadMessage
+          end
+        rescue OpenSSL::SSL::SSLError, AuthError, BadMessage => e
+          soc.close
+          if Global.show_communication
+            puts "closed relay socket"
+            Util::ErrorReport.print(e)
+          end
+          retry
+        end
+      end
+
+      # Creates a transmitter server with the relay socket.
+      # @return [void]
+      def create_transmitter_server(transmitter_id)
+        uri = "transmitter://%s" % transmitter_id
+        server = DRb::DRbServer.new(uri, Trampoline.new(uri, @config))
+        if Global.show_communication
+          puts "relay created the transmitter: %s" % server.uri
+        end
+        return server
+      end
+
+      # Creates a proxy server for brokers in LAN.
+      def create_proxy_server(transmitter_id)
+        transmitter = DRb::DRbObject.new_with_uri("transmitter://%s" % transmitter_id)
+        Global.relay_proxy_port_range.each do |port|
+          begin
+            uri = "druby://localhost:%s" % port
+            server = DRb::DRbServer.new(uri, transmitter)
+            if Global.show_communication
+              puts "relay created the proxy: %s" % server.uri
+            end
+            return server
+          rescue
+            next
+          end
+        end
+        raise ProxyError.new("You cannot start relay proxy server.")
+      end
+    end
+
+    # install the protocol
+    DRb::DRbProtocol.add_protocol(RelaySocket)
+  end
+end