lygneo-vines 0.1.1

data/lib/vines/follower.rb

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+
+module Vines
+  class Follower
+    include Comparable
+
+    attr_accessor :name, :subscription, :ask, :groups
+    attr_reader :jid
+
+    def initialize(args={})
+      @jid = JID.new(args[:jid]).bare
+      raise ArgumentError, 'invalid jid' if @jid.empty?
+      @name = args[:name]
+      @subscription = args[:subscription] || 'none'
+      @ask = args[:ask]
+      @groups = args[:groups] || []
+    end
+
+    def <=>(follower)
+      follower.is_a?(Follower) ? self.jid.to_s <=> follower.jid.to_s : nil
+    end
+
+    alias :eql? :==
+
+    def hash
+      jid.to_s.hash
+    end
+
+    def update_from(follower)
+      @name = follower.name
+      @subscription = follower.subscription
+      @ask = follower.ask
+      @groups = follower.groups.clone
+    end
+
+    # Returns true if this follower is in a state that allows the user
+    # to subscribe to their presence updates.
+    def can_subscribe?
+      @ask == 'subscribe' && %w[none from].include?(@subscription)
+    end
+
+    def subscribe_to
+      @subscription = (@subscription == 'none') ? 'to' : 'both'
+      @ask = nil
+    end
+
+    def unsubscribe_to
+      @subscription = (@subscription == 'both') ? 'from' : 'none'
+    end
+
+    def subscribe_from
+      @subscription = (@subscription == 'none') ? 'from' : 'both'
+      @ask = nil
+    end
+
+    def unsubscribe_from
+      @subscription = (@subscription == 'both') ? 'to' : 'none'
+    end
+
+    # Returns true if the user is subscribed to this follower's
+    # presence updates.
+    def subscribed_to?
+      %w[to both].include?(@subscription)
+    end
+
+    # Returns true if the user has a presence subscription from
+    # this follower. The follower is subscribed to this user's presence.
+    def subscribed_from?
+      %w[from both].include?(@subscription)
+    end
+
+    # Returns a hash of this follower's attributes suitable for persisting in
+    # a document store.
+    def to_h
+      {
+        'name' => @name,
+        'subscription' => @subscription,
+        'ask' => @ask,
+        'groups' => @groups.sort!
+      }
+    end
+
+    # Write an iq stanza to the recipient stream representing this follower's
+    # current roster item state.
+    def send_roster_push(recipient)
+      doc = Nokogiri::XML::Document.new
+      node = doc.create_element('iq',
+        'id'   => Kit.uuid,
+        'to'   => recipient.user.jid.to_s,
+        'type' => 'set')
+      node << doc.create_element('query', 'xmlns' => NAMESPACES[:roster]) do |query|
+        query << to_roster_xml
+      end
+      recipient.write(node)
+    end
+
+    # Returns this follower as an xmpp <item> element.
+    def to_roster_xml
+      doc = Nokogiri::XML::Document.new
+      doc.create_element('item') do |el|
+        el['ask'] = @ask unless @ask.nil? || @ask.empty?
+        el['jid'] = @jid.bare.to_s
+        el['name'] = @name unless @name.nil? || @name.empty?
+        el['subscription'] = @subscription
+        @groups.sort!.each do |group|
+          el << doc.create_element('group', group)
+        end
+      end
+    end
+  end
+end

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,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.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
+  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-%dT%H:%M:%SZ".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
+    # follower. 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/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,45 @@
+# 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 || !allowed?
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+              if to_pubsub_domain?
+                identity(query, 'pubsub', 'service')
+                pubsub = [:pubsub_create, :pubsub_delete, :pubsub_instant, :pubsub_item_ids, :pubsub_publish, :pubsub_subscribe]
+                features(query, :disco_info, :ping, :pubsub, *pubsub)
+              else
+                identity(query, 'server', 'im')
+                features = [:disco_info, :disco_items, :ping, :vcard, :version]
+                features << :storage if stream.config.private_storage?(validate_to || stream.domain)
+                features(query, features)
+              end
+            end
+          end
+          stream.write(result)
+        end
+
+        private
+
+        def identity(query, category, type)
+          query << query.document.create_element('identity', 'category' => category, 'type' => type)
+        end
+
+        def features(query, *features)
+          features.flatten.each do |feature|
+            query << query.document.create_element('feature', 'var' => NAMESPACES[feature])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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 || !allowed?
+          result = to_result.tap do |el|
+            el << el.document.create_element('query') do |query|
+              query.default_namespace = NS
+              unless to_pubsub_domain?
+                to = (validate_to || stream.domain).to_s
+                stream.config.vhost(to).disco_items.each do |domain|
+                  query << el.document.create_element('item', 'jid' => domain)
+                end
+              end
+            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 || !allowed?
+          stream.write(to_result)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+
+module Vines
+  class Stanza
+    class Iq
+      # Implements the Private Storage feature defined in XEP-0049. Clients are
+      # allowed to save arbitrary XML documents on the server, identified by
+      # element name and namespace.
+      class PrivateStorage < Query
+        NS = NAMESPACES[:storage]
+
+        register "/iq[@id and (@type='get' or @type='set')]/ns:query", 'ns' => NS
+
+        def process
+          validate_to_address
+          validate_storage_enabled
+          validate_children_size
+          validate_namespaces
+          get? ? retrieve_fragment : update_fragment
+        end
+
+        private
+
+        def retrieve_fragment
+          found = storage.find_fragment(stream.user.jid, elements.first.elements.first)
+          raise StanzaErrors::ItemNotFound.new(self, 'cancel') unless found
+
+          result = to_result do |node|
+            node << node.document.create_element('query') do |query|
+              query.default_namespace = NS
+              query << found
+            end
+          end
+          stream.write(result)
+        end
+
+        def update_fragment
+          elements.first.elements.each do |node|
+            storage.save_fragment(stream.user.jid, node)
+          end
+          stream.write(to_result)
+        end
+
+        private
+
+        def to_result
+          super.tap do |node|
+            node['from'] = stream.user.jid.to_s
+            yield node if block_given?
+          end
+        end
+
+        def validate_children_size
+          size = elements.first.elements.size
+          if (get? && size != 1) || (set? && size == 0)
+            raise StanzaErrors::NotAcceptable.new(self, 'modify')
+          end
+        end
+
+        def validate_to_address
+          to = validate_to
+          unless to.nil? || to == stream.user.jid.bare
+            raise StanzaErrors::Forbidden.new(self, 'cancel')
+          end
+        end
+
+        def validate_storage_enabled
+          unless stream.config.private_storage?(stream.domain)
+            raise StanzaErrors::ServiceUnavailable.new(self, 'cancel')
+          end
+        end
+
+        def validate_namespaces
+          elements.first.elements.each do |node|
+            if node.namespace.nil? || NAMESPACES.values.include?(node.namespace.href)
+              raise StanzaErrors::NotAcceptable.new(self, 'modify')
+            end
+          end
+        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