diaspora-vines 0.1.2

data/lib/vines/stream/component.rb

@@ -0,0 +1,58 @@
+# 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 :remote_domain
+
+      def initialize(config)
+        super
+        @remote_domain = nil
+        @stream_id = Kit.uuid
+        advance(Start.new(self))
+      end
+
+      def max_stanza_size
+        config[:component].max_stanza_size
+      end
+
+      def ready?
+        state.class == Component::Ready
+      end
+
+      def stream_type
+        :component
+      end
+
+      def start(node)
+        @remote_domain = node['to']
+        send_stream_header
+        raise StreamErrors::ImproperAddressing unless valid_address?(@remote_domain)
+        raise StreamErrors::HostUnknown unless config.component?(@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/http/auth.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Auth < Client::Auth
+        def initialize(stream, success=BindRestart)
+          super
+        end
+
+        def node(node)
+          unless stream.valid_session?(node['sid']) && body?(node) && node['rid']
+            raise StreamErrors::NotAuthorized
+          end
+          nodes = stream.parse_body(node)
+          raise StreamErrors::NotAuthorized unless nodes.size == 1
+          super(nodes.first)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Bind < Client::Bind
+        FEATURES = %Q{<stream:features xmlns:stream="#{NAMESPACES[:stream]}"/>}.freeze
+
+        def initialize(stream, success=Ready)
+          super
+        end
+
+        def node(node)
+          unless stream.valid_session?(node['sid']) && body?(node) && node['rid']
+            raise StreamErrors::NotAuthorized
+          end
+          nodes = stream.parse_body(node)
+          raise StreamErrors::NotAuthorized unless nodes.size == 1
+          super(nodes.first)
+        end
+
+        private
+
+        # Override Client::Bind#send_empty_features to properly namespace the
+        # empty features element.
+        def send_empty_features
+          stream.write(FEATURES)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class BindRestart < State
+        def initialize(stream, success=Bind)
+          super
+        end
+
+        def node(node)
+          raise StreamErrors::NotAuthorized unless restart?(node)
+
+          doc = Document.new
+          body = doc.create_element('body') do |el|
+            el.add_namespace(nil, NAMESPACES[:http_bind])
+            el.add_namespace('stream', NAMESPACES[:stream])
+            el << doc.create_element('stream:features') do |features|
+              features << doc.create_element('bind', 'xmlns' => NAMESPACES[:bind])
+            end
+          end
+          stream.reply(body)
+          advance
+        end
+
+        private
+
+        def restart?(node)
+          session = stream.valid_session?(node['sid'])
+          restart = node.attribute_with_ns('restart', NAMESPACES[:bosh]).value rescue nil
+          domain  = node['to'] == stream.domain
+          session && body?(node) && domain && restart == 'true' && node['rid']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Ready < Client::Ready
+        RID, SID, TYPE, TERMINATE = %w[rid sid type terminate].map {|s| s.freeze }
+
+        def node(node)
+          unless stream.valid_session?(node[SID]) && body?(node) && node[RID]
+            raise StreamErrors::NotAuthorized
+          end
+          stream.parse_body(node).each do |child|
+            begin
+              super(child)
+            rescue StanzaError => e
+              stream.error(e)
+            end
+          end
+          stream.terminate if terminate?(node)
+        end
+
+        def terminate?(node)
+          node[TYPE] == TERMINATE
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# encoding: UTF-8
+
+module Vines
+  class Stream
+    class Http
+      class Request
+        BUF_SIZE      = 1024
+        MODIFIED      = '%a, %d %b %Y %H:%M:%S GMT'.freeze
+        MOVED         = 'Moved Permanently'.freeze
+        NOT_FOUND     = 'Not Found'.freeze
+        NOT_MODIFIED  = 'Not Modified'.freeze
+        IF_MODIFIED   = 'If-Modified-Since'.freeze
+        TEXT_PLAIN    = 'text/plain'.freeze
+        OPTIONS       = 'OPTIONS'.freeze
+        CONTENT_TYPES = {
+          'html'     => 'text/html; charset="utf-8"',
+          'js'       => 'application/javascript; charset="utf-8"',
+          'css'      => 'text/css',
+          'png'      => 'image/png',
+          'jpg'      => 'image/jpeg',
+          'jpeg'     => 'image/jpeg',
+          'gif'      => 'image/gif',
+          'manifest' => 'text/cache-manifest'
+        }.freeze
+
+        attr_reader :stream, :body, :headers, :method, :path, :url, :query
+
+        def initialize(stream, parser, body)
+          @stream, @body = stream, body
+          @headers  = parser.headers
+          @method   = parser.http_method
+          @path     = parser.request_path
+          @url      = parser.request_url
+          @query    = parser.query_string
+          @received = Time.now
+        end
+
+        # Return the number of seconds since this request was received.
+        def age
+          Time.now - @received
+        end
+
+        # Write the requested file to the client out of the given document root
+        # directory. Take care to prevent directory traversal attacks with paths
+        # like ../../../etc/passwd. Use the If-Modified-Since request header
+        # to implement caching.
+        def reply_with_file(dir)
+          path = File.expand_path(File.join(dir, @path))
+
+          # redirect requests missing a slash so relative links work
+          if File.directory?(path) && !@path.end_with?('/')
+            send_status(301, MOVED, "Location: #{redirect_uri}")
+            return
+          end
+
+          path = File.join(path, 'index.html') if File.directory?(path)
+
+          if path.start_with?(dir) && File.exist?(path)
+            modified?(path) ? send_file(path) : send_status(304, NOT_MODIFIED)
+          else
+            missing = File.join(dir, '404.html')
+            if File.exist?(missing)
+              send_file(missing, 404, NOT_FOUND)
+            else
+              send_status(404, NOT_FOUND)
+            end
+          end
+        end
+
+        # Send an HTTP 200 OK response wrapping the XMPP node content back
+        # to the client.
+        def reply(node, content_type)
+          body = node.to_s
+          header = [
+            "HTTP/1.1 200 OK",
+            "Access-Control-Allow-Origin: *",
+            "Content-Type: #{content_type}",
+            "Content-Length: #{body.bytesize}",
+            vroute_cookie
+          ].compact.join("\r\n")
+          @stream.stream_write([header, body].join("\r\n\r\n"))
+        end
+
+        # Return true if the request method is OPTIONS, signaling a
+        # CORS preflight check.
+        def options?
+          @method == OPTIONS
+        end
+
+        # Send a 200 OK response, allowing any origin domain to connect to the
+        # server, in response to CORS preflight OPTIONS requests. This allows
+        # any web application using strophe.js to connect to our BOSH port.
+        def reply_to_options
+          allow = @headers['Access-Control-Request-Headers']
+          headers = [
+            "Access-Control-Allow-Origin: *",
+            "Access-Control-Allow-Methods: POST, GET, OPTIONS",
+            "Access-Control-Allow-Headers: #{allow}",
+            "Access-Control-Max-Age: #{60 * 60 * 24 * 30}"
+          ]
+          send_status(200, 'OK', headers)
+        end
+
+        private
+
+        # Attempt to rebuild the full request URI from the Host header. If it
+        # wasn't sent by the client, just return the relative path that
+        # was requested. The Location response header must contain the fully
+        # qualified URI, but most browsers will accept relative paths as well.
+        def redirect_uri
+          host = headers['Host']
+          uri = "#{path}/"
+          uri = "#{uri}?#{query}" unless (query || '').empty?
+          uri = "http://#{host}#{uri}" if host
+          uri
+        end
+
+        # Return true if the file has been modified since the client last
+        # requested it with the If-Modified-Since header.
+        def modified?(path)
+          @headers[IF_MODIFIED] != mtime(path)
+        end
+
+        def mtime(path)
+          File.mtime(path).utc.strftime(MODIFIED)
+        end
+
+        def send_status(status, message, *headers)
+          header = [
+            "HTTP/1.1 #{status} #{message}",
+            "Content-Length: 0",
+            *headers
+          ].join("\r\n")
+          @stream.stream_write("#{header}\r\n\r\n")
+        end
+
+        # Stream the contents of the file to the client in a 200 OK response.
+        # Send a Last-Modified response header so clients can send us an
+        # If-Modified-Since request header for caching.
+        def send_file(path, status=200, message='OK')
+          header = [
+            "HTTP/1.1 #{status} #{message}",
+            "Content-Type: #{content_type(path)}",
+            "Content-Length: #{File.size(path)}",
+            "Last-Modified: #{mtime(path)}"
+          ].join("\r\n")
+          @stream.stream_write("#{header}\r\n\r\n")
+
+          File.open(path) do |file|
+            while (buf = file.read(BUF_SIZE)) != nil
+              @stream.stream_write(buf)
+            end
+          end
+        end
+
+        def content_type(path)
+          ext = File.extname(path).sub('.', '')
+          CONTENT_TYPES[ext] || TEXT_PLAIN
+        end
+
+        # Provide a vroute cookie in each response that uniquely identifies this
+        # HTTP server. Reverse proxy servers (nginx/apache) can use this cookie
+        # to implement sticky sessions. Return nil if vroute was not set in
+        # config.rb and no cookie should be sent.
+        def vroute_cookie
+          route = @stream.config[:http].vroute
+          route ? "Set-Cookie: vroute=#{route}; path=/; HttpOnly" : nil
+        end
+      end
+    end
+  end
+end

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