vinesmod 0.4.5

data/lib/vines/jid.rb

@@ -0,0 +1,95 @@
+# encoding: UTF-8
+
+module Vines
+  class JID
+    include Comparable
+
+    PATTERN = /\A(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?\Z/.freeze
+
+    # http://tools.ietf.org/html/rfc6122#appendix-A
+    NODE_PREP = /[[:cntrl:] "&'\/:<>@]/.freeze
+
+    # http://tools.ietf.org/html/rfc3454#appendix-C
+    NAME_PREP = /[[:cntrl:] ]/.freeze
+
+    # http://tools.ietf.org/html/rfc6122#appendix-B
+    RESOURCE_PREP = /[[:cntrl:]]/.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 {|part| part.downcase! if part }
+
+      validate
+    end
+
+    # Strip the resource part from this JID and return it as a new
+    # JID object. The new JID contains only the optional node part
+    # and the required domain part from the original. This JID remains
+    # unchanged.
+    def bare
+      JID.new(@node, @domain)
+    end
+
+    # Return true if this is a bare JID without a resource part.
+    def bare?
+      @resource.nil?
+    end
+
+    # Return true if this is a domain-only JID without a node or resource part.
+    def domain?
+      !empty? && to_s == @domain
+    end
+
+    # Return true if this JID is equal to the empty string ''. That is, it's
+    # missing the node, domain, and resource parts that form a valid JID. It
+    # makes for easier error handling to be able to create JID objects from
+    # strings and then check if they're empty rather than nil.
+    def empty?
+      to_s == ''
+    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
+
+    private
+
+    def validate
+      [@node, @domain, @resource].each do |part|
+        raise ArgumentError, 'jid too long' if (part || '').size > 1023
+      end
+      raise ArgumentError, 'empty node' if @node && @node.strip.empty?
+      raise ArgumentError, 'node contains invalid characters' if @node && @node =~ NODE_PREP
+      raise ArgumentError, 'empty resource' if @resource && @resource.strip.empty?
+      raise ArgumentError, 'resource contains invalid characters' if @resource && @resource =~ RESOURCE_PREP
+      raise ArgumentError, 'empty domain' if @domain == '' && (@node || @resource)
+      raise ArgumentError, 'domain contains invalid characters' if @domain && @domain =~ NAME_PREP
+    end
+  end
+end

data/lib/vines/kit.rb

@@ -0,0 +1,35 @@
+# 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
+      SecureRandom.uuid
+    end
+
+    # Generates a random 128 character authentication token.
+    def self.auth_token
+      SecureRandom.hex(64)
+    end
+
+    def self.local_ip
+      orig = Socket.do_not_reverse_lookup
+      Socket.do_not_reverse_lookup = true
+      UDPSocket.open do |s|
+        s.connect '64.223.187.99', 1
+        s.addr.last
+      end
+
+      ensure
+        Socket.do_not_reverse_lookup = orig
+    end
+  end
+end

data/lib/vines/log.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+module Vines
+  module Log
+    @@logger = nil
+    def log
+      unless @@logger
+        @@logger = Logger.new(STDOUT)
+        @@logger.level = Logger::INFO
+        @@logger.progname = 'vines'
+        @@logger.formatter = Class.new(Logger::Formatter) do
+          def initialize
+            @time = "%Y-%m-%d %H:%M:%S".freeze
+            @fmt  = "[%s] %5s -- %s: %s\n".freeze
+          end
+          def call(severity, time, program, msg)
+            @fmt % [time.utc.strftime(@time), severity, program, msg2str(msg)]
+          end
+        end.new
+      end
+      @@logger
+    end
+  end
+end

data/lib/vines/router.rb

@@ -0,0 +1,179 @@
+# 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 +Config#router+.
+  class Router
+    EMPTY = [].freeze
+
+    STREAM_TYPES = [:client, :server, :component].freeze
+
+    def initialize(config)
+      @config = config
+      @clients, @servers, @components = {}, [], []
+      @pending = Hash.new {|h,k| h[k] = [] }
+    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, from, proxies=true)
+      jid, from = JID.new(jid), JID.new(from)
+      return [] unless @config.allowed?(jid, from)
+
+      local = @clients[jid.bare] || EMPTY
+      local = local.select {|stream| stream.user.jid == jid } unless jid.bare?
+      remote = proxies ? proxies(jid) : EMPTY
+      [local, remote].flatten
+    end
+
+    # Returns streams for all available resources for this JID. A resource is
+    # marked available after it sends initial presence.
+    def available_resources(*jids, from)
+      clients(jids, from) do |stream|
+        stream.available?
+      end
+    end
+
+    # Returns streams for all interested resources for this JID. A resource is
+    # marked interested after it requests the roster.
+    def interested_resources(*jids, from)
+      clients(jids, from) do |stream|
+        stream.interested?
+      end
+    end
+
+    # Add the connection to the routing table. The connection must return
+    # :client, :server, or :component from its +stream_type+ method so the
+    # router can properly route stanzas to the stream.
+    def <<(stream)
+      case stream_type(stream)
+      when :client then
+        return unless stream.connected?
+        jid = stream.user.jid.bare
+        @clients[jid] ||= []
+        @clients[jid] << stream
+      when :server then @servers << stream
+      when :component then @components << stream
+      end
+    end
+
+    # Remove the connection from the routing table.
+    def delete(stream)
+      case stream_type(stream)
+      when :client then
+        return unless stream.connected?
+        jid = stream.user.jid.bare
+        streams = @clients[jid] || []
+        streams.delete(stream)
+        @clients.delete(jid) if streams.empty?
+      when :server then @servers.delete(stream)
+      when :component then @components.delete(stream)
+      end
+    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]) }
+      return unless @config.allowed?(to, from)
+      key = [to.domain, from.domain]
+
+      if stream = connection_to(to, from)
+        stream.write(stanza)
+      elsif @pending.key?(key)
+        @pending[key] << stanza
+      elsif @config.s2s?(to.domain)
+        @pending[key] << stanza
+        Vines::Stream::Server.start(@config, to.domain, from.domain) do |stream|
+          stream ? send_pending(key, stream) : return_pending(key)
+          @pending.delete(key)
+        end
+      else
+        raise StanzaErrors::RemoteServerNotFound.new(stanza, 'cancel')
+      end
+    end
+
+    # Returns the total number of streams connected to the server.
+    def size
+      clients = @clients.values.inject(0) {|sum, arr| sum + arr.size }
+      clients + @servers.size + @components.size
+    end
+
+    private
+
+    # Write all pending stanzas for this domain to the stream. Called after a
+    # s2s stream has successfully connected and we need to dequeue all stanzas
+    # we received while waiting for the connection to finish.
+    def send_pending(key, stream)
+      @pending[key].each do |stanza|
+        stream.write(stanza)
+      end
+    end
+
+    # Return all pending stanzas to their senders as remote-server-not-found
+    # errors. Called after a s2s stream has failed to connect.
+    def return_pending(key)
+      @pending[key].each do |stanza|
+        to, from = JID.new(stanza['to']), JID.new(stanza['from'])
+        xml = StanzaErrors::RemoteServerNotFound.new(stanza, 'cancel').to_xml
+        if @config.component?(from)
+          connection_to(from, to).write(xml) rescue nil
+        else
+          connected_resources(from, to).each {|c| c.write(xml) }
+        end
+      end
+    end
+
+    # Return the client streams to which the from address is allowed to
+    # contact. Apply the filter block to each stream to narrow the results
+    # before returning the streams.
+    def clients(jids, from, &filter)
+      jids = filter_allowed(jids, from)
+      local = @clients.values_at(*jids).compact.flatten.select(&filter)
+      proxies = proxies(*jids).select(&filter)
+      [local, proxies].flatten
+    end
+
+    # Return the bare JIDs from the list that are allowed to talk to
+    # the +from+ JID.
+    def filter_allowed(jids, from)
+      from = JID.new(from)
+      jids.flatten.map {|jid| JID.new(jid).bare }
+        .select {|jid| @config.allowed?(jid, from) }
+    end
+
+    def proxies(*jids)
+      return EMPTY unless @config.cluster?
+      @config.cluster.remote_sessions(*jids)
+    end
+
+    def connection_to(to, from)
+      component_stream(to) || server_stream(to, from)
+    end
+
+    def component_stream(to)
+      @components.select do |stream|
+        stream.ready? && stream.remote_domain == to.domain
+      end.sample
+    end
+
+    def server_stream(to, from)
+      @servers.select do |stream|
+        stream.ready? &&
+          stream.remote_domain == to.domain &&
+            stream.domain == from.domain
+      end.sample
+    end
+
+    def stream_type(connection)
+      connection.stream_type.tap do |type|
+        unless STREAM_TYPES.include?(type)
+          raise ArgumentError, "unexpected stream type: #{type}"
+        end
+      end
+    end
+  end
+end

data/lib/vines/stanza.rb

@@ -0,0 +1,175 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    include Nokogiri::XML
+
+    attr_reader :stream
+
+    EMPTY = ''.freeze
+    FROM, MESSAGE, TO = %w[from message to].map {|s| s.freeze }
+    ROUTABLE_STANZAS  = %w[message iq presence].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
+
+    # Send the stanza to all recipients, stamping it with from and
+    # to addresses first.
+    def broadcast(recipients)
+      @node[FROM] = stream.user.jid.to_s
+      recipients.each do |recipient|
+        @node[TO] = recipient.user.jid.to_s
+        recipient.write(@node)
+      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?
+      return true unless ROUTABLE_STANZAS.include?(@node.name)
+      to = JID.new(@node[TO])
+      to.empty? || local_jid?(to)
+    end
+
+    def local_jid?(*jids)
+      stream.config.local_jid?(*jids)
+    end
+
+    # Return true if this stanza is addressed to a pubsub subdomain hosted
+    # at this server. This helps differentiate between IQ stanzas addressed
+    # to the server and stanzas addressed to pubsub domains, both of which must
+    # be handled locally and not routed.
+    def to_pubsub_domain?
+      stream.config.pubsub?(validate_to)
+    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
+
+    # Broadcast unavailable presence from the user's available resources to the
+    # recipient's available resources. Route the stanza to a remote server if
+    # the recipient isn't hosted locally.
+    def send_unavailable(from, to)
+      available = router.available_resources(from, to)
+      stanzas = available.map {|stream| unavailable(stream.user.jid) }
+      broadcast_to_available_resources(stanzas, to)
+    end
+
+    # Return an unavailable presence stanza addressed from the given JID.
+    def unavailable(from)
+      doc = Document.new
+      doc.create_element('presence',
+        'from' => from.to_s,
+        'id'   => Kit.uuid,
+        'type' => 'unavailable')
+    end
+
+    # Return nil if this stanza has no 'to' attribute. Return a Vines::JID
+    # if it contains a valid 'to' attribute.  Raise a JidMalformed error if
+    # the JID is invalid.
+    def validate_to
+      validate_address(TO)
+    end
+
+    # Return nil if this stanza has no 'from' attribute. Return a Vines::JID
+    # if it contains a valid 'from' attribute.  Raise a JidMalformed error if
+    # the JID is invalid.
+    def validate_from
+      validate_address(FROM)
+    end
+
+    def method_missing(method, *args, &block)
+      @node.send(method, *args, &block)
+    end
+
+    private
+
+    # Send the stanzas to the destination JID, routing to a s2s stream
+    # if the address is remote. This method properly stamps the to address
+    # on each stanza before it's sent. The caller must set the from address.
+    def broadcast_to_available_resources(stanzas, to)
+      return if send_to_remote(stanzas, to)
+      send_to_recipients(stanzas, stream.available_resources(to))
+    end
+
+    # Send the stanzas to the destination JID, routing to a s2s stream
+    # if the address is remote. This method properly stamps the to address
+    # on each stanza before it's sent. The caller must set the from address.
+    def broadcast_to_interested_resources(stanzas, to)
+      return if send_to_remote(stanzas, to)
+      send_to_recipients(stanzas, stream.interested_resources(to))
+    end
+
+    # Route the stanzas to a remote server, stamping a bare JID as the
+    # to address. Bare JIDs are required for presence subscription stanzas
+    # sent to the remote contact's server. Return true if the stanzas were
+    # routed, false if they must be delivered locally.
+    def send_to_remote(stanzas, to)
+      return false if local_jid?(to)
+      to = JID.new(to)
+      stanzas.each do |el|
+        el[TO] = to.bare.to_s
+        router.route(el)
+      end
+      true
+    end
+
+    # Send the stanzas to the local recipient streams, stamping a full JID as
+    # the to address. It's important to use full JIDs, even when sending to
+    # local clients, because the stanzas may be routed to other cluster nodes
+    # for delivery. We need the receiving cluster node to send the stanza just
+    # to this full JID, not to lookup all JIDs for this user.
+    def send_to_recipients(stanzas, recipients)
+      recipients.each do |recipient|
+        stanzas.each do |el|
+          el[TO] = recipient.user.jid.to_s
+          recipient.write(el)
+        end
+      end
+    end
+
+    # Return true if the to and from JIDs are allowed to communicate with one
+    # another based on the cross_domain_messages setting in conf/config.rb. If
+    # a domain's users are isolated to sending messages only within their own
+    # domain, pubsub stanzas must not be processed from remote JIDs.
+    def allowed?
+      stream.config.allowed?(validate_to || stream.domain, stream.user.jid)
+    end
+
+    def validate_address(attr)
+      jid = (self[attr] || EMPTY)
+      return if jid.empty?
+      JID.new(jid)
+    rescue
+      raise StanzaErrors::JidMalformed.new(self, 'modify')
+    end
+  end
+end