faye-websocket 0.1.2 → 0.2.0

data/CHANGELOG.txt

@@ -0,0 +1,22 @@
+=== 0.2.0 / 2011-12-21
+
+* Add support for Sec-WebSocket-Protocol negotiation
+* Support hixie-76 close frames and 75/76 ignored segments
+* Improve performance of HyBi parsing/framing functions
+* Write masking function in C
+
+
+=== 0.1.2 / 2011-12-05
+
+* Make hixie-76 sockets work through HAProxy
+
+
+=== 0.1.1 / 2011-11-30
+
+* Fix add_event_listener() interface methods
+
+
+=== 0.1.0 / 2011-11-27
+
+* Initial release, based on WebSocket components from Faye
+

data/README.rdoc

@@ -59,8 +59,8 @@ is how you'd implement an echo server:
 
 The client supports both the plain-text +ws+ protocol and the encrypted +wss+
 protocol, and has exactly the same interface as a socket you would use in a web
-browser. On the wire it identifies itself as hybi-08, though it's compatible
-with servers speaking later versions of the protocol, at least up to version 17.
+browser. On the wire it identifies itself as hybi-13, though it's compatible
+with servers speaking later versions of the protocol.
 
     require 'faye/websocket'
     require 'eventmachine'
@@ -84,6 +84,26 @@ with servers speaking later versions of the protocol, at least up to version 17.
     }
 
 
+== Subprotocol negotiation
+
+The WebSocket protocol allows peers to select and identify the application
+protocol to use over the connection. On the client side, you can set which
+protocols the client accepts by passing a list of protocol names when you
+construct the socket:
+
+    ws = Faye::WebSocket::Client.new('ws://www.example.com/', ['irc', 'amqp'])
+
+On the server side, you can likewise pass in the list of protocols the server
+supports after the other constructor arguments:
+
+    ws = Faye::WebSocket.new(env, ['irc', 'amqp'])
+
+If the client and server agree on a protocol, both the client- and server-side
+socket objects expose the selected protocol through the <tt>ws.protocol</tt>
+property. If they cannot agree on a protocol to use, the client closes the
+connection.
+
+
 == WebSocket API
 
 The WebSocket API consists of several event handlers and a method for sending
@@ -105,6 +125,8 @@ messages.
   the other peer.
 * <b><tt>close(code, reason)</tt></b> closes the connection, sending the given
   status code and reason text, both of which are optional.
+* <b><tt>protocol</tt></b> is a string or +nil+ identifying the subprotocol th
+  socket is using.
 
 
 == License

data/examples/autobahn_client.rb

@@ -6,8 +6,7 @@ EM.run {
   host   = 'ws://localhost:9001'
   agent  = "Faye (Ruby #{RUBY_VERSION})"
   cases  = 0
-  skip   = [247,248,249,250,251,252,253,254,255,
-            256,257,258,259,260,261,262,263,264]
+  skip   = []
   
   socket = Faye::WebSocket::Client.new("#{host}/getCaseCount")
   

data/examples/index.html

@@ -12,14 +12,19 @@
     <script type="text/javascript">
       var logger = document.getElementsByTagName('ul')[0],
           Socket = window.MozWebSocket || window.WebSocket,
-          socket = new Socket('ws://' + location.hostname + ':' + location.port + '/'),
+          protos = ['foo', 'bar', 'xmpp'],
+          socket = new Socket('ws://' + location.hostname + ':' + location.port + '/', protos),
           index  = 0;
       
       socket.onopen = function() {
-        logger.innerHTML += '<li>OPEN</li>';
+        logger.innerHTML += '<li>OPEN: ' + socket.protocol + '</li>';
         socket.send('Hello, world');
       };
       
+      socket.onerror = function(event) {
+        logger.innerHTML += '<li>ERROR: ' + error.message + '</li>';
+      };
+      
       socket.addEventListener('message', function(event) {
         logger.innerHTML += '<li>MESSAGE: ' + event.data + '</li>';
         setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);

data/examples/server.rb

@@ -10,8 +10,8 @@ static = Rack::File.new(File.dirname(__FILE__))
 
 app = lambda do |env|
   if env['HTTP_UPGRADE']
-    socket = Faye::WebSocket.new(env)
-    p [:open, socket.url, socket.version]
+    socket = Faye::WebSocket.new(env, ['irc', 'xmpp'])
+    p [:open, socket.url, socket.version, socket.protocol]
     
     socket.onmessage = lambda do |event|
       socket.send(event.data)

data/ext/faye_websocket_mask/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+extension_name = 'faye_websocket_mask'
+dir_config(extension_name)
+create_makefile(extension_name)
+

data/ext/faye_websocket_mask/faye_websocket_mask.c

@@ -0,0 +1,35 @@
+#include <ruby.h>
+
+VALUE Faye = Qnil;
+VALUE FayeWebSocket = Qnil;
+VALUE FayeWebSocketMask = Qnil;
+
+void Init_faye_websocket_mask();
+VALUE method_faye_websocket_mask(VALUE self, VALUE payload, VALUE mask);
+
+void Init_faye_websocket_mask() {
+  Faye = rb_define_module("Faye");
+  FayeWebSocket = rb_define_class_under(Faye, "WebSocket", rb_cObject);
+  FayeWebSocketMask = rb_define_module_under(FayeWebSocket, "Mask");
+  rb_define_singleton_method(FayeWebSocketMask, "mask", method_faye_websocket_mask, 2);
+}
+
+VALUE method_faye_websocket_mask(VALUE self, VALUE payload, VALUE mask) {
+  int n = RARRAY_LEN(payload), i, p, m;
+  VALUE unmasked = rb_ary_new2(n);
+  
+  int mask_array[] = {
+    NUM2INT(rb_ary_entry(mask, 0)),
+    NUM2INT(rb_ary_entry(mask, 1)),
+    NUM2INT(rb_ary_entry(mask, 2)),
+    NUM2INT(rb_ary_entry(mask, 3))
+  };
+  
+  for (i = 0; i < n; i++) {
+    p = NUM2INT(rb_ary_entry(payload, i));
+    m = mask_array[i % 4];
+    rb_ary_store(unmasked, i, INT2NUM(p ^ m));
+  }
+  return unmasked;
+}
+

data/lib/faye/websocket.rb

@@ -22,12 +22,13 @@ module Faye
   class WebSocket
     
     root = File.expand_path('../websocket', __FILE__)
+    require root + '/../../faye_websocket_mask'
     
     autoload :API,             root + '/api'
     autoload :Client,          root + '/client'
     autoload :Draft75Parser,   root + '/draft75_parser'
     autoload :Draft76Parser,   root + '/draft76_parser'
-    autoload :Protocol8Parser, root + '/protocol8_parser'
+    autoload :HybiParser,      root + '/hybi_parser'
     
     # http://www.w3.org/International/questions/qa-forms-utf-8.en.php
     UTF8_MATCH = /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/
@@ -47,7 +48,7 @@ module Faye
     
     def self.parser(env)
       if env['HTTP_SEC_WEBSOCKET_VERSION']
-        Protocol8Parser
+        HybiParser
       elsif env['HTTP_SEC_WEBSOCKET_KEY1']
         Draft76Parser
       else
@@ -61,7 +62,7 @@ module Faye
     attr_reader :env
     include API
     
-    def initialize(env)
+    def initialize(env, supported_protos = nil)
       @env      = env
       @callback = @env['async.callback']
       @stream   = Stream.new(self, @env['em.connection'])
@@ -71,7 +72,7 @@ module Faye
       @ready_state = CONNECTING
       @buffered_amount = 0
       
-      @parser = WebSocket.parser(@env).new(self)
+      @parser = WebSocket.parser(@env).new(self, :protocols => supported_protos)
       @stream.write(@parser.handshake_response)
       
       @ready_state = OPEN
@@ -86,6 +87,10 @@ module Faye
       end
     end
     
+    def protocol
+      @parser.protocol || ''
+    end
+    
   private
     
     def determine_url

data/lib/faye/websocket/client.rb

@@ -3,13 +3,14 @@ module Faye
     
     class Client
       include API
-      attr_reader :uri
+      attr_reader :protocol, :uri
       
-      def initialize(url)
-        @parser = Protocol8Parser.new(self, :masking => true)
+      def initialize(url, protocols = nil)
+        @parser = HybiParser.new(self, :masking => true, :protocols => protocols)
         @url    = url
         @uri    = URI.parse(url)
         
+        @protocol = ''
         @ready_state = CONNECTING
         @buffered_amount = 0
         
@@ -39,6 +40,7 @@ module Faye
             return unless @handshake.complete?
             
             if @handshake.valid?
+              @protocol = @handshake.protocol || ''
               @ready_state = OPEN
               event = Event.new('open')
               event.init_event('open', false, false)
@@ -47,8 +49,8 @@ module Faye
               receive_data(@message)
             else
               @ready_state = CLOSED
-              event = Event.new('error')
-              event.init_event('error', false, false)
+              event = Event.new('close', :code => 1006, :reason => '')
+              event.init_event('close', false, false)
               dispatch_event(event)
             end
             

data/lib/faye/websocket/draft75_parser.rb

@@ -2,14 +2,15 @@ module Faye
   class WebSocket
     
     class Draft75Parser
-      def initialize(web_socket)
-        @socket    = web_socket
-        @buffer    = []
-        @buffering = false
+      attr_reader :protocol
+      
+      def initialize(web_socket, options = {})
+        @socket = web_socket
+        @stage  = 0
       end
       
       def version
-        'draft-75'
+        'hixie-75'
       end
       
       def handshake_response
@@ -22,30 +23,58 @@ module Faye
         upgrade
       end
       
-      def parse(data)
-        data.each_byte(&method(:handle_byte))
+      def parse(buffer)
+        buffer.each_byte do |data|
+          case @stage
+            when 0 then
+              parse_leading_byte(data)
+              
+            when 1 then
+              value = (data & 0x7F)
+              @length = value + 128 * @length
+              
+              if @closing and @length.zero?
+                @socket.close(nil, nil, false)
+              elsif (0x80 & data) != 0x80
+                if @length.zero?
+                  @socket.receive('')
+                  @stage = 0
+                else
+                  @buffer = []
+                  @stage = 2
+                end
+              end
+              
+            when 2 then
+              if data == 0xFF
+                @socket.receive(WebSocket.encode(@buffer))
+                @stage = 0
+              else
+                @buffer << data
+                if @length and @buffer.size == @length
+                  @stage = 0
+                end
+              end
+          end
+        end
+        
         nil
       end
       
-      def frame(data, type = nil, error_type = nil)
-        ["\x00", data, "\xFF"].map(&WebSocket.method(:encode)) * ''
+      def parse_leading_byte(data)
+        if (0x80 & data) == 0x80
+          @length = 0
+          @stage = 1
+        else
+          @length = nil
+          @buffer = []
+          @stage = 2
+        end
       end
       
-    private
-      
-      def handle_byte(data)
-        case data
-          when 0x00 then
-            @buffering = true
-            
-          when 0xFF then
-            @socket.receive(WebSocket.encode(@buffer))
-            @buffer = []
-            @buffering = false
-            
-          else
-            @buffer.push(data) if @buffering
-        end
+      def frame(data, type = nil, error_type = nil)
+        return WebSocket.encode(data) if Array === data
+        ["\x00", data, "\xFF"].map(&WebSocket.method(:encode)) * ''
       end
     end
     

data/lib/faye/websocket/draft76_parser.rb

@@ -3,7 +3,7 @@ module Faye
     
     class Draft76Parser < Draft75Parser
       def version
-        'draft-76'
+        'hixie-76'
       end
       
       def handshake_response
@@ -42,8 +42,22 @@ module Faye
         handshake_signature(data)
       end
       
+      def close(code = nil, reason = nil, &callback)
+        return if @closed
+        @socket.send([0xFF, 0x00]) if @closing
+        @closed = true
+        callback.call if callback
+      end
+      
     private
       
+      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

data/lib/faye/websocket/{protocol8_parser.rb → hybi_parser.rb}

@@ -1,16 +1,19 @@
 module Faye
   class WebSocket
-    
-    class Protocol8Parser
-      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
-      
+
+    class HybiParser
+      root = File.expand_path('../hybi_parser', __FILE__)
+      autoload :Handshake, root + '/handshake'
+      autoload :StreamReader, root + '/stream_reader'
+
+      BYTE       = 0b11111111
       FIN = MASK = 0b10000000
       RSV1       = 0b01000000
       RSV2       = 0b00100000
       RSV3       = 0b00010000
       OPCODE     = 0b00001111
       LENGTH     = 0b01111111
-      
+
       OPCODES = {
         :continuation => 0,
         :text         => 1,
@@ -19,10 +22,10 @@ module Faye
         :ping         => 9,
         :pong         => 10
       }
-      
+
       FRAGMENTED_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
       OPENING_OPCODES = OPCODES.values_at(:text, :binary)
-      
+
       ERRORS = {
         :normal_closure   => 1000,
         :going_away       => 1001,
@@ -33,214 +36,201 @@ module Faye
         :too_large        => 1009,
         :extension_error  => 1010
       }
-      
+
       ERROR_CODES = ERRORS.values
-      
-      class Handshake
-        def initialize(uri)
-          @uri    = uri
-          @key    = Base64.encode64((1..16).map { rand(255).chr } * '').strip
-          @accept = Base64.encode64(Digest::SHA1.digest(@key + GUID)).strip
-          @buffer = []
-        end
-        
-        def request_data
-          hostname = @uri.host + (@uri.port ? ":#{@uri.port}" : '')
-          
-          handshake  = "GET #{@uri.path}#{@uri.query ? '?' : ''}#{@uri.query} HTTP/1.1\r\n"
-          handshake << "Host: #{hostname}\r\n"
-          handshake << "Upgrade: websocket\r\n"
-          handshake << "Connection: Upgrade\r\n"
-          handshake << "Sec-WebSocket-Key: #{@key}\r\n"
-          handshake << "Sec-WebSocket-Version: 8\r\n"
-          handshake << "\r\n"
-          
-          handshake
-        end
-        
-        def parse(data)
-          message  = []
-          complete = false
-          data.each_byte do |byte|
-            if complete
-              message << byte
-            else
-              @buffer << byte
-              complete ||= complete?
-            end
-          end
-          message
-        end
-        
-        def complete?
-          @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
-        end
-        
-        def valid?
-          data = WebSocket.encode(@buffer)
-          response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
-          return false unless response.code.to_i == 101
-          
-          upgrade, connection = response['Upgrade'], response['Connection']
-          
-          upgrade and upgrade =~ /^websocket$/i and
-          connection and connection.split(/\s*,\s*/).include?('Upgrade') and
-          response['Sec-WebSocket-Accept'] == @accept
-        end
-      end
-      
+
+      attr_reader :protocol
+
       def initialize(web_socket, options = {})
         reset
-        @socket  = web_socket
-        @stage   = 0
-        @masking = options[:masking]
+        @socket    = web_socket
+        @reader    = StreamReader.new
+        @stage     = 0
+        @masking   = options[:masking]
+        @protocols = options[:protocols]
+
+        @protocols = @protocols.split(/\s*,\s*/) if String === @protocols
       end
-      
+
       def version
-        "protocol-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
+        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
       end
-      
+
       def handshake_response
         sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
         return '' unless String === sec_key
-        
-        accept = Base64.encode64(Digest::SHA1.digest(sec_key + GUID)).strip
-        
-        upgrade =  "HTTP/1.1 101 Switching Protocols\r\n"
-        upgrade << "Upgrade: websocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "Sec-WebSocket-Accept: #{accept}\r\n"
-        upgrade << "\r\n"
-        upgrade
+
+        accept    = Base64.encode64(Digest::SHA1.digest(sec_key + Handshake::GUID)).strip
+        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 and supported
+          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 create_handshake
-        Handshake.new(@socket.uri)
+        Handshake.new(@socket.uri, @protocols)
       end
-      
+
       def parse(data)
-        data.each_byte do |byte|
+        @reader.put(data.bytes.to_a)
+        buffer = true
+        while buffer
           case @stage
-          when 0 then parse_opcode(byte)
-          when 1 then parse_length(byte)
-          when 2 then parse_extended_length(byte)
-          when 3 then parse_mask(byte)
-          when 4 then parse_payload(byte)
+            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
-          emit_frame if @stage == 4 and @length == 0
         end
+
         nil
       end
-      
+
       def frame(data, type = nil, code = nil)
         return nil if @closed
-        
-        type ||= (String === data ? :text : :binary)
-        data   = data.bytes.to_a if data.respond_to?(:bytes)
-        
-        if code
-          data = [code].pack('n').bytes.to_a + 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
-        
-        frame  = (FIN | OPCODES[type]).chr
-        length = data.size
-        masked = @masking ? MASK : 0
-        
-        case length
-          when 0..125 then
-            frame << (masked | length).chr
-          when 126..65535 then
-            frame << (masked | 126).chr
-            frame << [length].pack('n')
-          else
-            frame << (masked | 127).chr
-            frame << [length >> 32, length & 0xFFFFFFFF].pack('NN')
+
+        if code
+          buffer = [(code >> 8) & BYTE, code & BYTE] + buffer
         end
-        
+
         if @masking
-          mask = (1..4).map { rand 256 }
-          data.each_with_index do |byte, i|
-            data[i] = byte ^ mask[i % 4]
-          end
-          frame << mask.pack('C*')
+          mask = [rand(256), rand(256), rand(256), rand(256)]
+          frame[header...offset] = mask
+          buffer = Mask.mask(buffer, mask)
         end
-        
-        WebSocket.encode(frame) + WebSocket.encode(data)
+
+        frame.concat(buffer)
+
+        WebSocket.encode(frame)
       end
-      
+
       def close(code = nil, reason = nil, &callback)
         return if @closed
         @closing_callback ||= callback
         @socket.send(reason || '', :close, code || ERRORS[:normal_closure])
         @closed = true
       end
-      
+
     private
-      
+
       def parse_opcode(data)
         if [RSV1, RSV2, RSV3].any? { |rsv| (data & rsv) == rsv }
           return @socket.close(ERRORS[:protocol_error], nil, false)
         end
-        
+
         @final   = (data & FIN) == FIN
         @opcode  = (data & OPCODE)
         @mask    = []
         @payload = []
-        
+
         unless OPCODES.values.include?(@opcode)
           return @socket.close(ERRORS[:protocol_error], nil, false)
         end
-        
+
         unless FRAGMENTED_OPCODES.include?(@opcode) or @final
           return @socket.close(ERRORS[:protocol_error], nil, false)
         end
-        
+
         if @mode and OPENING_OPCODES.include?(@opcode)
           return @socket.close(ERRORS[:protocol_error], nil, false)
         end
-        
+
         @stage = 1
       end
-      
+
       def parse_length(data)
         @masked = (data & MASK) == MASK
         @length = (data & LENGTH)
-        
+
         if @length <= 125
           @stage = @masked ? 3 : 4
         else
-          @length_buffer = []
-          @length_size   = (@length == 126) ? 2 : 8
-          @stage         = 2
+          @length_size = (@length == 126) ? 2 : 8
+          @stage       = 2
         end
       end
-      
-      def parse_extended_length(data)
-        @length_buffer << data
-        return unless @length_buffer.size == @length_size
-        @length = integer(@length_buffer)
+
+      def parse_extended_length(buffer)
+        @length = integer(buffer)
         @stage  = @masked ? 3 : 4
       end
-      
-      def parse_mask(data)
-        @mask << data
-        return if @mask.size < 4
-        @stage = 4
-      end
-      
-      def parse_payload(data)
-        @payload << data
-        return if @payload.size < @length
-        emit_frame
-      end
-      
+
       def emit_frame
-        payload = unmask(@payload, @mask)
-        
+        payload = @masked ? Mask.mask(@payload, @mask) : @payload
+
         case @opcode
           when OPCODES[:continuation] then
             return @socket.close(ERRORS[:protocol_error], nil, false) unless @mode
-            @buffer += payload
+            @buffer.concat(payload)
             if @final
               message = @buffer
               message = WebSocket.encode(message, true) if @mode == :text
@@ -262,7 +252,7 @@ module Faye
               end
             else
               @mode = :text
-              @buffer += payload
+              @buffer.concat(payload)
             end
 
           when OPCODES[:binary] then
@@ -270,22 +260,22 @@ module Faye
               @socket.receive(payload)
             else
               @mode = :binary
-              @buffer += payload
+              @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 >= 3000 && code < 5000) or
                    ERROR_CODES.include?(code)
               code = ERRORS[:protocol_error]
             end
-            
+
             if payload.size > 125 or not WebSocket.valid_utf8?(payload[2..-1] || [])
               code = ERRORS[:protocol_error]
             end
-            
+
             reason = (payload.size > 2) ? WebSocket.encode(payload[2..-1], true) : nil
             @socket.close(code, reason, false)
             @closing_callback.call if @closing_callback
@@ -294,14 +284,13 @@ module Faye
             return @socket.close(ERRORS[:protocol_error], nil, false) if payload.size > 125
             @socket.send(payload, :pong)
         end
-        @stage = 0
       end
 
       def reset
         @buffer = []
         @mode   = nil
       end
-      
+
       def integer(bytes)
         number = 0
         bytes.each_with_index do |data, i|
@@ -309,17 +298,7 @@ module Faye
         end
         number
       end
-      
-      def unmask(payload, mask)
-        unmasked = []
-        payload.each_with_index do |byte, i|
-          byte = byte ^ mask[i % 4] if mask.size > 0
-          unmasked << byte
-        end
-        unmasked
-      end
     end
-    
+
   end
 end
-