vines 0.2.1 → 0.3.0

data/lib/vines/config/port.rb

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+
+module Vines
+  class Config
+    class Port
+      include Vines::Log
+
+      attr_reader :config, :stream
+
+      %w[host port].each do |name|
+        define_method(name) do
+          @settings[name.to_sym]
+        end
+      end
+
+      def initialize(config, host, port, &block)
+        @config, @settings = config, {}
+        instance_eval(&block) if block
+        defaults = {:host => host, :port => port,
+          :max_resources_per_account => 5, :max_stanza_size => 128 * 1024}
+        @settings = defaults.merge(@settings)
+      end
+
+      def max_stanza_size(max=nil)
+        if max
+          # rfc 6120 section 13.12
+          @settings[:max_stanza_size] = [10000, max].max
+        else
+          @settings[:max_stanza_size]
+        end
+      end
+
+      def start
+        type = stream.name.split('::').last.downcase
+        log.info("Accepting #{type} connections on #{host}:#{port}")
+        EventMachine::start_server(host, port, stream, config)
+      end
+    end
+
+    class ClientPort < Port
+      def initialize(config, host='0.0.0.0', port=5222, &block)
+        @stream = Vines::Stream::Client
+        super(config, host, port, &block)
+      end
+
+      def max_resources_per_account(max=nil)
+        if max
+          @settings[:max_resources_per_account] = max
+        else
+          @settings[:max_resources_per_account]
+        end
+      end
+    end
+
+    class ServerPort < Port
+      def initialize(config, host='0.0.0.0', port=5269, &block)
+        @hosts, @stream = [], Vines::Stream::Server
+        super(config, host, port, &block)
+      end
+
+      def hosts(*hosts)
+        if hosts.any?
+          @hosts << hosts
+          @hosts.flatten!
+        else
+          @hosts
+        end
+      end
+    end
+
+    class HttpPort < Port
+      def initialize(config, host='0.0.0.0', port=5280, &block)
+        @stream = Vines::Stream::Http
+        super(config, host, port, &block)
+        defaults = {:root => File.expand_path('web'), :bind => '/xmpp'}
+        @settings = defaults.merge(@settings)
+      end
+
+      def max_resources_per_account(max=nil)
+        if max
+          @settings[:max_resources_per_account] = max
+        else
+          @settings[:max_resources_per_account]
+        end
+      end
+
+      def root(dir=nil)
+        if dir
+          @settings[:root] = File.expand_path(dir)
+        else
+          @settings[:root]
+        end
+      end
+
+      def bind(url=nil)
+        if url
+          @settings[:bind] = url
+        else
+          @settings[:bind]
+        end
+      end
+    end
+
+    class ComponentPort < Port
+      def initialize(config, host='0.0.0.0', port=5347, &block)
+        @stream = Vines::Stream::Component
+        super(config, host, port, &block)
+      end
+    end
+  end
+end

data/lib/vines/contact.rb

@@ -9,7 +9,7 @@ module Vines
 
     def initialize(args={})
       @jid = JID.new(args[:jid]).bare
-      raise ArgumentError, 'invalid jid' unless @jid.node && !@jid.domain.empty?
+      raise ArgumentError, 'invalid jid' if @jid.empty?
       @name = args[:name]
       @subscription = args[:subscription] || 'none'
       @ask = args[:ask]

data/lib/vines/jid.rb

@@ -6,6 +6,12 @@ module Vines
 
     PATTERN = /^(?:([^@]*)@)??([^@\/]*)(?:\/(.*?))?$/.freeze
 
+    # http://tools.ietf.org/html/rfc6122#appendix-A
+    NODE_PREP = /[[:space:][:cntrl:]"&'\/:<>@]/.freeze
+
+    # http://tools.ietf.org/html/rfc3454#appendix-C
+    NAME_PREP = /[[:space:][:cntrl:]]/.freeze
+
     attr_reader :node, :domain, :resource
     attr_writer :resource
 
@@ -19,11 +25,9 @@ module Vines
       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].each {|part| part.downcase! if part }
 
-      [@node, @domain, @resource].each do |piece|
-        raise ArgumentError, 'jid too long' if (piece || '').size > 1023
-      end
+      validate
     end
 
     def bare
@@ -34,6 +38,10 @@ module Vines
       @resource.nil?
     end
 
+    def empty?
+      to_s == ''
+    end
+
     def <=>(jid)
       self.to_s <=> jid.to_s
     end
@@ -52,5 +60,19 @@ module Vines
       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 =~ NAME_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

@@ -19,5 +19,11 @@ module Vines
       hex[16] = %w[8 9 a b][rand(4)]
       hex.scan(/(\w{8})(\w{4})(\w{4})(\w{4})(\w{12})/).first.join('-')
     end
+    
+    def self.generate_password
+      hash = Digest::SHA512.new
+      1024.times { hash << rand.to_s }
+      hash.hexdigest
+    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

@@ -6,7 +6,6 @@ module Vines
   # 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
 
     STREAM_TYPES = [:client, :server, :component].freeze
     STREAM_TYPES.each do |name|
@@ -29,30 +28,32 @@ module Vines
     # 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)
+    def connected_resources(jid, from)
+      jid, from = JID.new(jid), JID.new(from)
       clients.select do |stream|
-        stream.connected? && jid == (jid.bare? ? stream.user.jid.bare : stream.user.jid)
+        stream.connected? &&
+          jid == (jid.bare? ? stream.user.jid.bare : stream.user.jid) &&
+          @config.allowed?(jid, from)
       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 }
+    def available_resources(*jids, from)
+      jids = filter_allowed(jids, from)
       clients.select do |stream|
-        stream.available? && ids.include?(stream.user.jid.bare)
+        stream.available? && jids.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 }
+    def interested_resources(*jids, from)
+      jids = filter_allowed(jids, from)
       clients.select do |stream|
-        stream.interested? && ids.include?(stream.user.jid.bare)
+        stream.interested? && jids.include?(stream.user.jid.bare)
       end
     end
 
@@ -75,40 +76,24 @@ module Vines
     # 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)
+      return unless @config.allowed?(to, from)
+      key = [to.domain, from.domain]
+
+      if stream = connection_to(to, from)
         stream.write(stanza)
-      elsif @pending.key?(to.domain)
-        @pending[to.domain] << stanza
+      elsif @pending.key?(key)
+        @pending[key] << stanza
       elsif @config.s2s?(to.domain)
-        @pending[to.domain] << stanza
+        @pending[key] << 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)
+          stream ? send_pending(key, stream) : return_pending(key)
+          @pending.delete(key)
         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 }
@@ -116,9 +101,56 @@ module Vines
 
     private
 
-    def connection_to(domain)
-      (components + servers).find do |stream|
-        stream.ready? && stream.remote_domain == domain
+    # 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 bare JID's from the list that are allowed to talk to
+    # the +from+ JID. Store them in a Hash for fast +include?+ checks.
+    def filter_allowed(jids, from)
+      from = JID.new(from)
+      {}.tap do |ids|
+        jids.flatten.each do |jid|
+          jid = JID.new(jid).bare
+          ids[jid] = nil if @config.allowed?(jid, from)
+        end
+      end
+    end
+
+    def connection_to(to, from)
+      component_stream(to) || server_stream(to, from)
+    end
+
+    def component_stream(to)
+      components.find do |stream|
+        stream.ready? && stream.remote_domain == to.domain
+      end
+    end
+
+    def server_stream(to, from)
+      servers.find do |stream|
+        stream.ready? &&
+          stream.remote_domain == to.domain &&
+            stream.domain == from.domain
       end
     end
 

data/lib/vines/stanza.rb

@@ -6,7 +6,13 @@ module Vines
 
     attr_reader :stream
 
+    EMPTY   = ''.freeze
+    FROM    = 'from'.freeze
     MESSAGE = 'message'.freeze
+    TO      = 'to'.freeze
+
+    ROUTABLE_STANZAS = %w[message iq presence].freeze
+
     @@types = {}
 
     def self.register(xpath, ns={})
@@ -28,15 +34,23 @@ module Vines
     # Send the stanza to all recipients, stamping it with from and
     # to addresses first.
     def broadcast(recipients)
-      @node['from'] = stream.user.jid.to_s
+      @node[FROM] = stream.user.jid.to_s
       recipients.each do |recipient|
-        @node['to'] = recipient.user.jid.to_s
+        @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?
-      stream.router.local?(@node)
+      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
 
     def route
@@ -59,12 +73,12 @@ module Vines
     # recipient's available resources. Route the stanza to a remote server if
     # the recipient isn't hosted locally.
     def send_unavailable(from, to)
-      router.available_resources(from).each do |stream|
+      recipients = router.available_resources(to, from) if local_jid?(to)
+
+      router.available_resources(from, to).each do |stream|
         el = unavailable(stream.user.jid, to)
-        if router.local_jid?(to)
-          router.available_resources(to).each do |recipient|
-            recipient.write(el)
-          end
+        if local_jid?(to)
+          recipients.each {|recipient| recipient.write(el) }
         else
           router.route(el)
         end
@@ -81,8 +95,31 @@ module Vines
         '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
+
+    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