em-websocket 0.2.1 → 0.3.0

data/lib/em-websocket/framing76.rb

@@ -42,12 +42,11 @@ module EventMachine
 
             # Addition to the spec to protect against malicious requests
             if length > MAXIMUM_FRAME_LENGTH
-              @connection.close_with_error(DataError.new("Frame length too long (#{length} bytes)"))
-              return false
+              raise DataError, "Frame length too long (#{length} bytes)"
             end
 
             if @data.getbyte(pointer+length-1) == nil
-              debug [:buffer_incomplete, @data.inspect]
+              debug [:buffer_incomplete, @data]
               # Incomplete data - leave @data to accumulate
               error = true
             else
@@ -70,13 +69,12 @@ module EventMachine
 
             if @data.getbyte(0) != 0x00
               # Close the connection since this buffer can never match
-              @connection.close_with_error(DataError.new("Invalid frame received"))
+              raise DataError, "Invalid frame received"
             end
 
             # Addition to the spec to protect against malicious requests
             if @data.size > MAXIMUM_FRAME_LENGTH
-              @connection.close_with_error(DataError.new("Frame length too long (#{@data.size} bytes)"))
-              return false
+              raise DataError, "Frame length too long (#{@data.size} bytes)"
             end
 
             # Optimization to avoid calling slice! unnecessarily
@@ -105,6 +103,7 @@ module EventMachine
       # byte to a value betweent 0x80 and 0xFF, followed by
       # a leading length indicator
       def send_text_frame(data)
+        debug [:sending_text_frame, data]
         ary = ["\x00", data, "\xff"]
         ary.collect{ |s| s.force_encoding('UTF-8') if s.respond_to?(:force_encoding) }
         @connection.send_data(ary.join)

data/lib/em-websocket/handler.rb

@@ -28,10 +28,8 @@ module EventMachine
         process_data(data)
       end
 
-      def close_websocket
-        # Unless redefined in a subclass, just close the connection
-        @state = :closed
-        @connection.close_connection_after_writing
+      def close_websocket(code, body)
+        # Implemented in subclass
       end
 
       def unbind

data/lib/em-websocket/handler03.rb

@@ -3,12 +3,8 @@ module EventMachine
     class Handler03 < Handler
       include Handshake76
       include Framing03
-
-      def close_websocket
-        # TODO: Should we send data and check the response matches?
-        send_frame(:close, '')
-        @state = :closing
-      end
+      include MessageProcessor03
+      include Close03
     end
   end
 end

data/lib/em-websocket/handler05.rb

@@ -0,0 +1,10 @@
+module EventMachine
+  module WebSocket
+    class Handler05 < Handler
+      include Handshake04
+      include Framing05
+      include MessageProcessor03
+      include Close05
+    end
+  end
+end

data/lib/em-websocket/handler06.rb

@@ -0,0 +1,10 @@
+module EventMachine
+  module WebSocket
+    class Handler06 < Handler
+      include Handshake04
+      include Framing05
+      include MessageProcessor06
+      include Close06
+    end
+  end
+end

data/lib/em-websocket/handler75.rb

@@ -3,6 +3,7 @@ module EventMachine
     class Handler75 < Handler
       include Handshake75
       include Framing76
+      include Close75
     end
   end
 end

data/lib/em-websocket/handler76.rb

@@ -3,6 +3,7 @@ module EventMachine
     class Handler76 < Handler
       include Handshake76
       include Framing76
+      include Close75
 
       # "\377\000" is octet version and "\xff\x00" is hex version
       TERMINATE_STRING = "\xff\x00"

data/lib/em-websocket/handler_factory.rb

@@ -18,59 +18,78 @@ module EventMachine
         # extract request path
         first_line = lines.shift.match(PATH)
         raise HandshakeError, "Invalid HTTP header" unless first_line
-        request['Method'] = first_line[1].strip
-        request['Path'] = first_line[2].strip
+        request['method'] = first_line[1].strip
+        request['path'] = first_line[2].strip
 
-        unless request["Method"] == "GET"
+        unless request["method"] == "GET"
           raise HandshakeError, "Must be GET request"
         end
 
         # extract query string values
-        request['Query'] = Addressable::URI.parse(request['Path']).query_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
+          request[h[1].strip.downcase] = h[2].strip if h
         end
 
-        version = request['Sec-WebSocket-Key1'] ? 76 : 75
+        build_with_request(connection, request, remains, secure, debug)
+      end
+
+      def self.build_with_request(connection, request, remains, secure = false, debug = false)
+        # Determine version heuristically
+        version = if request['sec-websocket-version']
+          # Used from drafts 04 onwards
+          request['sec-websocket-version'].to_i
+        elsif request['sec-websocket-draft']
+          # Used in drafts 01 - 03
+          request['sec-websocket-draft'].to_i
+        elsif request['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
+        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
-          request['Third-Key'] = remains
-        else
-          raise WebSocketError, "Must not happen"
+          request['third-key'] = remains
         end
 
-        unless request['Connection'] == 'Upgrade' and request['Upgrade'] == 'WebSocket'
+        # Validate that Connection and Upgrade headers
+        unless request['connection'] && request['connection'] =~ /Upgrade/ && request['upgrade'] && request['upgrade'].downcase == 'websocket'
           raise HandshakeError, "Connection and Upgrade headers required"
         end
 
         # transform headers
         protocol = (secure ? "wss" : "ws")
-        request['Host'] = Addressable::URI.parse("#{protocol}://"+request['Host'])
+        request['host'] = Addressable::URI.parse("#{protocol}://"+request['host'])
 
-        if version = request['Sec-WebSocket-Draft']
-          if version == '1' || version == '2' || version == '3'
-            # We'll use handler03 - I believe they're all compatible
-            Handler03.new(connection, request, debug)
-          else
-            # According to spec should abort the connection
-            raise WebSocketError, "Unknown draft version: #{version}"
-          end
-        elsif request['Sec-WebSocket-Key1']
+        case version
+        when 75
+          Handler75.new(connection, request, debug)
+        when 76
           Handler76.new(connection, request, debug)
+        when 1..3
+          # We'll use handler03 - I believe they're all compatible
+          Handler03.new(connection, request, debug)
+        when 5
+          Handler05.new(connection, request, debug)
+        when 6
+          Handler06.new(connection, request, debug)
         else
-          Handler75.new(connection, request, debug)
+          # According to spec should abort the connection
+          raise WebSocketError, "Protocol version #{version} not supported"
         end
       end
     end

data/lib/em-websocket/handshake04.rb

@@ -0,0 +1,35 @@
+require 'digest/sha1'
+require 'base64'
+
+module EventMachine
+  module WebSocket
+    module Handshake04
+      def handshake
+        # Required
+        unless key = request['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']
+        
+        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]
+        
+        return upgrade.join("\r\n") + "\r\n\r\n"
+      end
+    end
+  end
+end

data/lib/em-websocket/handshake75.rb

@@ -2,14 +2,14 @@ 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']
+        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-Origin: #{request['origin']}\r\n"
         upgrade << "WebSocket-Location: #{location}\r\n\r\n"
 
         debug [:upgrade_headers, upgrade]

data/lib/em-websocket/handshake76.rb

@@ -5,21 +5,21 @@ module EventMachine
     module Handshake76
       def handshake
         challenge_response = solve_challenge(
-          request['Sec-WebSocket-Key1'],
-          request['Sec-WebSocket-Key2'],
-          request['Third-Key']
+          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']
+        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']
+        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

data/lib/em-websocket/masking04.rb

@@ -0,0 +1,27 @@
+module EventMachine
+  module WebSocket
+    class MaskedString < String
+      def read_mask
+        raise "Too short" if bytesize < 4 # TODO - change
+        @masking_key = String.new(self[0..3])
+      end
+
+      def slice_mask
+        slice!(0, 4)
+      end
+
+      def getbyte(index)
+        masked_char = super(index + 4)
+        masked_char ? masked_char ^ @masking_key.getbyte(index % 4) : nil
+      end
+
+      def getbytes(start_index, count)
+        data = ''
+        count.times do |i|
+          data << getbyte(start_index + i)
+        end
+        data
+      end
+    end
+  end
+end

data/lib/em-websocket/message_processor_03.rb

@@ -0,0 +1,33 @@
+# encoding: BINARY
+
+module EventMachine
+  module WebSocket
+    module MessageProcessor03
+      def message(message_type, extension_data, application_data)
+        case message_type
+        when :close
+          if @state == :closing
+            # TODO: Check that message body matches sent data
+            # We can close connection immediately since there is no more data
+            # is allowed to be sent or received on this connection
+            @connection.close_connection
+            @state = :closed
+          else
+            # Acknowlege close
+            # The connection is considered closed
+            send_frame(:close, application_data)
+            @state = :closed
+            @connection.close_connection_after_writing
+          end
+        when :ping
+          # Pong back the same data
+          send_frame(:pong, application_data)
+        when :pong
+          # TODO: Do something. Complete a deferrable established by a ping?
+        when :text, :binary
+          @connection.trigger_on_message(application_data)
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/message_processor_06.rb

@@ -0,0 +1,46 @@
+module EventMachine
+  module WebSocket
+    module MessageProcessor06
+      def message(message_type, extension_data, application_data)
+        debug [:message_received, message_type, application_data]
+        
+        case message_type
+        when :close
+          status_code = case application_data.length
+          when 0
+            # close messages MAY contain a body
+            nil
+          when 1
+            # Illegal close frame
+            raise DataError, "Close frames with a body must contain a 2 byte status code"
+          else
+            application_data.slice!(0, 2).unpack('n').first
+          end
+          
+          debug [:close_frame_received, status_code, application_data]
+          
+          if @state == :closing
+            # We can close connection immediately since there is no more data
+            # is allowed to be sent or received on this connection
+            @connection.close_connection
+            @state = :closed
+          else
+            # Acknowlege close
+            # The connection is considered closed
+            send_frame(:close, '')
+            @state = :closed
+            @connection.close_connection_after_writing
+            # TODO: Send close status code and body to app code
+          end
+        when :ping
+          # Pong back the same data
+          send_frame(:pong, application_data)
+        when :pong
+          # TODO: Do something. Complete a deferrable established by a ping?
+        when :text, :binary
+          @connection.trigger_on_message(application_data)
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   module Websocket
-    VERSION = "0.2.1"
+    VERSION = "0.3.0"
   end
 end

data/spec/helper.rb

@@ -10,9 +10,13 @@ Rspec.configure do |c|
 end
 
 class FakeWebSocketClient < EM::Connection
-  attr_writer :onopen, :onclose, :onmessage
   attr_reader :handshake_response, :packets
 
+  def onopen(&blk);     @onopen = blk;    end
+  def onclose(&blk);    @onclose = blk;   end
+  def onerror(&blk);    @onerror = blk;   end
+  def onmessage(&blk);  @onmessage = blk; end
+
   def initialize
     @state = :new
     @packets = []
@@ -39,6 +43,54 @@ class FakeWebSocketClient < EM::Connection
   end
 end
 
+class Draft03FakeWebSocketClient < FakeWebSocketClient
+  def send(application_data)
+    frame = ''
+    opcode = 4 # fake only supports text frames
+    byte1 = opcode # since more, rsv1-3 are 0
+    frame << byte1
+
+    length = application_data.size
+    if length <= 125
+      byte2 = length # since rsv4 is 0
+      frame << byte2
+    elsif length < 65536 # write 2 byte length
+      frame << 126
+      frame << [length].pack('n')
+    else # write 8 byte length
+      frame << 127
+      frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+    end
+
+    frame << application_data
+
+    send_data(frame)
+  end
+end
+
+# Wrap EM:HttpRequest in a websocket like interface so that it can be used in the specs with the same interface as FakeWebSocketClient
+class Draft75WebSocketClient
+  def onopen(&blk);     @onopen = blk;    end
+  def onclose(&blk);    @onclose = blk;   end
+  def onerror(&blk);    @onerror = blk;   end
+  def onmessage(&blk);  @onmessage = blk; end
+
+  def initialize
+    @ws = EventMachine::HttpRequest.new('ws://127.0.0.1:12345/').get(:timeout => 0)
+    @ws.errback { @onerror.call if @onerror }
+    @ws.callback { @onopen.call if @onopen }
+    @ws.stream { |msg| @onmessage.call(msg) if @onmessage }
+  end
+
+  def send(message)
+    @ws.send(message)
+  end
+
+  def close_connection
+    @ws.close_connection
+  end
+end
+
 def failed
   EventMachine.stop
   fail
@@ -52,7 +104,7 @@ def format_request(r)
 end
 
 def format_response(r)
-  data = "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
+  data = r[:protocol] || "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