meshchat 0.5.0

data/lib/meshchat/message/node_list.rb

@@ -0,0 +1,41 @@
+module MeshChat
+  module Message
+    class NodeList < Base
+      def message
+        @message ||= Node.as_json
+      end
+
+      def handle
+        respond
+        return
+      end
+
+      # only need to respond if this server has node entries that the
+      # sender of this message doesn't have
+      def respond
+        received_list = message
+        we_only_have, they_only_have = Node.diff(received_list)
+
+        if we_only_have.present?
+          location = payload['sender']['location']
+
+          node = Node.find_by_location(location)
+
+          # give the sender our list
+          MeshChat::Net::Client.send(
+            node: node,
+            message: NodeListDiff.new(message: we_only_have)
+          )
+
+          # give the network their list
+          Node.online.each do |entry|
+            MeshChat::Net::Client.send(
+              node: entry,
+              message: NodeListDiff.new(message: they_only_have)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/message/node_list_diff.rb

@@ -0,0 +1,15 @@
+module MeshChat
+  module Message
+    class NodeListDiff < Base      
+      def handle
+        entries_we_do_not_have = message
+
+        entries_we_do_not_have.each do |entry_as_json|
+          # this will silently fail if there is a duplicate
+          # or if this is an invalid entry
+          Node.from_json(entry_as_json).save
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/message/node_list_hash.rb

@@ -0,0 +1,29 @@
+module MeshChat
+  module Message
+    class NodeListHash < Base
+      def message
+        @message ||= Node.as_sha512
+      end
+
+      # node list hash is received
+      # @return [NilClass] no output for this message type
+      def handle
+        respond
+        return
+      end
+
+      def respond
+        if message != Node.as_sha512
+          location = payload['sender']['location']
+
+          node = Node.find_by_location(location)
+
+          MeshChat::Net::Client.send(
+            node: node,
+            message: NodeList.new(message: Node.as_json)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/message/ping.rb

@@ -0,0 +1,32 @@
+module MeshChat
+  module Message
+    class Ping < Base
+
+      def display
+        # we'll never display our own ping to someone else...
+        # or shouldn't.... or there should be different output
+        # TODO: display is a bad method name
+        name = payload['sender']['alias']
+        location = payload['sender']['location']
+
+        "#{name}@#{location} pinged you."
+      end
+
+      def handle
+        respond
+        display
+      end
+
+      def respond
+        location = payload['sender']['location']
+
+        node = Node.find_by_location(location)
+
+        MeshChat::Net::Client.send(
+          node: node,
+          message: PingReply.new
+        )
+      end
+    end
+  end
+end

data/lib/meshchat/message/ping_reply.rb

@@ -0,0 +1,9 @@
+module MeshChat
+  module Message
+    class PingReply < Base
+      def display
+        'ping successful'.freeze
+      end
+    end
+  end
+end

data/lib/meshchat/message/relay.rb

@@ -0,0 +1,43 @@
+module MeshChat
+  module Message
+    class Relay < Base
+      def initialize(
+        message: nil,
+        sender_name: nil,
+        sender_location: nil,
+        sender_uid: nil,
+        time_recieved: nil,
+        payload: nil,
+        destination: '',
+        hops: [])
+
+        # package the original message
+        message = {
+          message: message,
+          destination: destination,
+          hops: hops
+        }
+
+        super(
+          message: message,
+          sender_name: sender_name,
+          sender_location: sender_location,
+          sender_uid: sender_uid,
+          time_recieved: time_recieved,
+          payload: payload)
+      end
+
+      def display; end
+
+      def handle
+        respond
+        return
+      end
+
+      def respond
+
+      end
+
+    end
+  end
+end

data/lib/meshchat/message/whisper.rb

@@ -0,0 +1,36 @@
+module MeshChat
+  module Message
+    class Whisper < Base
+      attr_accessor :_to
+
+      def initialize(
+        message: nil,
+        sender_name: nil,
+        sender_location: nil,
+        sender_uid: nil,
+        time_recieved: nil,
+        payload: nil,
+        to: '')
+
+        super(
+          message: message,
+          sender_name: sender_name,
+          sender_location: sender_location,
+          sender_uid: sender_uid,
+          time_recieved: time_recieved,
+          payload: payload)
+
+        self._to = to
+      end
+
+      def display
+        time_sent = payload['time_sent'].to_s
+        time = Date.parse(time_sent)
+        time_recieved = time.strftime('%e/%m/%y %H:%I:%M')
+
+        to = _to.present? ? "->#{_to}" : ''
+        "#{time_recieved} #{sender_name}#{to} > #{message}"
+      end
+    end
+  end
+end

data/lib/meshchat/models/entry.rb

@@ -0,0 +1,104 @@
+module MeshChat
+  module Models
+    class Entry < ActiveRecord::Base
+      IPV4_WITH_PORT = /((?:(?:^|\.)(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])){4})(:\d*)?/
+      # http://rubular.com/r/WYT09ptct3
+      DOMAIN_WITH_PORT = /(https?:\/\/)?([\da-z\.-]+)\.?([a-z\.]{2,6})([\/\w \.-]*)*[^\/](:\d*)?/
+
+      validates :alias_name,
+                :location,
+                :public_key, presence: true
+
+      validates :uid, presence: true, uniqueness: true
+
+      # ipv4 with port
+      validates_format_of :location, with: ->(e){
+        location = e.location || ''
+        location.include?('//') || location.include?('localhost') ?
+          DOMAIN_WITH_PORT :
+          IPV4_WITH_PORT
+      }
+
+      scope :online, -> { where(online: true) }
+      scope :offline, -> { where(online: false) }
+
+      class << self
+        def sha_preimage
+          all.map(&:public_key).sort.join(',')
+        end
+
+        def as_sha512
+          digest = Digest::SHA512.new
+          digest.hexdigest sha_preimage
+        end
+
+        def as_json
+          # must also include ourselves
+          # so that we can pass our own public key
+          # to those who don't have it
+          others = all.map(&:as_json)
+          me = Settings.identity_as_json
+          others << me
+        end
+
+        def from_json(json)
+          new(
+            alias_name: json['alias'],
+            location: json['location'],
+            uid: json['uid'],
+            public_key: json['publicKey']
+          )
+        end
+
+        def public_key_from_uid(uid)
+          find_by_uid(uid).try(:public_key)
+        end
+
+        # @param [Array] theirs array of hashes representing node entries
+        # @return [Array<-,+>] nodes only we have, and nodes only they have
+        def diff(theirs)
+          ours = as_json
+          we_only_have = ours - theirs
+          they_only_have = theirs - ours
+
+          [we_only_have, they_only_have]
+        end
+
+        def import_from_file(filename)
+          begin
+            f = File.read(filename)
+            hash = JSON.parse(f)
+            n = from_json(hash)
+            n.save
+            n
+          rescue => e
+            Display.alert e.message
+          end
+        end
+      end
+
+      def ==(other)
+        result = false
+
+        if other.is_a?(Hash)
+          result = as_json.values_at(*other.keys) == other.values
+        end
+
+        result || super
+      end
+
+      def as_json
+        {
+          'alias' => alias_name,
+          'location' => location,
+          'uid' => uid,
+          'publicKey' => public_key
+        }
+      end
+
+      def as_info
+        "#{alias_name}@#{location}"
+      end
+    end
+  end
+end

data/lib/meshchat/net/client.rb

@@ -0,0 +1,60 @@
+module MeshChat
+  module Net
+    module Client
+      module_function
+
+      # @note Either the location, node, or uid should be present
+      #
+      # @param [String] location (Optional) location of target
+      # @param [String] uid (Optional) uid of target
+      # @param [Node] node (Optional) target
+      # @param [Message] message (Required) what to send to the target
+      def send(location: nil, uid: nil, node: nil, message: nil)
+        # verify node is valid
+        node = self.node_for(location: location, uid: uid, node: node)
+
+        Thread.new(node, message) do |node, message|
+          request = MeshChat::Net::Request.new(node, message)
+          payload = { message: request.payload }
+          begin
+            Curl::Easy.http_post(node.location, payload.to_json) do |c|
+              c.headers['Accept'] = 'application/json'
+              c.headers['Content-Type'] = 'application/json'
+              if MeshChat::Settings.debug?
+                puts message.render
+                c.verbose = true
+                c.on_debug do |type, data|
+                  puts data
+                end
+              end
+            end
+          rescue => e
+            node.update(online: false)
+            Display.info "#{node.alias_name} has ventured offline"
+            Display.debug("#{message.class.name}: Issue connectiong to #{node.alias_name}@#{node.location}")
+            Display.debug(e.message)
+          end
+        end
+      end
+
+      # private
+
+      # @return [Node]
+      def node_for(location: nil, uid: nil, node: nil)
+        unless node
+          node = Models::Entry.find_by_location(location) if location
+          node = Models::Entry.find_by_uid(uid) if uid && !node
+        end
+
+        # TODO: also check for public key?
+        # without the public key, the message is sent in cleartext. :-\
+        if !(node && node.location)
+          Display.alert "Node not found, or does not have a location"
+          return
+        end
+
+        node
+      end
+    end
+  end
+end

data/lib/meshchat/net/listener/request.rb

@@ -0,0 +1,48 @@
+module MeshChat
+  module Net
+    module Listener
+      class Request
+        attr_accessor :json, :message
+        attr_accessor :_input
+
+        def initialize(input)
+          self._input = try_decrypt(input)
+          self.json = JSON.parse(_input)
+          self.message = process_json
+        end
+
+        private
+
+        def try_decrypt(input)
+          begin
+            # TODO: do we want to try to decrypting anyway if decoding fails?
+            decoded = Base64.decode64(input)
+            input = Cipher.decrypt(decoded, Settings[:privateKey])
+          rescue => e
+            Display.debug e.message
+            Display.debug e.backtrace.join("\n")
+            Display.warning e.message
+            Display.info 'It\'s possible that this message was sent in cleartext, or was encrypted with the wrong public key'
+          end
+
+          Display.debug 'server received message:'
+          Display.debug input
+
+          input
+        end
+
+        def process_json
+          type = json['type']
+          klass = Message::TYPES[type]
+
+          unless klass
+            Display.alert 'message recieved and not recognized...'
+            return
+          end
+
+          klass.new(payload: json)
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/net/listener/request_processor.rb

@@ -0,0 +1,45 @@
+module MeshChat
+  module Net
+    module Listener
+      module RequestProcessor
+
+        module_function
+
+        def process(raw)
+          request = Request.new(raw)
+
+          message = request.message
+          update_sender_info(request.json)
+
+          Display.present_message message
+        end
+
+        def update_sender_info(json)
+          sender = json['sender']
+
+          # if the sender isn't currently marked as active,
+          # perform the server list exchange
+          node = Node.find_by_uid(sender['uid'])
+          if node.nil?
+            return Display.alert "#{sender['alias']} is not authorized!"
+          end
+
+          unless node.online?
+            node.update(online: true)
+            payload = Message::NodeListHash.new
+            Client.send(
+              location: sender['location'],
+              message: payload)
+          end
+
+          # update the node's location/alias
+          # as they can change this info willy nilly
+          node.update(
+            location: sender['location'],
+            alias_name: sender['alias']
+          )
+        end
+      end
+    end
+  end
+end