sonixlabs-em-websocket 0.3.7

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/handler07.rb

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

data/lib/em-websocket/handler08.rb

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

data/lib/em-websocket/handler13.rb

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

data/lib/em-websocket/handler75.rb

@@ -0,0 +1,9 @@
+module EventMachine
+  module WebSocket
+    class Handler75 < Handler
+      include Handshake75
+      include Framing76
+      include Close75
+    end
+  end
+end

data/lib/em-websocket/handler76.rb

@@ -0,0 +1,12 @@
+module EventMachine
+  module WebSocket
+    class Handler76 < Handler
+      include Handshake76
+      include Framing76
+      include Close75
+
+      # "\377\000" is octet version and "\xff\x00" is hex version
+      TERMINATE_STRING = "\xff\x00"
+    end
+  end
+end

data/lib/em-websocket/handler_factory.rb

@@ -0,0 +1,107 @@
+module EventMachine
+  module WebSocket
+    class HandlerFactory
+      PATH   = /^(\w+) (\/[^\s]*) HTTP\/1\.1$/
+      HEADER = /^([^:]+):\s*(.+)$/
+
+      def self.build(connection, data, secure = false, debug = false)
+        (header, remains) = data.split("\r\n\r\n", 2)
+        unless remains
+          # The whole header has not been received yet.
+          return nil
+        end
+
+        request = {}
+
+        lines = header.split("\r\n")
+
+        # 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
+
+        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.downcase] = h[2].strip if h
+        end
+
+        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, 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
+        end
+
+        # 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'])
+
+        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)
+        when 7
+          Handler07.new(connection, request, debug)
+        when 8
+          # drafts 9, 10, 11 and 12 should never change the version
+          # number as they are all the same as version 08.
+          Handler08.new(connection, request, debug)
+        when 13
+          # drafts 13 to 17 all identify as version 13 as they are
+          # only minor changes or text changes.
+          Handler13.new(connection, request, debug)
+        else
+          # According to spec should abort the connection
+          raise WebSocketError, "Protocol version #{version} not supported"
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/handshake04.rb

@@ -0,0 +1,75 @@
+require 'digest/sha1'
+require 'base64'
+
+module EventMachine
+  module WebSocket
+    module Handshake04
+
+      def handshake_key_response(key)
+        string_to_sign = "#{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+        Base64.encode64(Digest::SHA1.digest(string_to_sign)).chomp
+      end
+
+      def handshake_server
+        # 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']
+        
+        upgrade = ["HTTP/1.1 101 Switching Protocols"]
+        upgrade << "Upgrade: websocket"
+        upgrade << "Connection: Upgrade"
+        upgrade << "Sec-WebSocket-Accept: #{handshake_key_response(key)}"
+        
+        # TODO: Support Sec-WebSocket-Protocol
+        # TODO: Sec-WebSocket-Extensions
+        
+        [:upgrade_headers, upgrade]
+        
+        return upgrade.join("\r\n") + "\r\n\r\n"
+      end
+
+      def handshake_client
+        request = ["GET /websocket HTTP/1.1"]
+        request << "Host: #{@request[:host]}:#{@request[:port]}"
+        request << "Connection: keep-alive, Upgrade"
+        request << "Sec-WebSocket-Version: 8" # TODO: supply version somehow
+        request << "Sec-WebSocket-Origin: null"
+        random16 = (0...16).map{rand(255).chr}.join
+        random16_base64 = Base64.encode64(random16).chomp
+        @correct_response = handshake_key_response random16_base64
+        request << "Sec-WebSocket-Key: #{random16_base64}"
+        request << "Upgrade: websocket"
+        # TODO: anything else needed?  nothing else parsed anyway
+        return request.join("\r\n") + "\r\n\r\n"
+      end
+
+      def client_handle_server_handshake_response(data)
+        header, msg = data.split "\r\n\r\n"
+        lines = header.split("\r\n")
+        accept = false
+        lines.each do |line|
+          h = /^([^:]+):\s*(.+)$/.match(line)
+          if !h.nil? and h[1].strip.downcase == "sec-websocket-accept"
+            accept = (h[2] == @correct_response)
+            break
+          end
+        end
+        if accept
+          @state = :connected #TODO - some actual logic would be nice
+          @connection.trigger_on_open
+          if msg # handle message bundled in with handshake response
+            receive_data(msg)
+          end
+        else
+          close_websocket(1002,nil)
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/handshake75.rb

@@ -0,0 +1,21 @@
+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']
+
+        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/handshake76.rb

@@ -0,0 +1,71 @@
+require 'digest/md5'
+
+module EventMachine
+  module WebSocket
+    module Handshake76
+      def handshake
+        challenge_response = solve_challenge(
+          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_challenge(first, second, third)
+        # Refer to 5.2 4-9 of the draft 76
+        sum = [numbers_over_spaces(first)].pack("N*") +
+          [numbers_over_spaces(second)].pack("N*") +
+          third
+        Digest::MD5.digest(sum)
+      end
+
+      def numbers_over_spaces(string)
+        numbers = string.scan(/[0-9]/).join.to_i
+
+        spaces = string.scan(/ /).size
+        # As per 5.2.5, abort the connection if spaces are zero.
+        raise HandshakeError, "Websocket Key1 or Key2 does not contain spaces - this is a symptom of a cross-protocol attack" if spaces == 0
+
+        # As per 5.2.6, abort if numbers is not an integral multiple of spaces
+        if numbers % spaces != 0
+          raise HandshakeError, "Invalid Key #{string.inspect}"
+        end
+
+        quotient = numbers / spaces
+
+        if quotient > 2**32-1
+          raise HandshakeError, "Challenge computation out of range for key #{string.inspect}"
+        end
+
+        return quotient
+      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/masking04.rb

@@ -0,0 +1,63 @@
+module EventMachine
+  module WebSocket
+    class MaskedString < String
+      # Read a 4 bit XOR mask - further requested bytes will be unmasked
+      def read_mask
+        if respond_to?(:encoding) && encoding.name != "ASCII-8BIT"
+          raise "MaskedString only operates on BINARY strings"
+        end
+        raise "Too short" if bytesize < 4 # TODO - change
+        @masking_key = String.new(self[0..3])
+      end
+
+      def self.create_mask
+        MaskedString.new "rAnD" #TODO make random 4 character string
+      end
+
+      def self.create_masked_string(original)
+        masked_string = MaskedString.new
+        masking_key = self.create_mask
+        masked_string << masking_key
+        original.size.times do |i|
+          char = original.getbyte(i)
+          masked_string << (char ^ masking_key.getbyte(i%4))
+        end
+        if masked_string.respond_to?(:force_encoding)
+          masked_string.force_encoding("ASCII-8BIT")
+        end
+        masked_string.read_mask # get input string
+        return masked_string
+      end
+
+      # Removes the mask, behaves like a normal string again
+      def unset_mask
+        @masking_key = nil
+      end
+
+      def slice_mask
+        slice!(0, 4)
+      end
+
+      def getbyte(index)
+        if @masking_key
+          masked_char = super
+          masked_char ? masked_char ^ @masking_key.getbyte(index % 4) : nil
+        else
+          super
+        end
+      end
+
+      def getbytes(start_index, count)
+        data = ''
+        if @masking_key
+          count.times do |i|
+            data << getbyte(start_index + i)
+          end
+        else
+          data = String.new(self[start_index..start_index+count])
+        end
+        data
+      end
+    end
+  end
+end

data/lib/em-websocket/message_processor_03.rb

@@ -0,0 +1,38 @@
+# 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
+          if application_data.respond_to?(:force_encoding)
+            application_data.force_encoding("UTF-8")
+          end
+          @connection.trigger_on_message(application_data)
+        when :binary
+          @connection.trigger_on_message(application_data)
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/message_processor_06.rb

@@ -0,0 +1,52 @@
+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?
+          @connection.trigger_on_message(application_data, :pong)
+        when :text
+          if application_data.respond_to?(:force_encoding)
+            application_data.force_encoding("UTF-8")
+          end
+          @connection.trigger_on_message(application_data, :text)
+        when :binary
+          @connection.trigger_on_message(application_data, :binary)
+        end
+      end
+    end
+  end
+end

data/lib/em-websocket/version.rb

@@ -0,0 +1,5 @@
+module EventMachine
+  module Websocket
+    VERSION = "0.3.7"
+  end
+end

data/lib/em-websocket/websocket.rb

@@ -0,0 +1,45 @@
+module EventMachine
+  module WebSocket
+    class WebSocketError < RuntimeError; end
+    class HandshakeError < WebSocketError; end
+    class DataError < WebSocketError; end
+
+    #backwards compatibility
+    def self.start(options, &blk)
+      self.start_ws_server(options, &blk)
+    end
+
+    def self.start_ws_server(options, &blk)
+      EM.epoll
+      EM.run do
+
+        #trap("TERM") { stop; }
+        #trap("INT") { stop; }
+
+        EventMachine::start_server(options[:host], options[:port],
+          EventMachine::WebSocket::Connection, options) do |c|
+          blk.call(c)
+        end
+      end
+    end
+
+    def self.start_ws_client(options, &blk)
+      EM.epoll
+      EM.run do
+
+        #trap("TERM") { stop; raise "TERM" }
+        #trap("INT")  { stop; raise "INT" }
+
+        EM.connect(options[:host], options[:port],
+          EventMachine::WebSocket::ClientConnection, options) do |c|
+          blk.call(c)
+        end
+      end
+    end
+
+    def self.stop
+      puts "Terminating WebSocket Server"
+      EventMachine.stop
+    end
+  end
+end

data/lib/em-websocket.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require "eventmachine"
+
+%w[
+  debugger websocket connection client_connection
+  handshake75 handshake76 handshake04
+  framing76 framing03 framing04 framing05 framing07
+  close75 close03 close05 close06
+  masking04
+  message_processor_03 message_processor_06
+  handler_factory handler handler75 handler76 handler03 handler05 handler06 handler07 handler08 handler13
+].each do |file|
+  require "em-websocket/#{file}"
+end
+
+unless ''.respond_to?(:getbyte)
+  class String
+    def getbyte(i)
+      self[i]
+    end
+  end
+end

data/lib/sonixlabs-em-websocket.rb

@@ -0,0 +1 @@
+require "em-websocket"