em-ws-client 0.1.2 → 0.2.0

data/lib/em-ws-client/decoder.rb

@@ -0,0 +1,238 @@
+# encoding: UTF-8
+
+module EventMachine::WebSocketCodec
+
+  # Internal: A WebSocket frame decoder 
+  # based on RFC 6455
+  class Decoder
+
+    include Protocol
+
+    def initialize
+      @fragmented = false
+      @buffer = ""
+      @chunks = nil
+      @callbacks = {}
+    end
+
+    def onclose █ @callbacks[:close] = block; end
+    def onping █ @callbacks[:ping] = block; end
+    def onpong █ @callbacks[:pong] = block; end
+    def onframe █ @callbacks[:frame] = block; end
+    def onerror █ @callbacks[:error] = block; end
+
+    # Public: Feed the decoder raw data from the wire
+    # 
+    # data - The raw websocket frame data
+    #
+    # Examples
+    #
+    #   decoder << raw
+    #
+    # Returns nothing
+    def << data
+
+      # put the data into the buffer, as
+      # we might be replaying
+      if data
+        @buffer << data
+      end
+
+      # Don't do work if we don't have to
+      if @buffer.length < 2
+        return
+      end
+
+      # decode the first 2 bytes, with
+      # opcode, lengthgth, masking bit, and frag bit
+      h1, h2 = @buffer.unpack("CC")
+
+      # check the fragmentation bit to see
+      # if this is a message fragment
+      fin = ((h1 & 0x80) == 0x80)
+
+      # used to keep track of our position in the buffer
+      offset = 2
+
+      # see above for possible opcodes
+      opcode = (h1 & 0x0F)
+
+      # the leading length idicator
+      length = (h2 & 0x7F)
+
+      # masking bit, is the data masked with
+      # a specified masking key?
+      masked = ((h2 & 0x80) == 0x80)
+
+      # Find errors and fail fast
+      if h1 & 0b01110000 != 0
+        return emit :error, 1002, "RSV bits must be 0"
+      end
+
+      if opcode > 7
+        if !fin
+          return emit :error, 1002, "Control frame cannot be fragmented"
+        elsif length > 125
+          return emit :error, 1002, "Control frame is too large #{length}"
+        elsif opcode > 0xA
+          return emit :error, 1002, "Unexpected reserved opcode #{opcode}"
+        elsif opcode == CLOSE && length == 1
+          return emit :error, 1002, "Close control frame with payload of length 1"
+        end
+      else
+        if opcode != CONTINUATION && opcode != TEXT_FRAME && opcode != BINARY_FRAME
+          return emit :error, 1002, "Unexpected reserved opcode #{opcode}"
+        end
+      end
+
+      # Get the actual size of the payload
+      if length > 125
+        if length == 126
+          length = @buffer.unpack("@#{offset}n").first
+          offset += 2
+        else
+          length = @buffer.unpack("@#{offset}L!>").first
+          offset += 8
+        end
+      end
+
+      # unpack the masking key
+      if masked
+        key = @buffer.unpack("@#{offset}N").first
+        offset += 4
+      end
+
+      # replay on next frame
+      if @buffer.size < (length + offset)
+        return false
+      end
+
+      # Read the important bits
+      payload = @buffer.unpack("@#{offset}C#{length}")
+
+      # Unmask the data if it"s masked
+      if masked
+        payload.bytesize.times do |i|
+          payload[i] = ((payload[i] ^ (key >> ((3 - (i % 4)) * 8))) & 0xFF)
+        end
+      end
+      
+      payload = payload.pack("C*")
+
+      case opcode
+      when CONTINUATION
+
+        # We shouldn't get a contination without
+        # knowing whether or not it's binary or text
+        unless @fragmented
+          return emit :error, 1002, "Unexepected continuation"
+        end
+
+        if @fragmented == :text
+          @chunks << payload.force_encoding("UTF-8")
+        else
+          @chunks << payload
+        end
+
+        if fin
+          if @fragmented == :text && !valid_utf8?(@chunks)
+            return emit :error, 1007, "Invalid UTF"
+          end
+
+          emit :frame, @chunks, @fragmented == :binary
+          @chunks = nil
+          @fragmented = false
+        end
+
+      when TEXT_FRAME
+        # We shouldn't get a text frame when we
+        # are expecting a continuation
+        if @fragmented
+          return emit :error, 1002, "Unexepected frame"
+        end
+
+        # emit or buffer
+        if fin
+          unless valid_utf8?(payload)
+            return emit :error, 1007, "Invalid UTF Hmm"
+          end
+
+          emit :frame, payload, false
+        else
+          @chunks = payload.force_encoding("UTF-8")
+          @fragmented = :text
+        end
+
+      when BINARY_FRAME
+        # We shouldn't get a text frame when we
+        # are expecting a continuation
+        if @fragmented
+          return emit :error, 1002, "Unexepected frame"
+        end
+
+        # emit or buffer
+        if fin
+          emit :frame, payload, true
+        else
+          @chunks = payload
+          @fragmented = :binary
+        end
+
+      when CLOSE
+        code, explain = payload.unpack("nA*")
+        if explain && !valid_utf8?(explain)
+          emit :close, 1007
+        else
+          emit :close, response_close_code(code)
+        end
+
+      when PING
+        emit :ping, payload
+
+      when PONG
+        emit :pong, payload
+
+      end
+
+      # Remove data we made use of and call back
+      # TODO: remove recursion
+      @buffer = @buffer[offset + length..-1] || ""
+      if not @buffer.empty?
+        self << nil
+      end
+
+    end
+
+    private
+
+    # trigger event for listener
+    def emit event, *args
+      if @callbacks.key?(event)
+        @callbacks[event].call(*args)
+      end
+    end
+
+    # Determine if the close code we received is valid
+    # and close if it's not
+    def response_close_code code
+      case code
+      when 1000,1001,1002,1003,1007,1008,1009,1010,1011
+        1000
+      when 3000..3999
+        1000
+      when 4000..4999
+        1000
+      when nil
+        1000
+      else
+        1002
+      end
+    end
+
+    def valid_utf8? str
+      str.force_encoding("UTF-8").valid_encoding?
+    end
+
+  end
+
+end

data/lib/em-ws-client/encoder.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+module EventMachine::WebSocketCodec
+  
+  # Internal: Encodes messages into WebSocket frames
+  # based on RFC 6455
+  class Encoder
+
+    include Protocol
+
+    # Encode a standard payload to a hybi10
+    # WebSocket frame
+    def encode data, opcode=TEXT_FRAME
+      frame = []
+      frame << (opcode | 0x80)
+
+      packr = "CC"
+
+      if opcode == TEXT_FRAME
+        data.force_encoding("UTF-8")
+
+        if !data.valid_encoding?
+          raise "Invalid UTF!"
+        end
+      end
+
+      # append frame length and mask bit 0x80
+      len = data ? data.bytesize : 0
+      if len <= 125
+        frame << (len | 0x80)
+      elsif len < 65536
+        frame << (126 | 0x80)
+        frame << len
+        packr << "n"
+      else
+        frame << (127 | 0x80)
+        frame << len
+        packr << "L!>"
+      end
+
+      # generate a masking key
+      key = rand(2 ** 31)
+
+      # mask each byte with the key
+      frame << key
+      packr << "N"
+
+      #puts "op #{opcode} len #{len} bytes #{data}"
+      # Apply the masking key to every byte
+      len.times do |i|
+        frame << ((data.getbyte(i) ^ (key >> ((3 - (i % 4)) * 8))) & 0xFF)
+      end
+
+      frame.pack("#{packr}C*")
+    end
+
+    # create a close payload with code
+    def close code, message
+      encode [code ? code : 1000, message].pack("nA*"), CLOSE
+    end
+
+    # create a ping payload
+    def ping data=nil
+      encode data, PING
+    end
+
+    # create a pong payload
+    def pong data=nil
+      encode data, PONG
+    end
+
+  end
+
+end

data/lib/em-ws-client/handshake.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+
+module EventMachine::WebSocketCodec
+
+  # Internal: Responsbile for generating the request and
+  # validating the response
+  class Handshake
+
+    class HandshakeError < StandardError; end
+
+    Status = /^HTTP\/1.1 (\d+)/i.freeze
+    Header = /^([^:]+):\s*(.+)$/i.freeze
+
+    attr_accessor :extra
+
+    def initialize uri, origin="em-ws-client"
+      @uri = uri
+      @origin = origin
+      @buffer = ""
+      @complete = false
+      @valid = false
+      @extra = ""
+    end
+
+    def request
+      headers = ["GET #{path} HTTP/1.1"]
+      headers << "Connection: keep-alive, Upgrade"
+      headers << "Host: #{host}"
+      headers << "Sec-WebSocket-Key: #{request_key}"
+      headers << "Sec-WebSocket-Version: 13"
+      headers << "Origin: #{@origin}"
+      headers << "Upgrade: websocket"
+      headers << "User-Agent: em-ws-client"
+      headers << "\r\n"
+
+      headers.join "\r\n"
+    end
+
+    def << data
+      @buffer << data
+
+      if @buffer.index "\r\n\r\n"
+
+        response, @extra = @buffer.split("\r\n\r\n", 2)
+
+        lines = response.split "\r\n"
+
+        if Status =~ lines.shift
+          if $1.to_i != 101
+            raise HandshakeError.new "Received code #{$1}"
+          end
+        end
+
+        table = {}
+        lines.each do |line|
+          header = /^([^:]+):\s*(.+)$/.match(line)
+          table[header[1].downcase.strip] = header[2].strip if header
+        end
+
+        @complete = true
+        if table["sec-websocket-accept"] == response_key
+          @valid = true
+        else
+          raise HandshakeError.new "Invalid Sec-Websocket-Accept"
+        end
+      end
+    end
+
+    def complete?
+      @complete
+    end
+
+    def valid?
+      @valid
+    end
+
+    def host
+      @uri.host + (@uri.port ? ":#{@uri.port}" : "")
+    end
+
+    def path
+      (@uri.path.empty? ? "/" : @uri.path) + (@uri.query ? "?#{@uri.query}" : "")
+    end
+
+    # Build a unique request key to match against
+    def request_key
+      @request_key ||= SecureRandom::base64
+    end
+
+    # Build the response key from the given request key
+    # for comparison with the response value.
+    def response_key
+      Base64.encode64(Digest::SHA1.digest("#{request_key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11")).chomp
+    end
+
+  end
+end

data/lib/em-ws-client/protocol.rb

@@ -0,0 +1,12 @@
+module EventMachine
+  module WebSocketCodec
+    module Protocol
+      CONTINUATION  = 0x0
+      TEXT_FRAME    = 0x1
+      BINARY_FRAME  = 0x2
+      CLOSE         = 0x8
+      PING          = 0x9
+      PONG          = 0xA
+    end
+  end
+end

data/spec/codec_spec.rb

@@ -0,0 +1,15 @@
+require "helper"
+
+module EM::WebSocketCodec
+  describe Decoder do
+
+    it "should decode an encoded message" do
+      dec = Decoder.new
+      enc = Encoder.new
+
+      str = enc.encode("simple message")
+      #dec.<<(str).should == "simple message"
+    end
+
+  end
+end

data/spec/handshake_spec.rb

@@ -0,0 +1,96 @@
+require "helper"
+
+module EM::WebSocketCodec
+  describe Handshake do
+
+    def craft_response status, message, headers
+      response = ["HTTP/1.1 #{status} #{message}"]
+      headers.each do |key, val|
+        response << "#{key}: #{val}"
+      end
+      response << "\r\n"
+      response.join "\r\n"
+    end
+
+    it "should generate a request a 24 byte key" do
+      handshake = Handshake.new URI.parse("ws://test.com/test"), "em-test"
+      handshake.request_key.length.should == 24
+    end
+
+    it "should craft an HTTP request" do
+      handshake = Handshake.new URI.parse("ws://test.com/test"), "em-test"
+      handshake.request.length.should > 0
+    end
+
+    it "should handle an good response" do
+      handshake = Handshake.new URI.parse("ws://test.com/test"), "em-test"
+
+      handshake << craft_response(101, "Switching Protocol", {
+        "Upgrade" => "WebSocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Accept" => handshake.response_key
+      })
+
+      handshake.complete?.should be_true
+      handshake.valid?.should be_true
+      handshake.extra.should be_empty
+    end
+
+    it "should handle an bad response" do
+      handshake = Handshake.new URI.parse("ws://test.com/test"), "em-test"
+
+      exception = false
+      begin
+        handshake << craft_response(200, "OK", {
+          "Upgrade" => "WebSocket",
+          "Connection" => "Upgrade",
+          "Sec-WebSocket-Accept" => handshake.response_key
+        })
+      rescue Handshake::HandshakeError => err
+        exception = true
+      end
+
+      handshake.complete?.should be_false
+      exception.should be_true
+    end
+
+    it "should handle an chunked response" do
+      handshake = Handshake.new URI.parse("ws://test.com/test"), "em-test"
+
+      response = craft_response(101, "Switching Protocol", {
+        "Upgrade" => "WebSocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Accept" => handshake.response_key
+      })
+
+      response[0..-2].each_byte do |byte|
+        handshake << byte
+        handshake.complete?.should be_false
+      end
+
+      handshake << response[-1..-1]
+
+      handshake.complete?.should be_true
+      handshake.valid?.should be_true
+      handshake.extra.should be_empty
+    end
+
+    it "should handle an response with framing after it" do
+      handshake = Handshake.new URI.parse("ws://test.com/test"), "em-test"
+
+      response = craft_response(101, "Switching Protocol", {
+        "Upgrade" => "WebSocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Accept" => handshake.response_key
+      })
+
+      response  << "extradata"
+      handshake << response
+
+      handshake.complete?.should be_true
+      handshake.valid?.should be_true
+      handshake.extra.should == "extradata"
+    end
+
+  end
+end