vines 0.1.0

data/lib/vines/jid.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+module Vines
+  class JID
+    include Comparable
+
+    PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/.freeze
+
+    attr_reader :node, :domain, :resource
+    attr_writer :resource
+
+    def self.new(node, domain=nil, resource=nil)
+      node.is_a?(JID) ? node : super
+    end
+
+    def initialize(node, domain=nil, resource=nil)
+      @node, @domain, @resource = node, domain, resource
+
+      if @domain.nil? && @resource.nil?
+        @node, @domain, @resource = @node.to_s.scan(PATTERN).first
+      end
+      [@node, @domain].each {|piece| piece.downcase! if piece }
+
+      [@node, @domain, @resource].each do |piece|
+        raise ArgumentError, 'jid too long' if (piece || '').size > 1023
+      end
+    end
+
+    def bare
+      JID.new(@node, @domain)
+    end
+
+    def bare?
+      @resource.nil?
+    end
+
+    def <=>(jid)
+      self.to_s <=> jid.to_s
+    end
+
+    def eql?(jid)
+      jid.is_a?(JID) && self == jid
+    end
+
+    def hash
+      self.to_s.hash
+    end
+
+    def to_s
+      s = @domain
+      s = "#{@node}@#{s}" if @node
+      s = "#{s}/#{@resource}" if @resource
+      s
+    end
+  end
+end

data/lib/vines/kit.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Vines
+
+  # A module for utility methods with no better home.
+  module Kit
+
+    # Create a hex-encoded, SHA-512 HMAC of the data, using the secret key.
+    def self.hmac(key, data)
+      digest = OpenSSL::Digest::Digest.new("sha512")
+      OpenSSL::HMAC.hexdigest(digest, key, data)
+    end
+
+    # Generates a random uuid per rfc 4122 that's useful for including in
+    # stream, iq, and other xmpp stanzas.
+    def self.uuid
+      hex = (0...16).map { "%02x" % rand(256) }.join
+      hex[12] = '4'
+      hex[16] = %w[8 9 a b][rand(4)]
+      hex.scan(/(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})/).first.join('-')
+    end
+  end
+end

data/lib/vines/router.rb

@@ -0,0 +1,125 @@
+# encoding: UTF-8
+
+module Vines
+  # The router tracks all stream connections to the server for all clients,
+  # servers, and components. It sends stanzas to the correct stream based on
+  # the 'to' attribute. Router is a singleton, shared by all streams, that must
+  # be accessed with +Router.instance+, not +Router.new+.
+  class Router
+    ROUTABLE_STANZAS = %w[message iq presence].freeze
+
+    @@instance = nil
+    def self.instance
+      @@instance ||= Router.new
+    end
+
+    def initialize
+      @config = nil
+      @streams = Hash.new {|h,k| h[k] = [] }
+      @pending = Hash.new {|h,k| h[k] = [] }
+    end
+
+    %w[Client Server Component].each do |klass|
+      name = klass.split(/(?=[A-Z])/).join('_').downcase
+      define_method(name + 's') do
+        @streams["Vines::Stream::#{klass}"]
+      end
+    end
+
+    def http_states
+      @streams["Vines::Stream::Http::HttpState"]
+    end
+
+    # Returns streams for all connected resources for this JID. A
+    # resource is considered connected after it has completed authentication
+    # and resource binding.
+    def connected_resources(jid)
+      jid = JID.new(jid)
+      (clients + http_states).select do |stream|
+        stream.connected? && jid == (jid.bare? ? stream.user.jid.bare : stream.user.jid)
+      end
+    end
+
+    # Returns streams for all available resources for this JID. A
+    # resource is marked available after it sends initial presence.
+    # This method accepts a single JID or a list of JIDs.
+    def available_resources(*jid)
+      ids = jid.flatten.map {|jid| JID.new(jid).bare }
+      (clients + http_states).select do |stream|
+        stream.available? && ids.include?(stream.user.jid.bare)
+      end
+    end
+
+    # Returns streams for all interested resources for this JID. A
+    # resource is marked interested after it requests the roster.
+    # This method accepts a single JID or a list of JIDs.
+    def interested_resources(*jid)
+      ids = jid.flatten.map {|jid| JID.new(jid).bare }
+      (clients + http_states).select do |stream|
+        stream.interested? && ids.include?(stream.user.jid.bare)
+      end
+    end
+
+    # Add the connection to the routing table.
+    def <<(connection)
+      @config ||= connection.config
+      @streams[connection.class.to_s] << connection
+    end
+
+    # Remove the connection from the routing table.
+    def delete(connection)
+      @streams[connection.class.to_s].delete(connection)
+    end
+
+    # Send the stanza to the appropriate remote server-to-server stream
+    # or an external component stream.
+    def route(stanza)
+      to, from = %w[to from].map {|attr| JID.new(stanza[attr]) }
+      if stream = connection_to(to.domain)
+        stream.write(stanza)
+      elsif @pending.key?(to.domain)
+        @pending[to.domain] << stanza
+      elsif @config.s2s?(to.domain)
+        @pending[to.domain] << stanza
+        Vines::Stream::Server.start(@config, to.domain, from.domain) do |stream|
+          if stream
+            @pending[to.domain].each {|s| stream.write(s) }
+          else
+            @pending[to.domain].each do |s|
+              xml = StanzaErrors::RemoteServerNotFound.new(s, 'cancel').to_xml
+              connected_resources(s['from']).each {|c| c.write(xml) }
+            end
+          end
+          @pending.delete(to.domain)
+        end
+      else
+        raise StanzaErrors::RemoteServerNotFound.new(stanza, 'cancel')
+      end
+    end
+
+    # Returns true if this stanza should be processed locally. Returns false
+    # if it's destined for a remote domain or external component.
+    def local?(stanza)
+      return true unless ROUTABLE_STANZAS.include?(stanza.name)
+      to = (stanza['to'] || '').strip
+      to.empty? || local_jid?(to)
+    end
+
+    def local_jid?(jid)
+      @config.vhost?(JID.new(jid).domain)
+    end
+
+    # Returns the total number of streams connected to the server.
+    def size
+      @streams.values.inject(0) {|sum, arr| sum + arr.size }
+    end
+
+    private
+
+    def connection_to(domain)
+      (components + servers).find do |stream|
+        stream.ready? && stream.remote_domain == domain
+      end
+    end
+  end
+end

data/lib/vines/stanza.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    include Nokogiri::XML
+
+    attr_reader :stream
+    MESSAGE = 'message'.freeze
+    @@types = {}
+
+    def self.register(xpath, ns={})
+      @@types[[xpath, ns]] = self
+    end
+
+    def self.from_node(node, stream)
+      # optimize common case
+      return Message.new(node, stream) if node.name == MESSAGE
+      found = @@types.select {|pair, v| node.xpath(*pair).any? }
+        .sort {|a, b| b[0][0].length - a[0][0].length }.first
+      found ? found[1].new(node, stream) : nil
+    end
+
+    def initialize(node, stream)
+      @node, @stream = node, stream
+    end
+
+    def broadcast(recipients)
+      stream.broadcast(@node, recipients)
+    end
+
+    def local?
+      stream.router.local?(@node)
+    end
+
+    def route
+      stream.router.route(@node)
+    end
+
+    def router
+      stream.router
+    end
+
+    def storage(domain=stream.domain)
+      stream.storage(domain)
+    end
+
+    def process
+      raise 'subclass must implement'
+    end
+
+    def method_missing(method, *args, &block)
+      @node.send(method, *args, &block)
+    end
+  end
+end

data/lib/vines/stanza/iq.rb

@@ -0,0 +1,50 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq < Stanza
+      register "/iq"
+
+      VALID_TYPES = %w[get set result error].freeze
+
+      VALID_TYPES.each do |type|
+        define_method "#{type}?" do
+          self['type'] == type
+        end
+      end
+
+      def process
+        if self['id'] && VALID_TYPES.include?(self['type'])
+          raise StanzaErrors::FeatureNotImplemented.new(@node, 'cancel')
+        else
+          raise StanzaErrors::BadRequest.new(@node, 'modify')
+        end
+      end
+
+      def to_result
+        doc = Document.new
+        doc.create_element('iq',
+          'from' => stream.domain,
+          'id'   => self['id'],
+          'to'   => stream.user.jid.to_s,
+          'type' => 'result')
+      end
+
+      private
+
+      def route_iq
+        to = (self['to'] || '').strip
+        return false if to.empty? || to == stream.domain
+        self['from'] = stream.user.jid.to_s
+        if local?
+          router.available_resources(to).each do |recipient|
+            recipient.write(@node)
+          end
+        else
+          route
+        end
+        true
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/auth.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Auth < Query
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NAMESPACES[:non_sasl]
+
+        def process
+          # XEP-0078 says we MUST send a service-unavailable error
+          # here, but Adium 1.4.1 won't login if we do that, so just
+          # swallow this stanza.
+          # raise StanzaErrors::ServiceUnavailable.new(@node, 'cancel')
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/disco_info.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class DiscoInfo < Query
+        NS = NAMESPACES[:disco_info]
+
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NS
+
+        def process
+          return if route_iq
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+              query << el.document.create_element('feature', 'var' => NAMESPACES[:ping])
+              query << el.document.create_element('feature', 'var' => NAMESPACES[:vcard])
+            end
+          end
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/disco_items.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class DiscoItems < Query
+        NS = NAMESPACES[:disco_items]
+
+        register "/iq[@id and @type='get']/ns:query", 'ns' => NS
+
+        def process
+          return if route_iq
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+            end
+          end
+          stream.write(result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/error.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Error < Iq
+        register "/iq[@id and @type='error']"
+
+        def process
+          return if route_iq
+          # do nothing
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/ping.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Ping < Iq
+        register "/iq[@id and @type='get']/ns:ping", 'ns' => NAMESPACES[:ping]
+
+        def process
+          return if route_iq
+          stream.write(to_result)
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/query.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Query < Iq
+      end
+    end
+  end
+end

data/lib/vines/stanza/iq/result.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      class Result < Iq
+        register "/iq[@id and @type='result']"
+
+        def process
+          return if route_iq
+          # do nothing
+        end
+      end
+    end
+  end
+end