websocket-driver 0.1.0-java

data/lib/websocket/driver/client.rb

@@ -0,0 +1,117 @@
+module WebSocket
+  class Driver
+
+    class Client < Hybi
+      def self.generate_key
+        Base64.encode64((1..16).map { rand(255).chr } * '').strip
+      end
+
+      def initialize(socket, options = {})
+        super
+
+        @ready_state = -1
+        @key         = Client.generate_key
+        @accept      = Hybi.generate_accept(@key)
+      end
+
+      def version
+        'hybi-13'
+      end
+
+      def start
+        return false unless @ready_state == -1
+        @socket.write(handshake_request)
+        @ready_state = 0
+        true
+      end
+
+      def parse(buffer)
+        return super if @ready_state > 0
+        message = []
+        buffer.each_byte do |data|
+          case @ready_state
+            when 0 then
+              @buffer << data
+              validate_handshake if @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
+            when 1 then
+              message << data
+          end
+        end
+        parse(message) if @ready_state == 1
+      end
+
+    private 
+
+      def handshake_request
+        uri   = URI.parse(@socket.url)
+        host  = uri.host + (uri.port ? ":#{uri.port}" : '')
+        path  = (uri.path == '') ? '/' : uri.path
+        query = uri.query ? "?#{uri.query}" : ''
+
+        headers = [ "GET #{path}#{query} HTTP/1.1",
+                    "Host: #{host}",
+                    "Upgrade: websocket",
+                    "Connection: Upgrade",
+                    "Sec-WebSocket-Key: #{@key}",
+                    "Sec-WebSocket-Version: 13"
+                  ]
+
+        if @protocols.size > 0
+          headers << "Sec-WebSocket-Protocol: #{@protocols * ', '}"
+        end
+
+        (headers + ['', '']).join("\r\n")
+      end
+
+      def fail_handshake(message)
+        message = "Error during WebSocket handshake: #{message}"
+        emit(:error, ProtocolError.new(message))
+        @ready_state = 3
+        emit(:close, CloseEvent.new(ERRORS[:protocol_error], message))
+      end
+
+      def validate_handshake
+        data     = Driver.encode(@buffer)
+        @buffer  = []
+        response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
+
+        unless response.code.to_i == 101
+          return fail_handshake("Unexpected response code: #{response.code}")
+        end
+
+        upgrade    = response['Upgrade'] || ''
+        connection = response['Connection'] || ''
+        accept     = response['Sec-WebSocket-Accept'] || ''
+        protocol   = response['Sec-WebSocket-Protocol'] || ''
+
+        if upgrade == ''
+          return fail_handshake("'Upgrade' header is missing")
+        elsif upgrade.downcase != 'websocket'
+          return fail_handshake("'Upgrade' header value is not 'WebSocket'")
+        end
+
+        if connection == ''
+          return fail_handshake("'Connection' header is missing")
+        elsif connection.downcase != 'upgrade'
+          return fail_handshake("'Connection' header value is not 'Upgrade'")
+        end
+
+        unless accept == @accept
+          return fail_handshake('Sec-WebSocket-Accept mismatch')
+        end
+
+        unless protocol == ''
+          if @protocols.include?(protocol)
+            @protocol = protocol
+          else
+            return fail_handshake('Sec-WebSocket-Protocol mismatch')
+          end
+        end
+
+        open
+      end
+    end
+
+  end
+end
+

data/lib/websocket/driver/draft75.rb

@@ -0,0 +1,93 @@
+module WebSocket
+  class Driver
+
+    class Draft75 < Driver
+      def initialize(socket, options = {})
+        super
+        @stage = 0
+      end
+
+      def version
+        'hixie-75'
+      end
+
+      def parse(buffer)
+        buffer = buffer.bytes if buffer.respond_to?(:bytes)
+
+        buffer.each do |data|
+          case @stage
+            when -1 then
+              @body << data
+              send_handshake_body
+
+            when 0 then
+              parse_leading_byte(data)
+
+            when 1 then
+              value = (data & 0x7F)
+              @length = value + 128 * @length
+
+              if @closing and @length.zero?
+                @ready_state = 3
+                emit(:close, CloseEvent.new(nil, nil))
+              elsif (0x80 & data) != 0x80
+                if @length.zero?
+                  @stage = 0
+                else
+                  @skipped = 0
+                  @stage = 2
+                end
+              end
+
+            when 2 then
+              if data == 0xFF
+                emit(:message, MessageEvent.new(Driver.encode(@buffer)))
+                @stage = 0
+              else
+                if @length
+                  @skipped += 1
+                  @stage = 0 if @skipped == @length
+                else
+                  @buffer << data
+                end
+              end
+          end
+        end
+      end
+
+      def frame(data, type = nil, error_type = nil)
+        return queue([data, type, error_type]) if @ready_state == 0
+        data = Driver.encode(data)
+        frame = ["\x00", data, "\xFF"].map(&Driver.method(:encode)) * ''
+        @socket.write(frame)
+        true
+      end
+
+    private
+
+      def handshake_response
+        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+        upgrade << "Upgrade: WebSocket\r\n"
+        upgrade << "Connection: Upgrade\r\n"
+        upgrade << "WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
+        upgrade << "WebSocket-Location: #{@socket.url}\r\n"
+        upgrade << "\r\n"
+        upgrade
+      end
+
+      def parse_leading_byte(data)
+        if (0x80 & data) == 0x80
+          @length = 0
+          @stage  = 1
+        else
+          @length  = nil
+          @skipped = nil
+          @buffer  = []
+          @stage   = 2
+        end
+      end
+    end
+
+  end
+end
+

data/lib/websocket/driver/draft76.rb

@@ -0,0 +1,97 @@
+module WebSocket
+  class Driver
+
+    class Draft76 < Draft75
+      BODY_SIZE = 8
+
+      def initialize(socket, options = {})
+        super
+        input  = @socket.env['rack.input']
+        @stage = -1
+        @body  = input ? input.read.bytes.to_a : []
+      end
+
+      def version
+        'hixie-76'
+      end
+
+      def start
+        return false unless super
+        send_handshake_body
+        true
+      end
+
+      def close(reason = nil, code = nil)
+        return false if @ready_state == 3
+        @socket.write("\xFF\x00")
+        @ready_state = 3
+        emit(:close, CloseEvent.new(nil, nil))
+        true
+      end
+
+    private
+
+      def handshake_response
+        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+        upgrade << "Upgrade: WebSocket\r\n"
+        upgrade << "Connection: Upgrade\r\n"
+        upgrade << "Sec-WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
+        upgrade << "Sec-WebSocket-Location: #{@socket.url}\r\n"
+        upgrade << "\r\n"
+        upgrade
+      end
+
+      def handshake_signature
+        return nil unless @body.size >= BODY_SIZE
+
+        head = @body[0...BODY_SIZE].pack('C*')
+        head.force_encoding('ASCII-8BIT') if head.respond_to?(:force_encoding)
+
+        env = @socket.env
+
+        key1   = env['HTTP_SEC_WEBSOCKET_KEY1']
+        value1 = number_from_key(key1) / spaces_in_key(key1)
+
+        key2   = env['HTTP_SEC_WEBSOCKET_KEY2']
+        value2 = number_from_key(key2) / spaces_in_key(key2)
+
+        Digest::MD5.digest(big_endian(value1) +
+                           big_endian(value2) +
+                           head)
+      end
+
+      def send_handshake_body
+        return unless signature = handshake_signature
+        @socket.write(signature)
+        @stage = 0
+        open
+        parse(@body[BODY_SIZE..-1]) if @body.size > BODY_SIZE
+      end
+
+      def parse_leading_byte(data)
+        return super unless data == 0xFF
+        @closing = true
+        @length = 0
+        @stage = 1
+      end
+
+      def number_from_key(key)
+        key.scan(/[0-9]/).join('').to_i(10)
+      end
+
+      def spaces_in_key(key)
+        key.scan(/ /).size
+      end
+
+      def big_endian(number)
+        string = ''
+        [24,16,8,0].each do |offset|
+          string << (number >> offset & 0xFF).chr
+        end
+        string
+      end
+    end
+
+  end
+end
+

data/lib/websocket/driver/event_emitter.rb

@@ -0,0 +1,43 @@
+module WebSocket
+  class Driver
+
+    module EventEmitter
+      def initialize
+        @listeners = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def add_listener(event, &listener)
+        @listeners[event.to_s] << listener
+      end
+
+      def on(event, &listener)
+        add_listener(event, &listener)
+      end
+
+      def remove_listener(event, &listener)
+        @listeners[event.to_s].delete(listener)
+      end
+
+      def remove_all_listeners(event = nil)
+        if event
+          @listeners.delete(event.to_s)
+        else
+          @listeners.clear
+        end
+      end
+
+      def emit(event, *args)
+        @listeners[event.to_s].each do |listener|
+          listener.call(*args)
+        end
+      end
+
+      def listener_count(event)
+        list = @listeners[event.to_s]
+        list && list.size
+      end
+    end
+
+  end
+end
+

data/lib/websocket/driver/hybi.rb

@@ -0,0 +1,368 @@
+module WebSocket
+  class Driver
+
+    class Hybi < Driver
+      root = File.expand_path('../hybi', __FILE__)
+      autoload :StreamReader, root + '/stream_reader'
+
+      def self.generate_accept(key)
+        Base64.encode64(Digest::SHA1.digest(key + GUID)).strip
+      end
+
+      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+      BYTE       = 0b11111111
+      FIN = MASK = 0b10000000
+      RSV1       = 0b01000000
+      RSV2       = 0b00100000
+      RSV3       = 0b00010000
+      OPCODE     = 0b00001111
+      LENGTH     = 0b01111111
+
+      OPCODES = {
+        :continuation => 0,
+        :text         => 1,
+        :binary       => 2,
+        :close        => 8,
+        :ping         => 9,
+        :pong         => 10
+      }
+
+      OPCODE_CODES       = OPCODES.values
+      FRAGMENTED_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
+      OPENING_OPCODES    = OPCODES.values_at(:text, :binary)
+
+      ERRORS = {
+        :normal_closure       => 1000,
+        :going_away           => 1001,
+        :protocol_error       => 1002,
+        :unacceptable         => 1003,
+        :encoding_error       => 1007,
+        :policy_violation     => 1008,
+        :too_large            => 1009,
+        :extension_error      => 1010,
+        :unexpected_condition => 1011
+      }
+
+      ERROR_CODES        = ERRORS.values
+      MIN_RESERVED_ERROR = 3000
+      MAX_RESERVED_ERROR = 4999
+
+      def initialize(socket, options = {})
+        super
+        reset
+
+        @reader    = StreamReader.new
+        @stage     = 0
+        @masking   = options[:masking]
+        @protocols = options[:protocols] || []
+        @protocols = @protocols.strip.split(/\s*,\s*/) if String === @protocols
+
+        @require_masking = options[:require_masking]
+        @ping_callbacks  = {}
+      end
+
+      def version
+        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
+      end
+
+      def parse(data)
+        data = data.bytes.to_a if data.respond_to?(:bytes)
+        @reader.put(data)
+        buffer = true
+        while buffer
+          case @stage
+            when 0 then
+              buffer = @reader.read(1)
+              parse_opcode(buffer[0]) if buffer
+
+            when 1 then
+              buffer = @reader.read(1)
+              parse_length(buffer[0]) if buffer
+
+            when 2 then
+              buffer = @reader.read(@length_size)
+              parse_extended_length(buffer) if buffer
+
+            when 3 then
+              buffer = @reader.read(4)
+              if buffer
+                @mask  = buffer
+                @stage = 4
+              end
+
+            when 4 then
+              buffer = @reader.read(@length)
+              if buffer
+                @payload = buffer
+                emit_frame
+                @stage = 0
+              end
+          end
+        end
+      end
+
+      def frame(data, type = nil, code = nil)
+        return queue([data, type, code]) if @ready_state == 0
+        return false unless @ready_state == 1
+
+        data = data.to_s unless Array === data
+        data = Driver.encode(data) if String === data
+
+        is_text = (String === data)
+        opcode  = OPCODES[type || (is_text ? :text : :binary)]
+        buffer  = data.respond_to?(:bytes) ? data.bytes.to_a : data
+        insert  = code ? 2 : 0
+        length  = buffer.size + insert
+        header  = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10)
+        offset  = header + (@masking ? 4 : 0)
+        masked  = @masking ? MASK : 0
+        frame   = Array.new(offset)
+
+        frame[0] = FIN | opcode
+
+        if length <= 125
+          frame[1] = masked | length
+        elsif length <= 65535
+          frame[1] = masked | 126
+          frame[2] = (length >> 8) & BYTE
+          frame[3] = length & BYTE
+        else
+          frame[1] = masked | 127
+          frame[2] = (length >> 56) & BYTE
+          frame[3] = (length >> 48) & BYTE
+          frame[4] = (length >> 40) & BYTE
+          frame[5] = (length >> 32) & BYTE
+          frame[6] = (length >> 24) & BYTE
+          frame[7] = (length >> 16) & BYTE
+          frame[8] = (length >> 8)  & BYTE
+          frame[9] = length & BYTE
+        end
+
+        if code
+          buffer = [(code >> 8) & BYTE, code & BYTE] + buffer
+        end
+
+        if @masking
+          mask = [rand(256), rand(256), rand(256), rand(256)]
+          frame[header...offset] = mask
+          buffer = Mask.mask(buffer, mask)
+        end
+
+        frame.concat(buffer)
+
+        @socket.write(Driver.encode(frame))
+        true
+      end
+
+      def text(message)
+        frame(message, :text)
+      end
+
+      def binary(message)
+        frame(message, :binary)
+      end
+
+      def ping(message = '', &callback)
+        @ping_callbacks[message] = callback if callback
+        frame(message, :ping)
+      end
+
+      def close(reason = nil, code = nil)
+        reason ||= ''
+        code   ||= ERRORS[:normal_closure]
+
+        case @ready_state
+          when 0 then
+            @ready_state = 3
+            emit(:close, CloseEvent.new(code, reason))
+            true
+          when 1 then
+            frame(reason, :close, code)
+            @ready_state = 2
+            true
+          else
+            false
+        end
+      end
+
+    private
+
+      def handshake_response
+        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
+        return '' unless String === sec_key
+
+        accept    = Hybi.generate_accept(sec_key)
+        protos    = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
+        supported = @protocols
+        proto     = nil
+
+        headers = [
+          "HTTP/1.1 101 Switching Protocols",
+          "Upgrade: websocket",
+          "Connection: Upgrade",
+          "Sec-WebSocket-Accept: #{accept}"
+        ]
+
+        if protos
+          protos = protos.split(/\s*,\s*/) if String === protos
+          proto = protos.find { |p| supported.include?(p) }
+          if proto
+            @protocol = proto
+            headers << "Sec-WebSocket-Protocol: #{proto}"
+          end
+        end
+
+        (headers + ['','']).join("\r\n")
+      end
+
+      def shutdown(code, reason)
+        frame(reason, :close, code)
+        @ready_state = 3
+        emit(:close, CloseEvent.new(code, reason))
+      end
+
+      def fail(type, message)
+        emit(:error, ProtocolError.new(message))
+        shutdown(ERRORS[type], message)
+      end
+
+      def parse_opcode(data)
+        rsvs = [RSV1, RSV2, RSV3].map { |rsv| (data & rsv) == rsv }
+
+        if rsvs.any?
+          return fail(:protocol_error,
+              "One or more reserved bits are on: reserved1 = #{rsvs[0] ? 1 : 0}" +
+              ", reserved2 = #{rsvs[1] ? 1 : 0 }" +
+              ", reserved3 = #{rsvs[2] ? 1 : 0 }")
+        end
+
+        @final   = (data & FIN) == FIN
+        @opcode  = (data & OPCODE)
+        @mask    = []
+        @payload = []
+
+        unless OPCODES.values.include?(@opcode)
+          return fail(:protocol_error, "Unrecognized frame opcode: #{@opcode}")
+        end
+
+        unless FRAGMENTED_OPCODES.include?(@opcode) or @final
+          return fail(:protocol_error, "Received fragmented control frame: opcode = #{@opcode}")
+        end
+
+        if @mode and OPENING_OPCODES.include?(@opcode)
+          return fail(:protocol_error, 'Received new data frame but previous continuous frame is unfinished')
+        end
+
+        @stage = 1
+      end
+
+      def parse_length(data)
+        @masked = (data & MASK) == MASK
+        if @require_masking and not @masked
+          return fail(:unacceptable, 'Received unmasked frame but masking is required')
+        end
+
+        @length = (data & LENGTH)
+
+        if @length <= 125
+          @stage = @masked ? 3 : 4
+        else
+          @length_size = (@length == 126) ? 2 : 8
+          @stage       = 2
+        end
+      end
+
+      def parse_extended_length(buffer)
+        @length = integer(buffer)
+
+        unless FRAGMENTED_OPCODES.include?(@opcode) or @length <= 125
+          return fail(:protocol_error, "Received control frame having too long payload: #{@length}")
+        end
+
+        @stage  = @masked ? 3 : 4
+      end
+
+      def emit_frame
+        payload = @masked ? Mask.mask(@payload, @mask) : @payload
+
+        case @opcode
+          when OPCODES[:continuation] then
+            return fail(:protocol_error, 'Received unexpected continuation frame') unless @mode
+            @buffer.concat(payload)
+            if @final
+              message = @buffer
+              message = Driver.encode(message, true) if @mode == :text
+              reset
+              if message
+                emit(:message, MessageEvent.new(message))
+              else
+                fail(:encoding_error, 'Could not decode a text frame as UTF-8')
+              end
+            end
+
+          when OPCODES[:text] then
+            if @final
+              message = Driver.encode(payload, true)
+              if message
+                emit(:message, MessageEvent.new(message))
+              else
+                fail(:encoding_error, 'Could not decode a text frame as UTF-8')
+              end
+            else
+              @mode = :text
+              @buffer.concat(payload)
+            end
+
+          when OPCODES[:binary] then
+            if @final
+              emit(:message, MessageEvent.new(payload))
+            else
+              @mode = :binary
+              @buffer.concat(payload)
+            end
+
+          when OPCODES[:close] then
+            code = (payload.size >= 2) ? 256 * payload[0] + payload[1] : nil
+
+            unless (payload.size == 0) or
+                   (code && code >= MIN_RESERVED_ERROR && code <= MAX_RESERVED_ERROR) or
+                   ERROR_CODES.include?(code)
+              code = ERRORS[:protocol_error]
+            end
+
+            if payload.size > 125 or not Driver.valid_utf8?(payload[2..-1] || [])
+              code = ERRORS[:protocol_error]
+            end
+
+            reason = (payload.size > 2) ? Driver.encode(payload[2..-1], true) : ''
+            shutdown(code, reason || '')
+
+          when OPCODES[:ping] then
+            frame(payload, :pong)
+
+          when OPCODES[:pong] then
+            message = Driver.encode(payload, true)
+            callback = @ping_callbacks[message]
+            @ping_callbacks.delete(message)
+            callback.call if callback
+        end
+      end
+
+      def reset
+        @buffer = []
+        @mode   = nil
+      end
+
+      def integer(bytes)
+        number = 0
+        bytes.each_with_index do |data, i|
+          number += data << (8 * (bytes.size - 1 - i))
+        end
+        number
+      end
+    end
+
+  end
+end
+