websocket 1.0.0

data/lib/websocket/handshake/handler/base.rb

@@ -0,0 +1,25 @@
+module WebSocket
+  module Handshake
+    module Handler
+      module Base
+
+        def to_s
+          result = [ header_line ]
+          handshake_keys.each do |key|
+            result << key.join(': ')
+          end
+          result << ""
+          result << finishing_line
+          result.join("\r\n")
+        end
+
+        private
+
+        def finishing_line
+          ""
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/client.rb

@@ -0,0 +1,19 @@
+module WebSocket
+  module Handshake
+    module Handler
+      module Client
+
+        include Base
+
+        private
+
+        def header_line
+          path = @path
+          path += "?" + @query if @query
+          "GET #{path} HTTP/1.1"
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/client01.rb

@@ -0,0 +1,19 @@
+require 'digest/md5'
+
+module WebSocket
+  module Handshake
+    module Handler
+      module Client01
+
+        include Client76
+
+        def handshake_keys
+          keys = super
+          keys << ['Sec-WebSocket-Draft', @version]
+          keys
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/client04.rb

@@ -0,0 +1,47 @@
+require 'digest/sha1'
+require 'base64'
+
+module WebSocket
+  module Handshake
+    module Handler
+      module Client04
+
+        include Client
+
+        def valid?
+          super && verify_accept
+        end
+
+        private
+
+        def handshake_keys
+          keys = [
+            ["Upgrade", "websocket"],
+            ["Connection", "Upgrade"]
+          ]
+          host = @host
+          host += ":#{@port}" if @port
+          keys << ["Host", host]
+          keys << ["Sec-WebSocket-Origin", @origin] if @origin
+          keys << ["Sec-WebSocket-Version", @version]
+          keys << ["Sec-WebSocket-Key", key]
+          keys
+        end
+
+        def key
+          @key ||= Base64.encode64((1..16).map { rand(255).chr } * '').strip
+        end
+
+        def accept
+          @accept ||= Base64.encode64(Digest::SHA1.digest(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')).strip
+        end
+
+        def verify_accept
+          set_error(:invalid_accept) and return false unless @headers['sec-websocket-accept'] == accept
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/client75.rb

@@ -0,0 +1,25 @@
+module WebSocket
+  module Handshake
+    module Handler
+      module Client75
+
+        include Client
+
+        private
+
+        def handshake_keys
+          keys = [
+            ["Upgrade", "WebSocket"],
+            ["Connection", "Upgrade"]
+          ]
+          host = @host
+          host += ":#{@port}" if @port
+          keys << ["Host", host]
+          keys << ["Origin", @origin] if @origin
+          keys
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/client76.rb

@@ -0,0 +1,85 @@
+require 'digest/md5'
+
+module WebSocket
+  module Handshake
+    module Handler
+      module Client76
+
+        include Client75
+
+        def key1
+          @key1 ||= generate_key(:key1)
+        end
+
+        def key2
+          @key2 ||= generate_key(:key2)
+        end
+
+        def key3
+          @key3 ||= generate_key3
+        end
+
+        def valid?
+          super && verify_challenge
+        end
+
+        private
+
+        def reserved_leftover_lines
+          1
+        end
+
+        def handshake_keys
+          keys = super
+          keys << ['Sec-WebSocket-Key1', key1]
+          keys << ['Sec-WebSocket-Key2', key2]
+          keys
+        end
+
+        def verify_challenge
+          set_error(:invalid_challenge) and return false unless @leftovers == challenge
+          true
+        end
+
+        def challenge
+          return @challenge if defined?(@challenge)
+          key1 && key2
+          sum = [@key1_number].pack("N*") +
+                [@key2_number].pack("N*") +
+                key3
+
+          @challenge = Digest::MD5.digest(sum)
+        end
+
+        def finishing_line
+          key3
+        end
+
+        NOISE_CHARS = ("\x21".."\x2f").to_a() + ("\x3a".."\x7e").to_a()
+
+        def generate_key(key)
+          spaces = 1 + rand(12)
+          max = 0xffffffff / spaces
+          number = rand(max + 1)
+          instance_variable_set("@#{key}_number", number)
+          key = (number * spaces).to_s
+          (1 + rand(12)).times() do
+            char = NOISE_CHARS[rand(NOISE_CHARS.size)]
+            pos = rand(key.size + 1)
+            key[pos...pos] = char
+          end
+          spaces.times() do
+            pos = 1 + rand(key.size - 1)
+            key[pos...pos] = " "
+          end
+          return key
+        end
+
+        def generate_key3
+          return [rand(0x100000000)].pack("N") + [rand(0x100000000)].pack("N")
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/server.rb

@@ -0,0 +1,30 @@
+module WebSocket
+  module Handshake
+    module Handler
+      module Server
+
+        include Base
+
+        def host
+          @headers["host"].to_s.split(":")[0].to_s
+        end
+
+        def port
+          @headers["host"].to_s.split(":")[1]
+        end
+
+        private
+
+        def handshake_location
+          location = @secure ? "wss://" : "ws://"
+          location << host
+          location << ":#{port}" if port
+          location << path
+          location << "?#{@query}" if @query
+          location
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/server04.rb

@@ -0,0 +1,38 @@
+require 'digest/sha1'
+require 'base64'
+
+module WebSocket
+  module Handshake
+    module Handler
+      module Server04
+
+        include Server
+
+        def valid?
+          super && (@headers['sec-websocket-key'] ? true : (set_error(:invalid_handshake_authentication) and false))
+        end
+
+        private
+
+        def header_line
+          "HTTP/1.1 101 Switching Protocols"
+        end
+
+        def handshake_keys
+          [
+            ["Upgrade", "websocket"],
+            ["Connection", "Upgrade"],
+            ["Sec-WebSocket-Accept", signature]
+          ]
+        end
+
+        def signature
+          return unless key = @headers['sec-websocket-key']
+          string_to_sign = "#{key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+          Base64.encode64(Digest::SHA1.digest(string_to_sign)).chomp
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/server75.rb

@@ -0,0 +1,26 @@
+module WebSocket
+  module Handshake
+    module Handler
+      module Server75
+
+        include Server
+
+        private
+
+        def header_line
+          "HTTP/1.1 101 Web Socket Protocol Handshake"
+        end
+
+        def handshake_keys
+          [
+            ["Upgrade", "WebSocket"],
+            ["Connection", "Upgrade"],
+            ["WebSocket-Origin", @headers['origin']],
+            ["WebSocket-Location", handshake_location]
+          ]
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/handler/server76.rb

@@ -0,0 +1,71 @@
+require 'digest/md5'
+
+module WebSocket
+  module Handshake
+    module Handler
+      module Server76
+
+        include Server
+
+        def valid?
+          super && !!finishing_line
+        end
+
+        private
+
+        def reserved_leftover_lines
+          1
+        end
+
+        def header_line
+          "HTTP/1.1 101 WebSocket Protocol Handshake"
+        end
+
+        def handshake_keys
+          [
+            ["Upgrade", "WebSocket"],
+            ["Connection", "Upgrade"],
+            ["Sec-WebSocket-Origin", @headers['origin']],
+            ["Sec-WebSocket-Location", handshake_location]
+          ]
+        end
+
+        def finishing_line
+          @finishing_line ||= challenge_response
+        end
+
+        private
+
+        def challenge_response
+          # Refer to 5.2 4-9 of the draft 76
+          first = numbers_over_spaces(@headers['sec-websocket-key1']) || return
+          second = numbers_over_spaces(@headers['sec-websocket-key2']) || return
+          third = @leftovers.strip
+
+          sum = [first].pack("N*") +
+                [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.
+          set_error(:invalid_handshake_authentication) and return if spaces == 0
+
+          # As per 5.2.6, abort if numbers is not an integral multiple of spaces
+          set_error(:invalid_handshake_authentication) and return if numbers % spaces != 0
+
+          quotient = numbers / spaces
+
+          set_error(:invalid_handshake_authentication) and return if quotient > 2**32-1
+
+          return quotient
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake/server.rb

@@ -0,0 +1,56 @@
+module WebSocket
+  module Handshake
+    class Server < Base
+
+      def initialize(args = {})
+        super
+        @secure = !!args[:secure]
+      end
+
+      def <<(data)
+        @data << data
+        if parse_data
+          set_version
+        end
+      end
+
+      def should_respond?
+        true
+      end
+
+      private
+
+      def set_version
+        @version = @headers['sec-websocket-version'].to_i if @headers['sec-websocket-version']
+        @version ||= @headers['sec-websocket-draft'].to_i if @headers['sec-websocket-draft']
+        @version ||= 76 if @leftovers != ""
+        @version ||= 75
+        include_version
+      end
+
+      def include_version
+        case @version
+          when 75 then extend Handler::Server75
+          when 76, 0..3 then extend Handler::Server76
+          when 4..13 then extend Handler::Server04
+          else set_error(:unknown_protocol_version) and return false
+        end
+        return true
+      end
+
+      PATH = /^(\w+) (\/[^\s]*) HTTP\/1\.1$/
+
+      def parse_first_line(line)
+        line_parts = line.match(PATH)
+        method = line_parts[1].strip
+        set_error(:get_request_required) and return unless method == "GET"
+
+        resource_name = line_parts[2].strip
+        @path, @query = resource_name.split('?', 2)
+
+        return true
+      end
+
+    end
+  end
+end