em-websocket 0.3.8 → 0.4.0

data/lib/em-websocket/handshake.rb

@@ -0,0 +1,137 @@
+require "http/parser"
+
+module EventMachine
+  module WebSocket
+
+    # Resposible for creating the server handshake response
+    class Handshake
+      include EM::Deferrable
+
+      attr_reader :parser, :protocol_version
+
+      # Unfortunately drafts 75 & 76 require knowledge of whether the
+      # connection is being terminated as ws/wss in order to generate the
+      # correct handshake response
+      def initialize(secure)
+        @parser = Http::Parser.new
+        @secure = secure
+
+        @parser.on_headers_complete = proc { |headers|
+          @headers = Hash[headers.map { |k,v| [k.downcase, v] }]
+        }
+      end
+
+      def receive_data(data)
+        @parser << data
+
+        if @headers
+          process(@headers, @parser.upgrade_data)
+        end
+      rescue HTTP::Parser::Error => e
+        fail(HandshakeError.new("Invalid HTTP header: #{e.message}"))
+      end
+
+      # Returns the WebSocket upgrade headers as a hash.
+      #
+      # Keys are strings, unmodified from the request.
+      #
+      def headers
+        @parser.headers
+      end
+
+      # The same as headers, except that the hash keys are downcased
+      #
+      def headers_downcased
+        @headers
+      end
+
+      # Returns the request path (excluding any query params)
+      #
+      def path
+        @parser.request_path
+      end
+
+      # Returns the query params as a string foo=bar&baz=...
+      def query_string
+        @parser.query_string
+      end
+
+      def query
+        Hash[query_string.split('&').map { |c| c.split('=', 2) }]
+      end
+
+      # Returns the WebSocket origin header if provided
+      #
+      def origin
+        @headers["origin"] || @headers["sec-websocket-origin"] || nil
+      end
+
+      private
+
+      def process(headers, remains)
+        unless @parser.http_method == "GET"
+          raise HandshakeError, "Must be GET request"
+        end
+
+        # Validate Upgrade
+        unless @parser.upgrade?
+          raise HandshakeError, "Not an upgrade request"
+        end
+        upgrade = @headers['upgrade']
+        unless upgrade.kind_of?(String) && upgrade.downcase == 'websocket'
+          raise HandshakeError, "Invalid upgrade header: #{upgrade}"
+        end
+
+        # Determine version heuristically
+        version = if @headers['sec-websocket-version']
+          # Used from drafts 04 onwards
+          @headers['sec-websocket-version'].to_i
+        elsif @headers['sec-websocket-draft']
+          # Used in drafts 01 - 03
+          @headers['sec-websocket-draft'].to_i
+        elsif @headers['sec-websocket-key1']
+          76
+        else
+          75
+        end
+
+        # Additional handling of bytes after the header if required
+        case version
+        when 75
+          if !remains.empty?
+            raise HandshakeError, "Extra bytes after header"
+          end
+        when 76, 1..3
+          if remains.length < 8
+            # The whole third-key has not been received yet.
+            return nil
+          elsif remains.length > 8
+            raise HandshakeError, "Extra bytes after third key"
+          end
+          @headers['third-key'] = remains
+        end
+
+        handshake_klass = case version
+        when 75
+          Handshake75
+        when 76, 1..3
+          Handshake76
+        when 5, 6, 7, 8, 13
+          Handshake04
+        else
+          # According to spec should abort the connection
+          raise HandshakeError, "Protocol version #{version} not supported"
+        end
+
+        upgrade_response = handshake_klass.handshake(@headers, @parser.request_url, @secure)
+
+        handler_klass = Handler.klass_factory(version)
+
+        @protocol_version = version
+        succeed(upgrade_response, handler_klass)
+      rescue HandshakeError => e
+        fail(e)
+      end
+    end
+  end
+end

data/lib/em-websocket/handshake04.rb

@@ -4,30 +4,28 @@ require 'base64'
 module EventMachine
   module WebSocket
     module Handshake04
-      def handshake
+      def self.handshake(headers, _, __)
         # Required
-        unless key = request['sec-websocket-key']
-          raise HandshakeError, "Sec-WebSocket-Key header is required"
+        unless key = headers['sec-websocket-key']
+          raise HandshakeError, "sec-websocket-key header is required"
         end
-        
+
         # Optional
-        origin = request['sec-websocket-origin']
-        protocols = request['sec-websocket-protocol']
-        extensions = request['sec-websocket-extensions']
-        
+        origin = headers['sec-websocket-origin']
+        protocols = headers['sec-websocket-protocol']
+        extensions = headers['sec-websocket-extensions']
+
         string_to_sign = "#{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
         signature = Base64.encode64(Digest::SHA1.digest(string_to_sign)).chomp
-        
+
         upgrade = ["HTTP/1.1 101 Switching Protocols"]
         upgrade << "Upgrade: websocket"
         upgrade << "Connection: Upgrade"
         upgrade << "Sec-WebSocket-Accept: #{signature}"
-        
-        # TODO: Support Sec-WebSocket-Protocol
-        # TODO: Sec-WebSocket-Extensions
-        
-        debug [:upgrade_headers, upgrade]
-        
+
+        # TODO: Support sec-websocket-protocol
+        # TODO: sec-websocket-extensions
+
         return upgrade.join("\r\n") + "\r\n\r\n"
       end
     end

data/lib/em-websocket/handshake75.rb

@@ -1,19 +1,16 @@
 module EventMachine
   module WebSocket
     module Handshake75
-      def handshake
-        location  = "#{request['host'].scheme}://#{request['host'].host}"
-        location << ":#{request['host'].port}" if request['host'].port
-        location << request['path']
+      def self.handshake(headers, path, secure)
+        scheme = (secure ? "wss" : "ws")
+        location = "#{scheme}://#{headers['host']}#{path}"
 
         upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
         upgrade << "Upgrade: WebSocket\r\n"
         upgrade << "Connection: Upgrade\r\n"
-        upgrade << "WebSocket-Origin: #{request['origin']}\r\n"
+        upgrade << "WebSocket-Origin: #{headers['origin']}\r\n"
         upgrade << "WebSocket-Location: #{location}\r\n\r\n"
 
-        debug [:upgrade_headers, upgrade]
-
         return upgrade
       end
     end

data/lib/em-websocket/handshake76.rb

@@ -1,33 +1,30 @@
 require 'digest/md5'
 
-module EventMachine
-  module WebSocket
-    module Handshake76
-      def handshake
+module EventMachine::WebSocket
+  module Handshake76
+    class << self
+      def handshake(headers, path, secure)
         challenge_response = solve_challenge(
-          request['sec-websocket-key1'],
-          request['sec-websocket-key2'],
-          request['third-key']
+          headers['sec-websocket-key1'],
+          headers['sec-websocket-key2'],
+          headers['third-key']
         )
 
-        location  = "#{request['host'].scheme}://#{request['host'].host}"
-        location << ":#{request['host'].port}" if request['host'].port
-        location << request['path']
+        scheme = (secure ? "wss" : "ws")
+        location = "#{scheme}://#{headers['host']}#{path}"
 
         upgrade =  "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
         upgrade << "Upgrade: WebSocket\r\n"
         upgrade << "Connection: Upgrade\r\n"
         upgrade << "Sec-WebSocket-Location: #{location}\r\n"
-        upgrade << "Sec-WebSocket-Origin: #{request['origin']}\r\n"
-        if protocol = request['sec-websocket-protocol']
+        upgrade << "Sec-WebSocket-Origin: #{headers['origin']}\r\n"
+        if protocol = headers['sec-websocket-protocol']
           validate_protocol!(protocol)
           upgrade << "Sec-WebSocket-Protocol: #{protocol}\r\n"
         end
         upgrade << "\r\n"
         upgrade << challenge_response
 
-        debug [:upgrade_headers, upgrade]
-
         return upgrade
       end
 

data/lib/em-websocket/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   module Websocket
-    VERSION = "0.3.8"
+    VERSION = "0.4.0"
   end
 end

data/lib/em-websocket/websocket.rb

@@ -1,16 +1,18 @@
 module EventMachine
   module WebSocket
+    class << self
+      attr_accessor :max_frame_size
+    end
+    @max_frame_size = 10 * 1024 * 1024 # 10MB
+
     # All errors raised by em-websocket should descend from this class
-    #
     class WebSocketError < RuntimeError; end
 
     # Used for errors that occur during WebSocket handshake
-    #
     class HandshakeError < WebSocketError; end
 
     # Used for errors which should cause the connection to close.
     # See RFC6455 §7.4.1 for a full description of meanings
-    #
     class WSProtocolError < WebSocketError
       def code; 1002; end
     end
@@ -20,28 +22,28 @@ module EventMachine
       def code; 1009; end
     end
 
+    # Start WebSocket server, including starting eventmachine run loop
     def self.start(options, &blk)
       EM.epoll
-      EM.run do
-
+      EM.run {
         trap("TERM") { stop }
         trap("INT")  { stop }
 
-        EventMachine::start_server(options[:host], options[:port],
-          EventMachine::WebSocket::Connection, options) do |c|
-          blk.call(c)
-        end
+        run(options, &blk)
+      }
+    end
+
+    # Start WebSocket server inside eventmachine run loop
+    def self.run(options)
+      host, port = options.values_at(:host, :port)
+      EM.start_server(host, port, Connection, options) do |c|
+        yield c
       end
     end
 
     def self.stop
       puts "Terminating WebSocket Server"
-      EventMachine.stop
-    end
-
-    class << self
-      attr_accessor :max_frame_size
+      EM.stop
     end
-    @max_frame_size = 10 * 1024 * 1024 # 10MB
   end
 end

data/spec/helper.rb

@@ -103,7 +103,10 @@ class Draft75WebSocketClient
   def onmessage(&blk);  @onmessage = blk; end
 
   def initialize
-    @ws = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
+    @ws = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get({
+      :timeout => 0,
+      :origin => 'http://example.com',
+    })
     @ws.errback { @onerror.call if @onerror }
     @ws.callback { @onopen.call if @onopen }
     @ws.stream { |msg| @onmessage.call(msg) if @onmessage }
@@ -133,8 +136,23 @@ def format_response(r)
   data
 end
 
-RSpec::Matchers.define :send_handshake do |response|
+RSpec::Matchers.define :succeed_with_upgrade do |response|
   match do |actual|
-    actual.handshake.lines.sort == format_response(response).lines.sort
+    success = nil
+    actual.callback { |upgrade_response, handler_klass|
+      success = (upgrade_response.lines.sort == format_response(response).lines.sort)
+    }
+    success
+  end
+end
+
+RSpec::Matchers.define :fail_with_error do |error_klass, error_message|
+  match do |actual|
+    success = nil
+    actual.errback { |e|
+      success = (e.class == error_klass)
+      success &= (e.message == error_message) if error_message
+    }
+    success
   end
 end

data/spec/integration/common_spec.rb

@@ -1,27 +1,27 @@
 require 'helper'
 
 # These tests are not specific to any particular draft of the specification
-# 
+#
 describe "WebSocket server" do
   include EM::SpecHelper
   default_timeout 1
 
   it "should fail on non WebSocket requests" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
+      EM.add_timer(0.1) do
+        http = EM::HttpRequest.new('http://127.0.0.1:12345/').get :timeout => 0
         http.errback { done }
         http.callback { fail }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
+      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) {}
     }
   end
-  
-  it "should populate ws.request with appropriate headers" do
+
+  it "should expose the WebSocket request headers, path and query params" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
+      EM.add_timer(0.1) do
+        http = EM::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
         http.errback { fail }
         http.callback {
           http.response_header.status.should == 101
@@ -30,27 +30,32 @@ describe "WebSocket server" do
         http.stream { |msg| }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-        ws.onopen {
-          ws.request["user-agent"].should == "EventMachine HttpClient"
-          ws.request["connection"].should == "Upgrade"
-          ws.request["upgrade"].should == "WebSocket"
-          ws.request["path"].should == "/"
-          ws.request["origin"].should == "127.0.0.1"
-          ws.request["host"].to_s.should == "ws://127.0.0.1:12345"
+      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
+        ws.onopen { |handshake|
+          headers = handshake.headers
+          headers["User-Agent"].should == "EventMachine HttpClient"
+          headers["Connection"].should == "Upgrade"
+          headers["Upgrade"].should == "WebSocket"
+          headers["Host"].to_s.should == "127.0.0.1:12345"
+          handshake.path.should == "/"
+          handshake.query.should == {}
+          handshake.origin.should == "127.0.0.1"
         }
         ws.onclose {
           ws.state.should == :closed
-          EventMachine.stop
+          done
         }
       end
     }
   end
-  
-  it "should allow sending and retrieving query string args passed in on the connection request." do
+
+  it "should expose the WebSocket path and query params when nonempty" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:query => {'foo' => 'bar', 'baz' => 'qux'}, :timeout => 0)
+      EM.add_timer(0.1) do
+        http = EM::HttpRequest.new('ws://127.0.0.1:12345/hello').get({
+          :query => {'foo' => 'bar', 'baz' => 'qux'},
+          :timeout => 0
+        })
         http.errback { fail }
         http.callback {
           http.response_header.status.should == 101
@@ -59,26 +64,41 @@ describe "WebSocket server" do
         http.stream { |msg| }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-        ws.onopen {
-          path, query = ws.request["path"].split('?')
-          path.should == '/'
-          Hash[*query.split(/&|=/)].should == {"foo"=>"bar", "baz"=>"qux"}
-          ws.request["query"]["foo"].should == "bar"
-          ws.request["query"]["baz"].should == "qux"
+      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
+        ws.onopen { |handshake|
+          handshake.path.should == '/hello'
+          handshake.query_string.split('&').sort.
+            should == ["baz=qux", "foo=bar"]
+          handshake.query.should == {"foo"=>"bar", "baz"=>"qux"}
         }
         ws.onclose {
           ws.state.should == :closed
-          EventMachine.stop
+          done
         }
       end
     }
   end
-  
-  it "should ws.response['Query'] to empty hash when no query string params passed in connection URI" do
+
+  it "should raise an exception if frame sent before handshake complete" do
     em {
-      EventMachine.add_timer(0.1) do
-        http = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
+      # 1. Start WebSocket server
+      EM::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+        # 3. Try to send a message to the socket
+        lambda {
+          ws.send('early message')
+        }.should raise_error('Cannot send data before onopen callback')
+        done
+      }
+
+      # 2. Connect a dumb TCP connection (will not send handshake)
+      EM.connect('0.0.0.0', 12345, EM::Connection)
+    }
+  end
+
+  it "should allow the server to be started inside an existing EM" do
+    em {
+      EM.add_timer(0.1) do
+        http = EM::HttpRequest.new('ws://127.0.0.1:12345/').get :timeout => 0
         http.errback { fail }
         http.callback {
           http.response_header.status.should == 101
@@ -87,32 +107,15 @@ describe "WebSocket server" do
         http.stream { |msg| }
       end
 
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) do |ws|
-        ws.onopen {
-          ws.request["path"].should == "/"
-          ws.request["query"].should == {}
+      EM::WebSocket.run(:host => "0.0.0.0", :port => 12345) do |ws|
+        ws.onopen { |handshake|
+          handshake.headers["User-Agent"].should == "EventMachine HttpClient"
         }
         ws.onclose {
           ws.state.should == :closed
-          EventMachine.stop
-        }
-      end
-    }
-  end
-  
-  it "should raise an exception if frame sent before handshake complete" do
-    em {
-      EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |c|
-        # We're not using a real client so the handshake will not be sent
-        EM.add_timer(0.1) {
-          lambda {
-            c.send('early message')
-          }.should raise_error('Cannot send data before onopen callback')
           done
         }
-      }
-
-      client = EM.connect('0.0.0.0', 12345, EM::Connection)
+      end
     }
   end
 end