em-websocket 0.0.6 → 0.1.1

data/VERSION

@@ -1 +1 @@
-0.0.6
+0.1.1

data/examples/multicast.rb

@@ -25,19 +25,21 @@ EventMachine.run {
 
 
   EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080, :debug => true) do |ws|
+
     ws.onopen {
-      @sid = @channel.subscribe { |msg| ws.send msg }
-      @channel.push "#{@sid} connected!"
-    }
+      sid = @channel.subscribe { |msg| ws.send msg }
+      @channel.push "#{sid} connected!"
 
-    ws.onmessage { |msg|
-      @channel.push "<#{@sid}>: #{msg}"
-    }
+      ws.onmessage { |msg|
+        @channel.push "<#{sid}>: #{msg}"
+      }
+
+      ws.onclose {
+        @channel.unsubscribe(sid)
+      }
 
-    ws.onclose {
-      @channel.unsubscribe(@sid)
     }
   end
 
   puts "Server started"
-}
+}

data/lib/em-websocket.rb

@@ -3,6 +3,6 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 #require "rubygems"
 require "eventmachine"
 
-%w[ websocket connection ].each do |file|
+%w[ debugger websocket connection handler_factory handler handler75 handler76 ].each do |file|
   require "em-websocket/#{file}"
 end

data/lib/em-websocket/connection.rb

@@ -3,9 +3,7 @@ require 'addressable/uri'
 module EventMachine
   module WebSocket
     class Connection < EventMachine::Connection
-
-      PATH   = /^GET (\/[^\s]*) HTTP\/1\.1$/
-      HEADER = /^([^:]+):\s*([^$]+)/
+      include Debugger
 
       attr_reader :state, :request
 
@@ -17,14 +15,18 @@ module EventMachine
       def initialize(options)
         @options = options
         @debug = options[:debug] || false
+        @secure = options[:secure] || false
         @state = :handshake
         @request = {}
         @data = ''
-        @skip_onclose = false
 
         debug [:initialize]
       end
 
+      def post_init
+        start_tls if @secure
+      end
+
       def receive_data(data)
         debug [:receive_data, data]
 
@@ -40,58 +42,36 @@ module EventMachine
       end
 
       def dispatch
-        while case @state
+        case @state
           when :handshake
-            new_request
-          when :upgrade
-            send_upgrade
+            handshake
           when :connected
             process_message
           else raise RuntimeError, "invalid state: #{@state}"
-          end
         end
       end
 
-      def new_request
-        if @data.match(/\r\n\r\n$/)
+      def handshake
+        if @data.match(/<policy-file-request\s*\/>/)
+          send_flash_cross_domain_file
+          return false
+        else
           debug [:inbound_headers, @data]
-          lines = @data.split("\r\n")
-
           begin
-            # extract request path
-            @request['Path'] = lines.shift.match(PATH)[1].strip
-
-            # extract query string values
-            @request['Query'] = Addressable::URI.parse(@request['Path']).query_values ||= {}
-
-            # extract remaining headers
-            lines.each do |line|
-              h = HEADER.match(line)
-              @request[h[1].strip] = h[2].strip
-            end
-
-            # transform headers
-            @request['Host'] = Addressable::URI.parse("ws://"+@request['Host'])
-
-            if not websocket_connection?
-              process_bad_request
-              return false
-            else
-              @data = ''
-              @state = :upgrade
-              return true
-            end
+            @handler = HandlerFactory.build(@data, @secure, @debug)
+            @data = ''
+            send_data @handler.handshake
+
+            @request = @handler.request
+            @state = :connected
+            @onopen.call if @onopen
+            return true
           rescue => e
             debug [:error, e]
             process_bad_request
             return false
           end
-        elsif @data.match(/<policy-file-request\s*\/>/)
-          send_flash_cross_domain_file
-          return false
         end
-
-        false
       end
 
       def process_bad_request
@@ -99,53 +79,76 @@ module EventMachine
         close_connection_after_writing
       end
 
-      def websocket_connection?
-        @request['Connection'] == 'Upgrade' and @request['Upgrade'] == 'WebSocket'
-      end
-
-      def send_upgrade
-        location  = "ws://#{@request['Host'].host}"
-        location << ":#{@request['Host'].port}" if @request['Host'].port
-        location << @request['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-Location: #{location}\r\n\r\n"
-
-        # upgrade connection and notify client callback
-        # about completed handshake
-        debug [:upgrade_headers, upgrade]
-        send_data upgrade
-
-        @state = :connected
-        @onopen.call if @onopen
-
-        # stop dispatch, wait for messages
-        false
-      end
-
       def send_flash_cross_domain_file
         file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
         debug [:cross_domain, file]
         send_data file
 
         # handle the cross-domain request transparently
-        # no need to notif the user about this connection
+        # no need to notify the user about this connection
         @onclose = nil
         close_connection_after_writing
       end
 
       def process_message
-        return if not @onmessage
         debug [:message, @data]
 
-        # slice the message out of the buffer and pass in
-        # for processing, and buffer data otherwise
-        while msg = @data.slice!(/\000([^\377]*)\377/)
-          msg.gsub!(/^\x00|\xff$/, '')
-          @onmessage.call(msg)
+        # This algorithm comes straight from the spec
+        # http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76#section-4.2
+
+        error = false
+
+        while !error
+          pointer = 0
+          frame_type = @data[pointer].to_i
+          pointer += 1
+
+          if (frame_type & 0x80) == 0x80
+            # If the high-order bit of the /frame type/ byte is set
+            length = 0
+
+            loop do
+              b = @data[pointer].to_i
+              return false unless b
+              pointer += 1
+              b_v = b & 0x7F
+              length = length * 128 + b_v
+              break unless (b & 0x80) == 0x80
+            end
+
+            if @data[pointer+length-1] == nil
+              debug [:buffer_incomplete, @data.inspect]
+              # Incomplete data - leave @data to accumulate
+              error = true
+            else
+              # Straight from spec - I'm sure this isn't crazy...
+              # 6. Read /length/ bytes.
+              # 7. Discard the read bytes.
+              @data = @data[(pointer+length)..-1]
+
+              # If the /frame type/ is 0xFF and the /length/ was 0, then close
+              if length == 0
+                send_data("\xff\x00")
+                @state = :closing
+                close_connection_after_writing
+              else
+                error = true
+              end
+            end
+          else
+            # If the high-order bit of the /frame type/ byte is _not_ set
+            msg = @data.slice!(/^\x00([^\xff]*)\xff/)
+            if msg
+              msg.gsub!(/^\x00|\xff$/, '')
+              if @state == :closing
+                debug [:ignored_message, msg]
+              else
+                @onmessage.call(msg) if @onmessage
+              end
+            else
+              error = true
+            end
+          end
         end
 
         false
@@ -162,16 +165,6 @@ module EventMachine
         debug [:send, data]
         send_data("\x00#{data}\xff")
       end
-
-      private
-
-      def debug(*data)
-        if @debug
-          require 'pp'
-          pp data
-          puts
-        end
-      end
     end
   end
 end

data/lib/em-websocket/debugger.rb

@@ -0,0 +1,17 @@
+module EventMachine
+  module WebSocket
+    module Debugger
+
+      private
+
+      def debug(*data)
+        if @debug
+          require 'pp'
+          pp data
+          puts
+        end
+      end
+
+    end
+  end
+end

data/lib/em-websocket/handler.rb

@@ -0,0 +1,21 @@
+module EventMachine
+  module WebSocket
+    class HandshakeError < RuntimeError; end
+
+    class Handler
+      include Debugger
+
+      attr_reader :request
+
+      def initialize(request, response, debug = false)
+        @request = request
+        @response = response
+        @debug = debug
+      end
+
+      def handshake
+        # Implemented in subclass
+      end
+    end
+  end
+end

data/lib/em-websocket/handler75.rb

@@ -0,0 +1,21 @@
+module EventMachine
+  module WebSocket
+    class Handler75 < Handler
+      def handshake
+        location  = "#{@request['Host'].scheme}://#{@request['Host'].host}"
+        location << ":#{@request['Host'].port}" if @request['Host'].port
+        location << @request['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-Location: #{location}\r\n\r\n"
+
+        debug [:upgrade_headers, upgrade]
+
+        return upgrade
+      end
+    end
+  end
+end

data/lib/em-websocket/handler76.rb

@@ -0,0 +1,61 @@
+require 'digest/md5'
+
+module EventMachine
+  module WebSocket
+    class Handler76 < Handler
+      # "\377\000" is octet version and "\xff\x00" is hex version
+      TERMINATE_STRING = "\xff\x00"
+
+      def handshake
+        challenge_response = solve_challange(
+          @request['Sec-WebSocket-Key1'],
+          @request['Sec-WebSocket-Key2'],
+          @request['Third-Key']
+        )
+
+        location  = "#{@request['Host'].scheme}://#{@request['Host'].host}"
+        location << ":#{@request['Host'].port}" if @request['Host'].port
+        location << @request['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']
+          validate_protocol!(protocol)
+          upgrade << "Sec-WebSocket-Protocol: #{protocol}\r\n"
+        end
+        upgrade << "\r\n"
+        upgrade << challenge_response
+
+        debug [:upgrade_headers, upgrade]
+
+        return upgrade
+      end
+
+      private
+
+      def solve_challange(first, second, third)
+        # Refer to 5.2 4-9 of the draft 76
+        sum = [(extract_nums(first) / count_spaces(first))].pack("N*") +
+          [(extract_nums(second) / count_spaces(second))].pack("N*") +
+          third
+        Digest::MD5.digest(sum)
+      end
+
+      def extract_nums(string)
+        string.scan(/[0-9]/).join.to_i
+      end
+
+      def count_spaces(string)
+        string.scan(/ /).size
+      end
+
+      def validate_protocol!(protocol)
+        raise HandshakeError, "Invalid WebSocket-Protocol: empty" if protocol.empty?
+        # TODO: Validate characters
+      end
+    end
+  end
+end

data/lib/em-websocket/handler_factory.rb

@@ -0,0 +1,52 @@
+module EventMachine
+  module WebSocket
+    class HandlerFactory
+      PATH   = /^(\w+) (\/[^\s]*) HTTP\/1\.1$/
+      HEADER = /^([^:]+):\s*([^$]+)/
+
+      def self.build(data, secure = false, debug = false)
+        request = {}
+        response = nil
+
+        lines = data.split("\r\n")
+
+        # extract request path
+        first_line = lines.shift.match(PATH)
+        request['Method'] = first_line[1].strip
+        request['Path'] = first_line[2].strip
+
+        unless request["Method"] == "GET"
+          raise HandshakeError, "Must be GET request"
+        end
+
+        # extract query string values
+        request['Query'] = Addressable::URI.parse(request['Path']).query_values ||= {}
+        # extract remaining headers
+        lines.each do |line|
+          h = HEADER.match(line)
+          request[h[1].strip] = h[2].strip if h
+        end
+        request['Third-Key'] = lines.last
+
+        unless request['Connection'] == 'Upgrade' and request['Upgrade'] == 'WebSocket'
+          raise HandshakeError, "Connection and Upgrade headers required"
+        end
+
+        # transform headers
+        protocol = (secure ? "wss" : "ws")
+        request['Host'] = Addressable::URI.parse("#{protocol}://"+request['Host'])
+
+        version = request['Sec-WebSocket-Key1'] ? 76 : 75
+
+        case version
+        when 75
+          Handler75.new(request, response, debug)
+        when 76
+          Handler76.new(request, response, debug)
+        else
+          raise "Must not happen"
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/websocket.rb

@@ -20,4 +20,4 @@ module EventMachine
       EventMachine.stop
     end
   end
-end
+end

data/spec/helper.rb

@@ -3,4 +3,63 @@ require 'spec'
 require 'pp'
 require 'em-http'
 
-require 'lib/em-websocket'
+require 'lib/em-websocket'
+
+class FakeWebSocketClient < EM::Connection
+  attr_writer :onopen, :onclose, :onmessage
+  attr_reader :handshake_response, :packets
+
+  def initialize
+    @state = :new
+    @packets = []
+  end
+
+  def receive_data(data)
+    # puts "RECEIVE DATA #{data}"
+    if @state == :new
+      @handshake_response = data
+      @onopen.call if @onopen
+      @state = :open
+    else
+      @onmessage.call if @onmessage
+      @packets << data
+    end
+  end
+
+  def send(data)
+    send_data("\x00#{data}\xff")
+  end
+
+  def unbind
+    @onclose.call if @onclose
+  end
+end
+
+def failed
+  EventMachine.stop
+  fail
+end
+
+def format_request(r)
+  data = "#{r[:method]} #{r[:path]} HTTP/1.1\r\n"
+  header_lines = r[:headers].map { |k,v| "#{k}: #{v}" }
+  data << [header_lines, '', r[:body]].join("\r\n")
+  data
+end
+
+def format_response(r)
+  data = "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+  header_lines = r[:headers].map { |k,v| "#{k}: #{v}" }
+  data << [header_lines, '', r[:body]].join("\r\n")
+  data
+end
+
+def handler(request, secure = false)
+  EM::WebSocket::HandlerFactory.build(format_request(request), secure)
+end
+
+def send_handshake(response)
+  simple_matcher do |given|
+    given.handshake.lines.sort == format_response(response).lines.sort
+  end
+end

data/spec/integration/integration_spec.rb

@@ -0,0 +1,102 @@
+require 'spec/helper'
+
+describe "WebSocket server draft76" do
+  before :each do
+    @request = {
+      :port => 80,
+      :method => "GET",
+      :path => "/demo",
+      :headers => {
+        'Host' => 'example.com',
+        'Connection' => 'Upgrade',
+        'Sec-WebSocket-Key2' => '12998 5 Y3 1  .P00',
+        'Sec-WebSocket-Protocol' => 'sample',
+        'Upgrade' => 'WebSocket',
+        'Sec-WebSocket-Key1' => '4 @1  46546xW%0l 1 5',
+        'Origin' => 'http://example.com'
+      },
+      :body => '^n:ds[4U'
+    }
+
+    @response = {
+      :headers => {
+        "Upgrade" => "WebSocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Location" => "ws://example.com/demo",
+        "Sec-WebSocket-Origin" => "http://example.com",
+        "Sec-WebSocket-Protocol" => "sample"
+      },
+      :body => "8jKS\'y:G*Co,Wxa-"
+    }
+  end
+  
+  it "should send back the correct handshake response" do
+    EM.run do
+      EM.add_timer(0.1) do
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { }
+        
+        # Create a fake client which sends draft 76 handshake
+        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
+        connection.send_data(format_request(@request))
+        
+        connection.onopen = lambda {
+          connection.handshake_response.lines.sort.
+            should == format_response(@response).lines.sort
+          EM.stop
+        }
+      end
+    end
+  end
+  
+  it "should send closing frame back and close the connection after recieving closing frame" do
+    EM.run do
+      EM.add_timer(0.1) do
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { }
+  
+        # Create a fake client which sends draft 76 handshake
+        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
+        connection.send_data(format_request(@request))
+  
+        # Send closing frame after handshake complete
+        connection.onopen = lambda {
+          connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
+        }
+  
+        # Check that this causes a termination string to be returned and the 
+        # connection close
+        connection.onclose = lambda {
+          connection.packets[0].should == 
+            EM::WebSocket::Handler76::TERMINATE_STRING
+          EM.stop
+        }
+      end
+    end
+  end
+  
+  it "should ignore any data received after the closing frame" do
+    EM.run do
+      EM.add_timer(0.1) do
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 12345) { |ws|
+          # Fail if foobar message is received
+          ws.onmessage { |msg|
+            failed
+          }
+        }
+        
+        # Create a fake client which sends draft 76 handshake
+        connection = EM.connect('0.0.0.0', 12345, FakeWebSocketClient)
+        connection.send_data(format_request(@request))
+  
+        # Send closing frame after handshake complete, followed by another msg
+        connection.onopen = lambda {
+          connection.send_data(EM::WebSocket::Handler76::TERMINATE_STRING)
+          connection.send('foobar')
+        }
+  
+        connection.onclose = lambda {
+          EM.stop
+        }
+      end
+    end
+  end
+end

data/spec/unit/handler_spec.rb

@@ -0,0 +1,117 @@
+require 'spec/helper'
+
+describe "EventMachine::WebSocket::Handler" do
+  before :each do
+    @request = {
+      :port => 80,
+      :method => "GET",
+      :path => "/demo",
+      :headers => {
+        'Host' => 'example.com',
+        'Connection' => 'Upgrade',
+        'Sec-WebSocket-Key2' => '12998 5 Y3 1  .P00',
+        'Sec-WebSocket-Protocol' => 'sample',
+        'Upgrade' => 'WebSocket',
+        'Sec-WebSocket-Key1' => '4 @1  46546xW%0l 1 5',
+        'Origin' => 'http://example.com'
+      },
+      :body => '^n:ds[4U'
+    }
+    @secure_request = @request.merge(:port => 443)
+
+    @response = {
+      :headers => {
+        "Upgrade" => "WebSocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Location" => "ws://example.com/demo",
+        "Sec-WebSocket-Origin" => "http://example.com",
+        "Sec-WebSocket-Protocol" => "sample"
+      },
+      :body => "8jKS\'y:G*Co,Wxa-"
+    }
+    @secure_response = @response.merge(:headers => @response[:headers].merge('Sec-WebSocket-Location' => "wss://example.com/demo"))
+  end
+
+  it "should handle good request" do
+    handler(@request).should send_handshake(@response)
+  end
+
+  it "should handle good request to secure default port if secure mode is enabled" do
+    handler(@secure_request, true).should send_handshake(@secure_response)
+  end
+
+  it "should not handle good request to secure default port if secure mode is disabled" do
+    handler(@secure_request, false).should_not send_handshake(@secure_response)
+  end
+
+  it "should handle good request on nondefault port" do
+    @request[:port] = 8081
+    @request[:headers]['Host'] = 'example.com:8081'
+    @response[:headers]['Sec-WebSocket-Location'] =
+      'ws://example.com:8081/demo'
+
+    handler(@request).should send_handshake(@response)
+  end
+
+  it "should handle good request to secure nondefault port" do
+    @secure_request[:port] = 8081
+    @secure_request[:headers]['Host'] = 'example.com:8081'
+    @secure_response[:headers]['Sec-WebSocket-Location'] = 'wss://example.com:8081/demo'
+    handler(@secure_request, true).should send_handshake(@secure_response)
+  end
+
+  it "should handle good request with no protocol" do
+    @request[:headers].delete('Sec-WebSocket-Protocol')
+    @response[:headers].delete("Sec-WebSocket-Protocol")
+
+    handler(@request).should send_handshake(@response)
+  end
+
+  it "should handle extra headers by simply ignoring them" do
+    @request[:headers]['EmptyValue'] = ""
+    @request[:headers]['AKey'] = "AValue"
+
+    handler(@request).should send_handshake(@response)
+  end
+  
+  it "should raise error on HTTP request" do
+    @request[:headers] = {
+      'Host' => 'www.google.com',
+      'User-Agent' => 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1.3) Gecko/20090824 Firefox/3.5.3 GTB6 GTBA',
+      'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'Accept-Language' => 'en-us,en;q=0.5',
+      'Accept-Encoding' => 'gzip,deflate',
+      'Accept-Charset' => 'ISO-8859-1,utf-8;q=0.7,*;q=0.7',
+      'Keep-Alive' => '300',
+      'Connection' => 'keep-alive',
+    }
+    
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  it "should raise error on wrong method" do
+    @request[:method] = 'POST'
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  it "should raise error if upgrade header incorrect" do
+    @request[:headers]['Upgrade'] = 'NonWebSocket'
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+
+  it "should raise error if Sec-WebSocket-Protocol is empty" do
+    @request[:headers]['Sec-WebSocket-Protocol'] = ''
+
+    lambda {
+      handler(@request).handshake
+    }.should raise_error(EM::WebSocket::HandshakeError)
+  end
+end

data/spec/websocket_spec.rb

@@ -2,11 +2,6 @@ require 'spec/helper'
 
 describe EventMachine::WebSocket do
 
-  def failed
-    EventMachine.stop
-    fail
-  end
-
   it "should automatically complete WebSocket handshake" do
     EM.run do
       MSG = "Hello World!"

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 6
-  version: 0.0.6
+  - 1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Ilya Grigorik
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-18 00:00:00 -04:00
+date: 2010-06-13 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -72,6 +72,7 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- em-websocket.gemspec
 - examples/echo.rb
 - examples/js/FABridge.js
 - examples/js/WebSocketMain.swf
@@ -81,8 +82,15 @@ files:
 - examples/test.html
 - lib/em-websocket.rb
 - lib/em-websocket/connection.rb
+- lib/em-websocket/debugger.rb
+- lib/em-websocket/handler.rb
+- lib/em-websocket/handler75.rb
+- lib/em-websocket/handler76.rb
+- lib/em-websocket/handler_factory.rb
 - lib/em-websocket/websocket.rb
 - spec/helper.rb
+- spec/integration/integration_spec.rb
+- spec/unit/handler_spec.rb
 - spec/websocket_spec.rb
 has_rdoc: true
 homepage: http://github.com/igrigorik/em-websocket
@@ -116,6 +124,8 @@ specification_version: 3
 summary: EventMachine based WebSocket server
 test_files: 
 - spec/helper.rb
+- spec/integration/integration_spec.rb
+- spec/unit/handler_spec.rb
 - spec/websocket_spec.rb
 - examples/echo.rb
 - examples/multicast.rb