websocket_parser 0.0.1 → 0.0.2

data/README.md

@@ -20,7 +20,7 @@ Or install it yourself as:
 
 ## Usage
 
-```
+```ruby
 require 'websocket_parser'
 
 socket = # Handle I/O with your server/event loop.
@@ -36,12 +36,17 @@ parser.on_error do |m|
   socket.close!
 end
 
-parser.on_close do |m|
-  puts "Client closed connection. Reason: #{m}"
+parser.on_close do |status, message|
+  # According to the spec the server must respond with another
+  # close message before closing the connection
+
+  socket << WebSocket::Message.close.to_data
   socket.close!
+
+  puts "Client closed connection. Status: #{status}. Reason: #{m}"
 end
 
-parser.on_ping do |m|
+parser.on_ping do
   socket << WebSocket::Message.pong.to_data
 end
 
@@ -53,6 +58,10 @@ socket << WebSocket::Message.new('Hi there!').to_data
 
 ```
 
+## Status
+
+Websocket Parser is still in early development phase.
+
 ## Contributing
 
 1. Fork it

data/lib/websocket/client_handshake.rb

@@ -3,6 +3,10 @@ require 'digest/sha1'
 module WebSocket
   class ClientHandshake < Http::Request
 
+    def self.accept_token_for(websocket_key)
+      Digest::SHA1.base64digest(websocket_key.strip + GUID)
+    end
+
     def initialize(method, uri, headers = {}, proxy = {}, body = nil, version = "1.1")
       @method = method.to_s.downcase.to_sym
       @uri = uri.is_a?(URI) ? uri : URI(uri.to_s)
@@ -21,16 +25,10 @@ module WebSocket
       response_headers = {
         'Upgrade'    => 'websocket',
         'Connection' => 'Upgrade',
-        'Sec-WebSocket-Accept' => accept_token
+        'Sec-WebSocket-Accept' => ClientHandshake.accept_token_for(headers['Sec-WebSocket-Key'])
       }
 
       ServerHandshake.new(101, '1.1', response_headers)
     end
-
-    private
-
-    def accept_token
-      Digest::SHA1.base64digest(headers['Sec-WebSocket-Key'].strip + GUID)
-    end
   end
 end

data/lib/websocket/message.rb

@@ -1,34 +1,49 @@
 module WebSocket
   class Message
-    attr_reader :type, :payload
+    attr_reader :type, :mask_key, :status_code, :payload, :status_message
 
     # Return a new ping message
-    def self.ping(message = '')
-      new(message, :ping)
+    def self.ping
+      new('', :ping)
     end
 
     # Return a new pong message
-    def self.pong(message = '')
-      new(message, :pong)
+    def self.pong
+      new('', :pong)
     end
 
     # Return a new close message
-    def self.close(reason = '')
-      new(reason, :close)
-    end
+    def self.close(status_code = nil, reason = nil)
+      if status_code && STATUS_CODES[status_code] == nil
+        raise ArgumentError.new('Invalid status')
+      end
+
+      if reason && status_code == nil
+        raise ArgumentError.new("Can't set a status message without status code")
+      end
 
-    def initialize(message, type = :text)
-      @type, @payload = type, message.force_encoding("ASCII-8BIT")
+      new(reason, :close, status_code)
     end
 
-    def first_byte
-      @first_byte ||= if type == :continuation
-        OPCODE_VALUES[type]
+    def initialize(message = '', type = :text, status_code = nil)
+      @type = type
+
+      @payload = if status_code
+        @status_code    = status_code
+        @status_message = message
+
+        [status_code, message].pack('S<a*')
       else
-        0b10000000 | OPCODE_VALUES[type] # set FIN bit to true
+        message.force_encoding("ASCII-8BIT") if message
       end
     end
 
+    def mask!
+      @second_byte = second_byte | 0b10000000 # Set masked bit
+      @mask_key = Random.new.bytes(4)
+      @payload = WebSocket.mask(@payload, @mask_key)
+    end
+
     def message_size
       if payload_length < 126
         :small
@@ -39,36 +54,58 @@ module WebSocket
       end
     end
 
-    def second_byte
-      case message_size
-      when :small  then payload_length
-      when :medium then 126
-      when :large  then 127
-      end
+    def payload_length
+      @payload ? @payload.length : 0
     end
 
-    def payload_length
-      @payload.length
+    def masked?
+      second_byte & 0b10000000 != 0
     end
 
     def extended_payload_length
       message_size == :small ? nil : payload_length
     end
 
+    def to_data
+      to_a.pack(pack_format)
+    end
+
+    def write(io)
+      io << to_data
+    end
+
+    def control_frame?
+      [:close, :ping, :pong].include?(type)
+    end
+
+    def status
+      STATUS_CODES[status_code]
+    end
+
+    private
+
     def to_a
-      [first_byte, second_byte, extended_payload_length, payload].compact
+      [first_byte, second_byte, extended_payload_length, mask_key, payload].compact
     end
 
     def pack_format
-      "#{FRAME_FORMAT[message_size]}#{payload_length}"
+      WebSocket.frame_format(payload_length, masked?)
     end
 
-    def to_data
-      to_a.pack(pack_format)
+    def first_byte
+      @first_byte ||= if type == :continuation
+        OPCODE_VALUES[type]
+      else
+        0b10000000 | OPCODE_VALUES[type] # set FIN bit to true
+      end
     end
 
-    def write(io)
-      io << to_data
+    def second_byte
+      @second_byte ||= case message_size
+      when :small  then payload_length
+      when :medium then 126
+      when :large  then 127
+      end
     end
   end
 end

data/lib/websocket/parser.rb

@@ -36,15 +36,15 @@ module WebSocket
         puts "WebSocket error: #{error}"
       end
 
-      @on_close = Proc.new do |reason|
-        puts "Should close connection. Reason: #{reason}"
+      @on_close = Proc.new do |status, message|
+        puts "Should close connection. Status: #{status} Message: #{message}"
       end
 
-      @on_ping = Proc.new do |ping|
+      @on_ping = Proc.new do
         puts "Ping received"
       end
 
-      @on_pong = Proc.new do |pong|
+      @on_pong = Proc.new do
         puts "Pong received"
       end
 
@@ -76,6 +76,7 @@ module WebSocket
 
       read_header         if @state == :header
       read_payload_length if @state == :payload_length
+      read_mask_key       if @state == :mask
       read_payload        if @state == :payload
 
       process_frame if @state == :complete
@@ -97,7 +98,9 @@ module WebSocket
         read_extended_payload_length
       end
 
-      @state = :payload if @payload_length
+      return unless @payload_length
+
+      @state = masked? ? :mask : :payload
     end
 
     def read_extended_payload_length
@@ -108,11 +111,23 @@ module WebSocket
       end
     end
 
+    def read_mask_key
+      return unless @data.size >= 4
+
+      @mask_key = unpack_bytes(4,'a4')
+      @state = :payload
+    end
+
     def read_payload
       return unless @data.length >= @payload_length # Not enough data
 
       payload_data = unpack_bytes(@payload_length, "a#{@payload_length}")
-      @payload = masked? ? unmask(payload_data) : payload_data
+
+      @payload = if masked?
+        WebSocket.unmask(payload_data, @mask_key)
+      else
+        payload_data
+      end
 
       @state = :complete if @payload
     end
@@ -121,10 +136,6 @@ module WebSocket
       @data.slice!(0,num).unpack(format).first
     end
 
-    def completed_message?
-      fin? || payload
-    end
-
     def control_frame?
       [:close, :ping, :pong].include?(opcode)
     end
@@ -150,11 +161,14 @@ module WebSocket
       when :binary
         @on_message.call(@current_message)
       when :close
-        @on_close.call(@current_message.encode("UTF-8"))
+        status_code, message = @current_message.unpack('S<a*')
+        status = STATUS_CODES[status_code]
+
+        @on_close.call(status, message)
       when :ping
-        @on_ping.call(@current_message.encode("UTF-8"))
+        @on_ping.call
       when :pong
-        @on_pong.call(@current_message.encode("UTF-8"))
+        @on_pong.call
       end
 
       @current_message = nil
@@ -166,18 +180,6 @@ module WebSocket
       @first_byte & 0b10000000 != 0
     end
 
-    def svr1?
-      @first_byte & 0b01000000 != 0
-    end
-
-    def svr2?
-      @first_byte & 0b00100000 != 0
-    end
-
-    def svr3?
-      @first_byte & 0b00010000 != 0
-    end
-
     def opcode
       @opcode ||= OPCODES[@first_byte & 0b00001111]
     end
@@ -190,14 +192,6 @@ module WebSocket
       @second_byte & 0b01111111
     end
 
-    def mask_key
-      @mask_key ||= if masked?
-        @second_byte && read_uint32!
-      else
-        nil
-      end
-    end
-
     def message_size
       if payload_length_field < 126
         :small
@@ -209,21 +203,9 @@ module WebSocket
     end
 
     def pack_format
-      "#{FRAME_FORMAT[message_size]}#{actual_payload_length}"
-    end
-
-    def mask(data)
-      masked_data = ''.encode!("ASCII-8BIT")
-
-      data.each_byte.each_with_index do |byte, i|
-        masked_data << byte ^ mask_key.chars[i%4]
-      end
+      WebSocket.frame_format(actual_payload_length, masked?)
     end
 
-    # The same algorithm applies regardless of the direction of the translation,
-    # e.g., the same steps are applied to mask the data as to unmask the data.
-    alias_method :unmask, :mask
-
     def reset_frame!
       @state = :header
 

data/lib/websocket/server_handshake.rb

@@ -1,9 +1,23 @@
 module WebSocket
   class ServerHandshake < Http::Response
 
-    def initialize(status = nil, version = "1.1", headers = {}, body = nil, &body_proc)
+    def initialize(status = 101, version = "1.1", headers = {}, body = nil, &body_proc)
       @status, @version, @body, @body_proc = status, version, body, body_proc
       @headers = headers
     end
+
+    def render(out)
+      response_header = "#{@version} #{@status} #{@reason}#{CRLF}"
+
+      unless @headers.empty?
+        response_header << @headers.map do |header, value|
+          "#{header}: #{value}"
+        end.join(CRLF) << CRLF
+      end
+
+      response_header << CRLF
+
+      out << response_header
+    end
   end
 end

data/lib/websocket/version.rb

@@ -1,3 +1,3 @@
 module WebSocket
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/websocket_parser.rb

@@ -5,6 +5,8 @@ require "websocket/message"
 require "websocket/parser"
 
 module WebSocket
+  extend self
+
   PROTOCOL_VERSION = 13 # RFC 6455
   GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
 
@@ -27,9 +29,54 @@ module WebSocket
     :pong         => 10
   }
 
-  FRAME_FORMAT = {
-    :small  => 'CCa',   # 2 bytes for header. N bytes for payload.
-    :medium => 'CCS<a', # 2 bytes for header. 2 bytes for extended length. N bytes for payload.
-    :large  => 'CCQ<a'  # 2 bytes for header. 4 bytes for extended length. N bytes for payload.
+  # See: http://tools.ietf.org/html/rfc6455#section-7.4.1
+  STATUS_CODES = {
+    1000 => :normal_closure,
+    1001 => :peer_going_away,
+    1002 => :protocol_error,
+    1003 => :data_error,
+    1007 => :data_not_consistent,
+    1008 => :policy_violation,
+    1009 => :message_too_big,
+    1010 => :extension_required,
+    1011 => :unexpected_condition
   }
+
+  # Determines how to unpack the frame depending on
+  # the payload length and wether the frame is masked
+  def frame_format(payload_length, masked = false)
+    format = 'CC'
+
+    if payload_length > 65_535
+      format += 'Q<'
+    elsif payload_length > 125
+      format += 'S<'
+    end
+
+    if masked
+      format += 'a4'
+    end
+
+    if payload_length > 0
+      format += "a#{payload_length}"
+    end
+
+    format
+  end
+
+  def mask(data, mask_key)
+    masked_data = ''.encode!("ASCII-8BIT")
+    mask_bytes = mask_key.bytes.to_a
+
+    data.bytes.each_with_index do |byte, i|
+      masked_data << (byte ^ mask_bytes[i%4])
+    end
+
+    masked_data
+  end
+
+  # The same algorithm applies regardless of the direction of the translation,
+  # e.g., the same steps are applied to mask the data as to unmask the data.
+  alias_method :unmask, :mask
+
 end

data/spec/websocket/message_spec.rb

@@ -17,4 +17,26 @@ describe WebSocket::Message do
     ext_length.should  == text.length
     payload.should     == text
   end
+
+  it "can be masked" do
+    message = WebSocket::Message.new('The man with the Iron Mask')
+    message.masked?.should be_false
+
+    message.mask!
+
+    message.masked?.should be_true
+  end
+
+  it "allows status codes for control frames" do
+    msg = WebSocket::Message.close(1001, 'Bye')
+
+    msg.status_code.should == 1001
+    msg.payload.should == [1001, 'Bye'].pack('S<a*')
+    msg.status.should == :peer_going_away
+    msg.status_message.should == 'Bye'
+  end
+
+  it "does not allow a status message without status code" do
+    expect{ WebSocket::Message.close(nil, 'Bye') }.to raise_error(ArgumentError)
+  end
 end

data/spec/websocket/parser_spec.rb

@@ -13,9 +13,9 @@ describe WebSocket::Parser do
 
     parser.on_message { |m| received_messages << m }
     parser.on_error   { |m| received_errors << m }
-    parser.on_close   { |m| received_closes << m }
-    parser.on_ping    { |m| received_pings << m }
-    parser.on_pong    { |m| received_pongs << m }
+    parser.on_close   { |status, message| received_closes << [status, message] }
+    parser.on_ping    { received_pings << 'ping' }
+    parser.on_pong    { received_pongs << 'pong' }
 
     parser
   end
@@ -93,20 +93,39 @@ describe WebSocket::Parser do
   end
 
   it "recognizes a ping message" do
-    parser << WebSocket::Message.ping('Oh, hai!').to_data
+    parser << WebSocket::Message.ping.to_data
 
-    received_pings.first.should == 'Oh, hai!'
+    received_pings.size.should == 1
   end
 
   it "recognizes a pong message" do
-    parser << WebSocket::Message.pong('Hi there!').to_data
+    parser << WebSocket::Message.pong.to_data
 
-    received_pongs.first.should == 'Hi there!'
+    received_pongs.size.should == 1
   end
 
-  it "recognizes a close message" do
-    parser << WebSocket::Message.close('Browser leaving page').to_data
+  it "recognizes a close message with status code and message" do
+    parser << WebSocket::Message.close(1001, 'Browser leaving page').to_data
 
-    received_closes.first.should == 'Browser leaving page'
+    status, message = received_closes.first
+    status.should  == :peer_going_away # Status code 1001
+    message.should == 'Browser leaving page'
+  end
+
+  it "recognizes a close message without status code" do
+    parser << WebSocket::Message.close.to_data
+
+    status, message = received_closes.first
+    status.should  be_nil
+    message.should be_empty
+  end
+
+  it "recognizes a masked frame" do
+    msg = WebSocket::Message.new('Once upon a time')
+    msg.mask!
+
+    parser << msg.to_data
+
+    received_messages.first.should == 'Once upon a time'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: websocket_parser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -96,7 +96,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3979494630006513518
+      hash: -3359756691541156568
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3979494630006513518
+      hash: -3359756691541156568
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23