vines 0.1.0

data/lib/vines/stream/client/auth_restart.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class AuthRestart < State
+        def initialize(stream, success=Auth)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          doc = Document.new
+          features = doc.create_element('stream:features') do |el|
+            el << doc.create_element('mechanisms') do |parent|
+              parent.default_namespace = NAMESPACES[:sasl]
+              mechanisms.each {|name| parent << doc.create_element('mechanism', name) }
+            end
+          end
+          stream.write(features)
+          advance
+        end
+
+        private
+
+        def mechanisms
+          ['EXTERNAL', 'PLAIN']
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/client/bind.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class Bind < State
+        NS = NAMESPACES[:bind]
+        MAX_ATTEMPTS = 5
+
+        def initialize(stream, success=Ready)
+          super
+          @attempts = 0
+        end
+
+        def node(node)
+          @attempts += 1
+          raise StreamErrors::NotAuthorized unless bind?(node)
+          raise StreamErrors::PolicyViolation.new('max bind attempts reached') if @attempts > MAX_ATTEMPTS
+          raise StanzaErrors::ResourceConstraint.new(node, 'wait') if resource_limit_reached?
+          stream.user.jid.resource = resource(node)
+          doc = Document.new
+          result = doc.create_element('iq', 'id' => node['id'], 'type' => 'result') do |el|
+            el << doc.create_element('bind') do |bind|
+              bind.default_namespace = NS
+              bind << doc.create_element('jid', stream.user.jid.to_s)
+            end
+          end
+          stream.write(result)
+          stream.write('<stream:features/>')
+          advance
+        end
+
+        private
+
+        def bind?(node)
+          node.name == 'iq' && node['type'] == 'set' && node.xpath('ns:bind', 'ns' => NS).any?
+        end
+
+        def resource(node)
+          el = node.xpath('ns:bind/ns:resource', 'ns' => NS).first
+          resource = el ? el.text.strip : ''
+          resource.empty? || resource_used?(resource) ? Kit.uuid : resource
+        end
+
+        def resource_limit_reached?
+          used = stream.router.connected_resources(stream.user.jid.bare).size
+          used >= stream.max_resources_per_account
+        end
+
+        def resource_used?(resource)
+          stream.router.available_resources(stream.user.jid).any? do |c|
+            c.user.jid.resource == resource
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/client/bind_restart.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class BindRestart < State
+        def initialize(stream, success=Bind)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          doc = Document.new
+          features = doc.create_element('stream:features') do |el|
+            el << doc.create_element('bind', 'xmlns' => NAMESPACES[:bind])
+            el << doc.create_element('session', 'xmlns' => NAMESPACES[:session])
+          end
+          stream.write(features)
+          advance
+        end  
+      end
+    end
+  end
+end

data/lib/vines/stream/client/closed.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class Closed < State
+        def node(node)
+          # ignore data received after close_connection
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/client/ready.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class Ready < State
+        def node(node)
+          stanza = to_stanza(node)
+          raise StreamErrors::UnsupportedStanzaType unless stanza
+          stanza.process
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class Start < State
+        def initialize(stream, success=TLS)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          doc = Document.new
+          features = doc.create_element('stream:features') do |el|
+            el << doc.create_element('starttls') do |tls|
+              tls.default_namespace = NAMESPACES[:tls]
+              tls << doc.create_element('required')
+            end
+          end
+          stream.write(features)
+          advance
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/client/tls.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Client
+      class TLS < State
+        NS = NAMESPACES[:tls]
+        PROCEED  = %Q{<proceed xmlns="#{NS}"/>}.freeze
+        FAILURE  = %Q{<failure xmlns="#{NS}"/>}.freeze
+        STARTTLS = 'starttls'.freeze
+
+        def initialize(stream, success=AuthRestart)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless starttls?(node)
+          if stream.encrypt?
+            stream.write(PROCEED)
+            stream.encrypt
+            advance
+          else
+            stream.write(FAILURE)
+            stream.write('</stream:stream>')
+            stream.close_connection_after_writing
+          end
+        end
+
+        private
+
+        def starttls?(node)
+          node.name == STARTTLS && namespace(node) == NS
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/component.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+
+    # Implements the XMPP protocol for trusted, external component (XEP-0114)
+    # streams. This serves connected streams using the jabber:component:accept
+    # namespace.
+    class Component < Stream
+      attr_reader :config, :remote_domain
+
+      def initialize(config)
+        @config = config
+        @remote_domain = nil
+        @stream_id = Kit.uuid
+        @state = Start.new(self)
+      end
+
+      def max_stanza_size
+        @config[:component].max_stanza_size
+      end
+
+      def ready?
+        @state.class == Component::Ready
+      end
+
+      def start(node)
+        @remote_domain = node['to']
+        send_stream_header
+        raise StreamErrors::HostUnknown unless @config[:component].password(@remote_domain)
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns'] == NAMESPACES[:component]
+        raise StreamErrors::InvalidNamespace unless node.namespaces['xmlns:stream'] == NAMESPACES[:stream]
+      end
+
+      def secret
+        password = @config[:component].password(@remote_domain)
+        Digest::SHA1.hexdigest(@stream_id + password)
+      end
+
+      private
+
+      def send_stream_header
+        attrs = {
+          'xmlns' => NAMESPACES[:component],
+          'xmlns:stream' => NAMESPACES[:stream],
+          'id' => @stream_id,
+          'from' => @remote_domain
+        }
+        write "<stream:stream %s>" % attrs.to_a.map{|k,v| "#{k}='#{v}'"}.join(' ')
+      end
+    end
+  end
+end

data/lib/vines/stream/component/handshake.rb

@@ -0,0 +1,25 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Component
+      class Handshake < State
+        def initialize(stream, success=Ready)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless handshake?(node)
+          stream.write('<handshake/>')
+          advance
+        end
+
+        private
+
+        def handshake?(node)
+          node.name == 'handshake' && node.text == stream.secret
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/component/ready.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Component
+      class Ready < State
+        def node(node)
+          stanza = to_stanza(node)
+          raise StreamErrors::UnsupportedStanzaType unless stanza
+          to = (node['to'] || '').strip
+          from = JID.new(node['from'] || '')
+          raise StreamErrors::ImproperAddressing if to.empty? || from.domain != stream.remote_domain
+          if stanza.local?
+            stream.router.connected_resources(to).each do |recipient|
+              recipient.write(node)
+            end
+          else
+            stanza.route
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Component
+      class Start < State
+        def initialize(stream, success=Handshake)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless stream?(node)
+          stream.start(node)
+          advance
+        end
+      end
+    end
+  end
+end

data/lib/vines/stream/http.rb

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http < Client
+      include Thin
+      include Vines::Log
+
+      attr_accessor :last_broadcast_presence, :last_activity
+
+      def initialize(config)
+        @config = config
+        @domain = nil
+        @requested_roster = false
+        @available = false
+        @unbound = false
+        @last_broadcast_presence = nil
+        @request = Thin::Request.new
+        @@http_states ||= HttpStates.new
+        @state = Auth.new(self)
+      end
+
+      def user
+        @http_state.user
+      end
+
+      def user=(user)
+        @http_state.user = user
+      end
+
+      def receive_data(data)
+        #TODO: make sure we add max stanza size enforcement
+        if @request.parse(data)
+          process_http_request(@request)
+          @request = Thin::Request.new
+        end
+      rescue InvalidRequest => e
+        error(StreamErrors::NotWellFormed.new)
+      end
+
+      def write(data)
+        @http_state.write(data)
+      end
+
+      def setup_new_client(rid, domain)
+        sid = Kit.uuid
+        log.info("Setting up a new client SID: #{sid} for RID: #{rid}.")
+        @http_state = HttpState.new(self, sid, rid, domain)
+        @@http_states[sid] = @http_state
+      end
+
+      def unbind
+        #router.delete(@http_state)
+        log.info("HTTP Stream disconnected:\tfrom=#{@remote_addr}\tto=#{@local_addr}")
+        log.info("Streams connected: #{router.size}")
+      end
+
+      def process_http_request(request)
+        if request.body.string.empty?
+          #Respond to proxy servers' status pings
+          log.info("A status request has been received.")
+          send_data("Online")
+          close_connection_after_writing
+          return
+        end
+        body = Nokogiri::XML(request.body.string).root
+        body.namespace = nil
+        #TODO: Confirm this is a valid body stanza.
+        # If it isn't a body, return proxy ping result
+
+        if body['sid']
+          @http_state = @@http_states[body['sid']]
+          unless @http_state
+            log.info("Client was not found #{body['sid']}")
+            send_bosh_error
+            return
+          end
+          @domain = @http_state.domain
+          @user = @http_state.user
+          @http_state.request(body['rid'])
+          if body['restart']
+            @http_state.handle_restart
+            router << @http_state
+            @state = Bind.new(self)
+          end
+
+          body.elements.each do |node|
+            @nodes.push(Nokogiri::XML(node.to_s.sub(' xmlns="jabber:client"', '')).root)
+          end
+        else
+          self.setup_new_client(body['rid'], body['to'])
+        end
+      end
+
+      def send_bosh_error
+        body = "<body type='terminate' condition='remote-connection-failed' xmlns='http://jabber.org/protocol/httpbind'/>"
+        header = [
+          "HTTP/1.1 404 OK",
+          "Content-Type: text/xml; charset=utf-8",
+          "Content-Length: #{body.bytesize}"
+        ].join("\r\n")
+
+        send_data([header, body].join("\r\n\r\n"))
+      end
+
+      def domain
+        @http_state.domain
+      end
+    end
+  end
+end