faye 0.6.8 → 0.7.0

data/lib/faye/util/web_socket.rb

@@ -1,135 +1,89 @@
 module Faye
   class WebSocket
     
-    autoload :Draft75Parser, File.expand_path('..', __FILE__) + '/web_socket/draft75_parser'
-    autoload :Draft76Parser, File.expand_path('..', __FILE__) + '/web_socket/draft76_parser'
-    autoload :Protocol8Parser, File.expand_path('..', __FILE__) + '/web_socket/protocol8_parser'
+    root = File.expand_path('..', __FILE__) + '/web_socket'
     
-    include Publisher
+    autoload :API,             root + '/api'
+    autoload :Client,          root + '/client'
+    autoload :Draft75Parser,   root + '/draft75_parser'
+    autoload :Draft76Parser,   root + '/draft76_parser'
+    autoload :Protocol8Parser, root + '/protocol8_parser'
     
-    CONNECTING = 0
-    OPEN       = 1
-    CLOSING    = 2
-    CLOSED     = 3
-    
-    attr_reader   :request, :url, :ready_state
-    attr_accessor :onopen, :onmessage, :onerror, :onclose
+    attr_reader :env
+    include API
     
     extend Forwardable
     def_delegators :@parser, :version
     
-    def self.parser(request)
-      if request.env['HTTP_SEC_WEBSOCKET_VERSION']
+    def self.parser(env)
+      if env['HTTP_SEC_WEBSOCKET_VERSION']
         Protocol8Parser
-      elsif request.env['HTTP_SEC_WEBSOCKET_KEY1']
+      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
         Draft76Parser
       else
         Draft75Parser
       end
     end
     
-    def initialize(request)
-      @request  = request
-      @callback = @request.env['async.callback']
-      @stream   = Stream.new
+    def initialize(env)
+      @env      = env
+      @callback = @env['async.callback']
+      @stream   = Stream.new(self, @env['em.connection'])
       @callback.call [200, RackAdapter::TYPE_JSON, @stream]
       
       @url = determine_url
       @ready_state = CONNECTING
       @buffered_amount = 0
       
-      @parser = WebSocket.parser(@request).new(self)
+      @parser = WebSocket.parser(@env).new(self)
       @stream.write(@parser.handshake_response)
       
       @ready_state = OPEN
       
-      event = Event.new
+      event = Event.new('open')
       event.init_event('open', false, false)
       dispatch_event(event)
       
-      @request.env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK] = @parser.method(:parse)
-    end
-    
-    def receive(data)
-      event = Event.new
-      event.init_event('message', false, false)
-      event.data = Faye.encode(data)
-      dispatch_event(event)
-    end
-    
-    def send(data, type = nil, error_type = nil)
-      frame = @parser.frame(Faye.encode(data), type, error_type)
-      @stream.write(frame) if frame
-    end
-    
-    def close(*args)
-    end
-    
-    def add_event_listener(type, listener, use_capture)
-      add_subscriber(type, listener)
-    end
-    
-    def remove_event_listener(type, listener, use_capture)
-      remove_subscriber(type, listener)
-    end
-    
-    def dispatch_event(event)
-      event.target = event.current_target = self
-      event.event_phase = Event::AT_TARGET
-      
-      publish_event(event.type, event)
-      callback = __send__("on#{ event.type }")
-      callback.call(event) if callback
+      @env[Thin::Request::WEBSOCKET_RECEIVE_CALLBACK] = @parser.method(:parse)
     end
     
   private
     
     def determine_url
-      env = @request.env
-      secure = if env.has_key?('HTTP_X_FORWARDED_PROTO')
-                 env['HTTP_X_FORWARDED_PROTO'] == 'https'
+      secure = if @env.has_key?('HTTP_X_FORWARDED_PROTO')
+                 @env['HTTP_X_FORWARDED_PROTO'] == 'https'
                else
-                 env['HTTP_ORIGIN'] =~ /^https:/i
+                 @env['HTTP_ORIGIN'] =~ /^https:/i
                end
       
       scheme = secure ? 'wss:' : 'ws:'
-      "#{ scheme }//#{ env['HTTP_HOST'] }#{ env['REQUEST_URI'] }"
+      "#{ scheme }//#{ @env['HTTP_HOST'] }#{ @env['REQUEST_URI'] }"
     end
   end
   
   class WebSocket::Stream
     include EventMachine::Deferrable
     
-    def each(&callback)
-      @data_callback = callback
-    end
+    extend Forwardable
+    def_delegators :@connection, :close_connection, :close_connection_after_writing
     
-    def write(data)
-      return unless @data_callback
-      @data_callback.call(data)
+    def initialize(web_socket, connection)
+      @web_socket = web_socket
+      @connection = connection
     end
-  end
-  
-  class WebSocket::Event
-    attr_reader   :type, :bubbles, :cancelable
-    attr_accessor :target, :current_target, :event_phase, :data
-    
-    CAPTURING_PHASE = 1
-    AT_TARGET       = 2
-    BUBBLING_PHASE  = 3
     
-    def init_event(event_type, can_bubble, cancelable)
-      @type       = event_type
-      @bubbles    = can_bubble
-      @cancelable = cancelable
+    def each(&callback)
+      @data_callback = callback
     end
     
-    def stop_propagation
+    def fail
+      @web_socket.close(1006, '', false)
     end
     
-    def prevent_default
+    def write(data)
+      return unless @data_callback
+      @data_callback.call(data)
     end
   end
   
 end
-

data/lib/faye/util/web_socket/api.rb

@@ -0,0 +1,103 @@
+module Faye
+  class WebSocket
+    
+    CONNECTING = 0
+    OPEN       = 1
+    CLOSING    = 2
+    CLOSED     = 3
+    
+    module API
+      attr_reader   :url, :ready_state, :buffered_amount
+      attr_accessor :onopen, :onmessage, :onerror, :onclose
+      
+      include Publisher
+      
+      def receive(data)
+        return false unless ready_state == OPEN
+        event = Event.new('message')
+        event.init_event('message', false, false)
+        event.data = data
+        dispatch_event(event)
+      end
+      
+      def send(data, type = nil, error_type = nil)
+        return false if ready_state == CLOSED
+        data = Faye.encode(data) if String === data
+        frame = @parser.frame(data, type, error_type)
+        @stream.write(frame) if frame
+      end
+      
+      def close(code = nil, reason = nil, ack = true)
+        return if [CLOSING, CLOSED].include?(ready_state)
+        
+        @ready_state = CLOSING
+        
+        close = lambda do
+          @ready_state = CLOSED
+          @stream.close_connection_after_writing
+          event = Event.new('close', :code => code || 1000, :reason => reason || '')
+          event.init_event('close', false, false)
+          dispatch_event(event)
+        end
+        
+        if ack
+          if @parser.respond_to?(:close)
+            @parser.close(code, reason, &close)
+          else
+            close.call
+          end
+        else
+          @parser.close(code, reason) if @parser.respond_to?(:close)
+          close.call
+        end
+      end
+      
+      def add_event_listener(type, listener, use_capture)
+        bind(type, listener)
+      end
+      
+      def remove_event_listener(type, listener, use_capture)
+        unbind(type, listener)
+      end
+      
+      def dispatch_event(event)
+        event.target = event.current_target = self
+        event.event_phase = Event::AT_TARGET
+        
+        trigger(event.type, event)
+        callback = __send__("on#{ event.type }")
+        callback.call(event) if callback
+      end
+    end
+    
+    class Event
+      attr_reader   :type, :bubbles, :cancelable
+      attr_accessor :target, :current_target, :event_phase, :data
+      
+      CAPTURING_PHASE = 1
+      AT_TARGET       = 2
+      BUBBLING_PHASE  = 3
+      
+      def initialize(event_type, options = {})
+        @type = event_type
+        metaclass = (class << self ; self ; end)
+        options.each do |key, value|
+          metaclass.__send__(:define_method, key) { value }
+        end
+      end
+      
+      def init_event(event_type, can_bubble, cancelable)
+        @type       = event_type
+        @bubbles    = can_bubble
+        @cancelable = cancelable
+      end
+      
+      def stop_propagation
+      end
+      
+      def prevent_default
+      end
+    end
+    
+  end
+end

data/lib/faye/util/web_socket/client.rb

@@ -0,0 +1,82 @@
+module Faye
+  class WebSocket
+    
+    class Client
+      include API
+      attr_reader :uri
+      
+      def initialize(url)
+        @parser = Protocol8Parser.new(self, :masking => true)
+        @url    = url
+        @uri    = URI.parse(url)
+        
+        @ready_state = CONNECTING
+        @buffered_amount = 0
+        
+        port = @uri.port || (@uri.scheme == 'wss' ? 443 : 80)
+        
+        EventMachine.connect(@uri.host, port, Connection) do |conn|
+          @stream = conn
+          conn.parent = self
+        end
+      end
+      
+    private
+      
+      def on_connect
+        @stream.start_tls if @uri.scheme == 'wss'
+        @handshake = @parser.create_handshake
+        @message = []
+        @stream.write(@handshake.request_data)
+      end
+      
+      def receive_data(data)
+        data = Faye.encode(data)
+        
+        case @ready_state
+          when CONNECTING then
+            @message += @handshake.parse(data)
+            return unless @handshake.complete?
+            
+            if @handshake.valid?
+              @ready_state = OPEN
+              event = Event.new('open')
+              event.init_event('open', false, false)
+              dispatch_event(event)
+              
+              receive_data(@message)
+            else
+              @ready_state = CLOSED
+              event = Event.new('error')
+              event.init_event('error', false, false)
+              dispatch_event(event)
+            end
+            
+          when OPEN, CLOSING then
+            @parser.parse(data)
+        end
+      end
+      
+      module Connection
+        attr_accessor :parent
+        
+        def connection_completed
+          parent.__send__(:on_connect)
+        end
+        
+        def receive_data(data)
+          parent.__send__(:receive_data, data)
+        end
+        
+        def unbind
+          parent.close(1006, '', false)
+        end
+        
+        def write(data)
+          send_data(data)
+        end
+      end
+    end
+    
+  end
+end

data/lib/faye/util/web_socket/draft75_parser.rb

@@ -13,12 +13,10 @@ module Faye
       end
       
       def handshake_response
-        request = @socket.request
-        
         upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
         upgrade << "Upgrade: WebSocket\r\n"
         upgrade << "Connection: Upgrade\r\n"
-        upgrade << "WebSocket-Origin: #{request.env['HTTP_ORIGIN']}\r\n"
+        upgrade << "WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
         upgrade << "WebSocket-Location: #{@socket.url}\r\n"
         upgrade << "\r\n"
         upgrade
@@ -40,12 +38,12 @@ module Faye
             @buffering = true
             
           when 0xFF then
-            @socket.receive(Faye.encode(@buffer.join('')))
+            @socket.receive(Faye.encode(@buffer))
             @buffer = []
             @buffering = false
             
           else
-            @buffer.push(data.chr) if @buffering
+            @buffer.push(data) if @buffering
         end
       end
     end

data/lib/faye/util/web_socket/draft76_parser.rb

@@ -1,5 +1,3 @@
-require 'digest/md5'
-
 module Faye
   class WebSocket
     
@@ -9,22 +7,22 @@ module Faye
       end
       
       def handshake_response
-        request = @socket.request
+        env = @socket.env
         
-        key1   = request.env['HTTP_SEC_WEBSOCKET_KEY1']
+        key1   = env['HTTP_SEC_WEBSOCKET_KEY1']
         value1 = number_from_key(key1) / spaces_in_key(key1)
         
-        key2   = request.env['HTTP_SEC_WEBSOCKET_KEY2']
+        key2   = env['HTTP_SEC_WEBSOCKET_KEY2']
         value2 = number_from_key(key2) / spaces_in_key(key2)
         
         hash = Digest::MD5.digest(big_endian(value1) +
                                   big_endian(value2) +
-                                  request.body.read)
+                                  env['rack.input'].read)
         
         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: #{request.env['HTTP_ORIGIN']}\r\n"
+        upgrade << "Sec-WebSocket-Origin: #{env['HTTP_ORIGIN']}\r\n"
         upgrade << "Sec-WebSocket-Location: #{@socket.url}\r\n"
         upgrade << "\r\n"
         upgrade << hash

data/lib/faye/util/web_socket/protocol8_parser.rb

@@ -1,7 +1,3 @@
-require 'base64'
-require 'digest/sha1'
-require 'net/http'
-
 module Faye
   class WebSocket
     
@@ -24,15 +20,22 @@ module Faye
         :pong         => 10
       }
       
+      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,
-        :too_large      => 1004,
-        :encoding_error => 1007
+        :normal_closure   => 1000,
+        :going_away       => 1001,
+        :protocol_error   => 1002,
+        :unacceptable     => 1003,
+        :encoding_error   => 1007,
+        :policy_violation => 1008,
+        :too_large        => 1009,
+        :extension_error  => 1010
       }
       
+      ERROR_CODES = ERRORS.values
+      
       class Handshake
         def initialize(uri)
           @uri    = uri
@@ -44,7 +47,7 @@ module Faye
         def request_data
           hostname = @uri.host + (@uri.port ? ":#{@uri.port}" : '')
           
-          handshake  = "GET #{@uri.path} HTTP/1.1\r\n"
+          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"
@@ -56,15 +59,25 @@ module Faye
         end
         
         def parse(data)
-          data.each_byte { |b| @buffer << b.chr }
+          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] == ["\r", "\n", "\r", "\n"]
+          @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
         end
         
         def valid?
-          data = Faye.encode(@buffer * '')
+          data = Faye.encode(@buffer)
           response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
           return false unless response.code.to_i == 101
           
@@ -76,10 +89,11 @@ module Faye
         end
       end
       
-      def initialize(web_socket)
+      def initialize(web_socket, options = {})
         reset
-        @socket = web_socket
-        @stage  = 0
+        @socket  = web_socket
+        @stage   = 0
+        @masking = options[:masking]
       end
       
       def version
@@ -87,7 +101,7 @@ module Faye
       end
       
       def handshake_response
-        sec_key = @socket.request.env['HTTP_SEC_WEBSOCKET_KEY']
+        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
         return '' unless String === sec_key
         
         accept = Base64.encode64(Digest::SHA1.digest(sec_key + GUID)).strip
@@ -113,59 +127,85 @@ module Faye
           when 3 then parse_mask(byte)
           when 4 then parse_payload(byte)
           end
+          emit_frame if @stage == 4 and @length == 0
         end
       end
       
-      def frame(data, type = nil, error_type = nil)
+      def frame(data, type = nil, code = nil)
         return nil if @closed
         
-        if error_type
-          data = [ERRORS[error_type]].pack('n') + data
+        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
         end
         
-        opcode = OPCODES[type || :text]
-        frame  = (FIN | opcode).chr
-        length = data.respond_to?(:bytes) ? data.bytes.count : data.size
+        frame  = (FIN | OPCODES[type]).chr
+        length = data.size
+        masked = @masking ? MASK : 0
         
         case length
           when 0..125 then
-            frame << length
+            frame << (masked | length).chr
           when 126..65535 then
-            frame << 126
+            frame << (masked | 126).chr
             frame << [length].pack('n')
           else
-            frame << 127
+            frame << (masked | 127).chr
             frame << [length >> 32, length & 0xFFFFFFFF].pack('NN')
         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*')
+        end
         
         Faye.encode(frame) + Faye.encode(data)
       end
       
-      def close(error_type = nil, &callback)
+      def close(code = nil, reason = nil, &callback)
         return if @closed
         @closing_callback ||= callback
-        @socket.send('', :close, error_type || :normal_closure)
+        @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 = []
         
-        return @socket.close(:protocol_error) unless OPCODES.values.include?(@opcode)
-        @stage   = 1
+        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 (1..125).include?(@length)
+        if @length <= 125
           @stage = @masked ? 3 : 4
         else
           @length_buffer = []
@@ -191,7 +231,6 @@ module Faye
         @payload << data
         return if @payload.size < @length
         emit_frame
-        @stage = 0
       end
       
       def emit_frame
@@ -199,32 +238,62 @@ module Faye
         
         case @opcode
           when OPCODES[:continuation] then
-            return unless @mode == :text
-            @buffer << payload
+            return @socket.close(ERRORS[:protocol_error], nil, false) unless @mode
+            @buffer += payload
             if @final
-              message = @buffer * ''
+              message = @buffer
+              message = Faye.encode(message, true) if @mode == :text
               reset
-              @socket.receive(Faye.encode(message))
+              if message
+                @socket.receive(message)
+              else
+                @socket.close(ERRORS[:encoding_error], nil, false)
+              end
             end
 
           when OPCODES[:text] then
             if @final
-              @socket.receive(Faye.encode(payload))
+              message = Faye.encode(payload, true)
+              if message
+                @socket.receive(message)
+              else
+                @socket.close(ERRORS[:encoding_error], nil, false)
+              end
             else
               @mode = :text
-              @buffer << payload
+              @buffer += payload
             end
 
           when OPCODES[:binary] then
-            @socket.close(:unacceptable)
+            if @final
+              @socket.receive(payload)
+            else
+              @mode = :binary
+              @buffer += payload
+            end
 
           when OPCODES[:close] then
-            @socket.close(:normal_closure)
+            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 Faye.valid_utf8?(payload[2..-1] || [])
+              code = ERRORS[:protocol_error]
+            end
+            
+            reason = (payload.size > 2) ? Faye.encode(payload[2..-1], true) : nil
+            @socket.close(code, reason, false)
             @closing_callback.call if @closing_callback
 
           when OPCODES[:ping] then
+            return @socket.close(ERRORS[:protocol_error], nil, false) if payload.size > 125
             @socket.send(payload, :pong)
         end
+        @stage = 0
       end
 
       def reset
@@ -232,10 +301,6 @@ module Faye
         @mode   = nil
       end
       
-      def getbyte(data, offset)
-        data.respond_to?(:getbyte) ? data.getbyte(offset) : data[offset]
-      end
-      
       def integer(bytes)
         number = 0
         bytes.each_with_index do |data, i|
@@ -245,7 +310,7 @@ module Faye
       end
       
       def unmask(payload, mask)
-        unmasked = ''
+        unmasked = []
         payload.each_with_index do |byte, i|
           byte = byte ^ mask[i % 4] if mask.size > 0
           unmasked << byte