vinesmod 0.4.5

data/lib/vines/stream/http/session.rb

@@ -0,0 +1,120 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Session < Client::Session
+        include Nokogiri::XML
+
+        attr_accessor :content_type, :hold, :inactivity, :wait
+
+        CONTENT_TYPE = 'text/xml; charset=utf-8'.freeze
+
+        def initialize(stream)
+          super
+          @state = Http::Start.new(stream)
+          @inactivity, @wait, @hold = 20, 60, 1
+          @replied = Time.now
+          @requests, @responses = [], []
+          @content_type = CONTENT_TYPE
+        end
+
+        def close
+          Sessions.delete(@id)
+          router.delete(self)
+          delete_from_cluster
+          unsubscribe_pubsub
+          @requests.each {|req| req.stream.close_connection }
+          @requests.clear
+          @responses.clear
+          @state = Client::Closed.new(nil)
+          @unbound = true
+          @available = false
+          broadcast_unavailable
+        end
+
+        def ready?
+          @state.class == Http::Ready
+        end
+
+        def requests
+          @requests.clone
+        end
+
+        def expired?
+          respond_to_expired_requests
+          @requests.empty? && (Time.now - @replied > @inactivity)
+        end
+
+        # Resume this session from its most recent state with a new client
+        # stream and incoming node.
+        def resume(stream, node)
+          stream.session.requests.each do |req|
+            request(req)
+          end
+          stream.session = self
+          @state.stream = stream
+          @state.node(node)
+        end
+
+        def request(request)
+          if @responses.any?
+            request.reply(wrap_body(@responses.join), @content_type)
+            @replied = Time.now
+            @responses.clear
+          else
+            while @requests.size >= @hold
+              @requests.shift.reply(wrap_body(''), @content_type)
+              @replied = Time.now
+            end
+            @requests << request
+          end
+        end
+
+        # Send an HTTP 200 OK response wrapping the XMPP node content back
+        # to the client.
+        def reply(node)
+          if request = @requests.shift
+            request.reply(node, @content_type)
+            @replied = Time.now
+          end
+        end
+
+        # Write the XMPP node to the client stream after wrapping it in a BOSH
+        # body tag. If there's a waiting request, the node is written
+        # immediately. If not, it's queued until the next request arrives.
+        def write(node)
+          if request = @requests.shift
+            request.reply(wrap_body(node), @content_type)
+            @replied = Time.now
+          else
+            @responses << node.to_s
+          end
+        end
+
+        def unbind!(stream)
+          @requests.reject! {|req| req.stream == stream }
+        end
+
+        private
+
+        def respond_to_expired_requests
+          expired = @requests.select {|req| req.age > @wait }
+          expired.each do |request|
+            request.reply(wrap_body(''), @content_type)
+            @requests.delete(request)
+            @replied = Time.now
+          end
+        end
+
+        def wrap_body(data)
+          doc = Document.new
+          doc.create_element('body') do |node|
+            node.add_namespace(nil, NAMESPACES[:http_bind])
+            node.inner_html = data.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/sessions.rb

@@ -0,0 +1,65 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      # Sessions is a cache of Http::Session objects for transient HTTP
+      # connections. The cache is monitored for expired client connections.
+      class Sessions
+        include Vines::Log
+
+        @@instance = nil
+        def self.instance
+          @@instance ||= self.new
+        end
+
+        def self.[](sid)
+          instance[sid]
+        end
+
+        def self.[]=(sid, session)
+          instance[sid] = session
+        end
+
+        def self.delete(sid)
+          instance.delete(sid)
+        end
+
+        def initialize
+          @sessions = {}
+          start_timer
+        end
+
+        def []=(sid, session)
+          @sessions[sid] = session
+        end
+
+        def [](sid)
+          @sessions[sid]
+        end
+
+        def delete(sid)
+          @sessions.delete(sid)
+        end
+
+        private
+
+        # Check for expired clients to cleanup every second.
+        def start_timer
+          @timer ||= EventMachine::PeriodicTimer.new(1) { cleanup }
+        end
+
+        # Remove cached information for all expired connections. An expired
+        # HTTP client is one that has no queued requests and has had no activity
+        # for over 20 seconds.
+        def cleanup
+          @sessions.each_value do |session|
+            session.close if session.expired?
+          end
+        rescue => e
+          log.error("Expired session cleanup failed: #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http/start.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Start < State
+        def initialize(stream, success=Auth)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless body?(node)
+          if session = Sessions[node['sid']]
+            session.resume(stream, node)
+          else
+            stream.start(node)
+            advance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/parser.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Parser < Nokogiri::XML::SAX::Document
+      include Nokogiri::XML
+      STREAM_NAME = 'stream'.freeze
+      STREAM_URI  = 'http://etherx.jabber.org/streams'.freeze
+      IGNORE = NAMESPACES.values_at(:client, :component, :server)
+
+      def initialize(&block)
+        @listeners, @node = Hash.new {|h, k| h[k] = []}, nil
+        @parser = Nokogiri::XML::SAX::PushParser.new(self)
+        instance_eval(&block) if block
+      end
+
+      [:stream_open, :stream_close, :stanza].each do |name|
+        define_method(name) do |&block|
+          @listeners[name] << block
+        end
+      end
+
+      def <<(data)
+        @parser << data
+        self
+      end
+
+      def start_element_namespace(name, attrs=[], prefix=nil, uri=nil, ns=[])
+        el = node(name, attrs, prefix, uri, ns)
+        if stream?(name, uri)
+          notify(:stream_open, el)
+        else
+          @node << el if @node
+          @node = el
+        end
+      end
+
+      def end_element_namespace(name, prefix=nil, uri=nil)
+        if stream?(name, uri)
+          notify(:stream_close)
+        elsif @node.parent != @node.document
+          @node = @node.parent
+        else
+          notify(:stanza, @node)
+          @node = nil
+        end
+      end
+
+      def characters(chars)
+        @node << Text.new(chars, @node.document) if @node
+      end
+      alias :cdata_block :characters
+
+      private
+
+      def notify(msg, node=nil)
+        @listeners[msg].each do |b|
+          (node ? b.call(node) : b.call) rescue nil
+        end
+      end
+
+      def stream?(name, uri)
+        name == STREAM_NAME && uri == STREAM_URI
+      end
+
+      def node(name, attrs=[], prefix=nil, uri=nil, ns=[])
+        ignore = stream?(name, uri) ? [] : IGNORE
+        doc = @node ? @node.document : Document.new
+        doc.create_element(name) do |node|
+          attrs.each {|attr| node[attr.localname] = attr.value }
+          ns.each {|prefix, uri| node.add_namespace(prefix, uri) unless ignore.include?(uri) }
+          node.namespace = node.add_namespace(prefix, uri) unless ignore.include?(uri)
+          doc << node unless @node
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/sasl.rb

@@ -0,0 +1,92 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    # Provides plain (username/password) and external (TLS certificate) SASL
+    # authentication to client and server streams.
+    class SASL
+      include Vines::Log
+      EMPTY = '='.freeze
+
+      def initialize(stream)
+        @stream = stream
+      end
+
+      # Authenticate s2s streams, comparing their domain to their SSL certificate.
+      # Return +true+ if the base64 encoded domain matches the TLS certificate
+      # presented earlier in stream negotiation. Raise a +SaslError+ if
+      # authentication failed.
+      # http://xmpp.org/extensions/xep-0178.html#s2s
+      def external_auth(encoded)
+        unless encoded == EMPTY
+          authzid = decode64(encoded)
+          matches_from = (authzid == @stream.remote_domain)
+          raise SaslErrors::InvalidAuthzid unless matches_from
+        end
+        matches_from = @stream.cert_domain_matches?(@stream.remote_domain)
+        matches_from or raise SaslErrors::NotAuthorized
+      end
+
+      # Authenticate c2s streams using a username and password. Return the
+      # authenticated +User+ or raise a +SaslError+ if authentication failed.
+      def plain_auth(encoded)
+        jid, password = decode_credentials(encoded)
+        user = authenticate(jid, password)
+        user or raise SaslErrors::NotAuthorized
+      end
+
+      private
+
+      # Storage backends should not raise errors, but if an unexpected error
+      # occurs during authentication, convert it to a temporary-auth-failure.
+      # Return the authenticated +User+ or +nil+ if authentication failed.
+      def authenticate(jid, password)
+        log.info("Authenticating user: %s" % jid)
+        @stream.storage.authenticate(jid, password).tap do |user|
+          log.info("Authentication succeeded: %s" % user.jid) if user
+        end
+      rescue => e
+        log.error("Failed to authenticate: #{e.to_s}")
+        raise SaslErrors::TemporaryAuthFailure
+      end
+
+      # Return the +JID+ and password decoded from the base64 encoded SASL PLAIN
+      # credentials formatted as authzid\0authcid\0password.
+      # http://tools.ietf.org/html/rfc6120#section-6.3.8
+      # http://tools.ietf.org/html/rfc4616
+      def decode_credentials(encoded)
+        authzid, node, password = decode64(encoded).split("\x00")
+        raise SaslErrors::NotAuthorized if node.nil? || node.empty? || password.nil? || password.empty?
+        jid = JID.new(node, @stream.domain) rescue (raise SaslErrors::NotAuthorized)
+        validate_authzid!(authzid, jid)
+        [jid, password]
+      end
+
+      # An optional SASL authzid allows a user to authenticate with one
+      # user name and password and then have their connection authorized as a
+      # different ID (the authzid). We don't support that, so raise an error if
+      # the authzid is provided and different than the authcid.
+      #
+      # Most clients don't send an authzid at all because it's optional and not
+      # widely supported. However, Strophe and Blather send a bare JID, in
+      # compliance with RFC 6120, but Smack sends just the user name as the
+      # authzid. So, take care to handle non-compliant clients here.
+      # http://tools.ietf.org/html/rfc6120#section-6.3.8
+      def validate_authzid!(authzid, jid)
+        return if authzid.nil? || authzid.empty?
+        authzid.downcase!
+        smack = authzid == jid.node
+        compliant = authzid == jid.to_s
+        raise SaslErrors::InvalidAuthzid unless compliant || smack
+      end
+
+      # Decode the base64 encoded string, raising an error for invalid data.
+      # http://tools.ietf.org/html/rfc6120#section-13.9.1
+      def decode64(encoded)
+        Base64.strict_decode64(encoded)
+      rescue
+        raise SaslErrors::IncorrectEncoding
+      end
+    end
+  end
+end

data/lib/vines/stream/server.rb

@@ -0,0 +1,150 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    # Implements the XMPP protocol for server-to-server (s2s) streams. This
+    # serves connected streams using the jabber:server namespace. This handles
+    # both accepting incoming s2s streams and initiating outbound s2s streams
+    # to other servers.
+    class Server < Stream
+      MECHANISMS = %w[EXTERNAL].freeze
+
+      # Starts the connection to the remote server. When the stream is
+      # connected and ready to send stanzas it will yield to the callback
+      # block. The callback is run on the EventMachine reactor thread. The
+      # yielded stream will be nil if the remote connection failed. We need to
+      # use a background thread to avoid blocking the server on DNS SRV
+      # lookups.
+      def self.start(config, to, from, &callback)
+        op = proc do
+          Resolv::DNS.open do |dns|
+            dns.getresources("_xmpp-server._tcp.#{to}", Resolv::DNS::Resource::IN::SRV)
+          end.sort! {|a,b| a.priority == b.priority ? b.weight <=> a.weight : a.priority <=> b.priority }
+        end
+        cb = proc do |srv|
+          if srv.empty?
+            srv << {target: to, port: 5269}
+            class << srv.first
+              def method_missing(name); self[name]; end
+            end
+          end
+          Server.connect(config, to, from, srv, callback)
+        end
+        EM.defer(proc { op.call rescue [] }, cb)
+      end
+
+      def self.connect(config, to, from, srv, callback)
+        if srv.empty?
+          # fiber so storage calls work properly
+          Fiber.new { callback.call(nil) }.resume
+        else
+          begin
+            rr = srv.shift
+            opts = {to: to, from: from, srv: srv, callback: callback}
+            EM.connect(rr.target.to_s, rr.port, Server, config, opts)
+          rescue => e
+            connect(config, to, from, srv, callback)
+          end
+        end
+      end
+
+      attr_reader   :domain
+      attr_accessor :remote_domain
+
+      def initialize(config, options={})
+        super(config)
+        @connected = false
+        @remote_domain = options[:to]
+        @domain = options[:from]
+        @srv = options[:srv]
+        @callback = options[:callback]
+        @outbound = @remote_domain && @domain
+        start = @outbound ? Outbound::Start.new(self) : Start.new(self)
+        advance(start)
+      end
+
+      def post_init
+        super
+        send_stream_header if @outbound
+      end
+
+      def max_stanza_size
+        config[:server].max_stanza_size
+      end
+
+      def ssl_handshake_completed
+        close_connection unless cert_domain_matches?(@remote_domain)
+      end
+
+      # Return an array of allowed authentication mechanisms advertised as
+      # server stream features.
+      def authentication_mechanisms
+        MECHANISMS
+      end
+
+      def stream_type
+        :server
+      end
+
+      def unbind
+        super
+        if @outbound && !@connected
+          Server.connect(config, @remote_domain, @domain, @srv, @callback)
+        end
+      end
+
+      def vhost?(domain)
+        config.vhost?(domain)
+      end
+
+      def notify_connected
+        @connected = true
+        if @callback
+          @callback.call(self)
+          @callback = nil
+        end
+      end
+
+      def ready?
+        state.class == Server::Ready
+      end
+
+      def start(node)
+        if @outbound then send_stream_header; return end
+        to, from = %w[to from].map {|a| node[a] }
+        @domain, @remote_domain = to, from unless @domain
+        send_stream_header
+        raise StreamErrors::NotAuthorized if domain_change?(to, from)
+        raise StreamErrors::UnsupportedVersion unless node['version'] == '1.0'
+        raise StreamErrors::ImproperAddressing unless valid_address?(@domain) && valid_address?(@remote_domain)
+        raise StreamErrors::HostUnknown unless config.vhost?(@domain) || config.pubsub?(@domain) || config.component?(@domain)
+        raise StreamErrors::NotAuthorized unless config.s2s?(@remote_domain) && config.allowed?(@domain, @remote_domain)
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:server]
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns:stream'] == NAMESPACES[:stream]
+      end
+
+      private
+
+      # The +to+ and +from+ domain addresses set on the initial stream header
+      # must not change during stream restarts. This prevents a server from
+      # authenticating as one domain, then sending stanzas from users in a
+      # different domain.
+      def domain_change?(to, from)
+        to != @domain || from != @remote_domain
+      end
+
+      def send_stream_header
+        attrs = {
+          'xmlns' => NAMESPACES[:server],
+          'xmlns:stream' => NAMESPACES[:stream],
+          'xml:lang' => 'en',
+          'id' => Kit.uuid,
+          'from' => @domain,
+          'to' => @remote_domain,
+          'version' => '1.0'
+        }
+        write "<stream:stream %s>" % attrs.to_a.map{|k,v| "#{k}='#{v}'"}.join(' ')
+      end
+    end
+  end
+end