websocket-rack 0.1.0

data/lib/rack/websocket/application.rb

@@ -0,0 +1,65 @@
+module Rack
+  module WebSocket
+    class Application
+
+      DEFAULT_OPTIONS = {}
+      attr_accessor :options
+
+      def on_open; end # Fired when a client is connected.
+      def on_message(msg); end # Fired when a message from a client is received.
+      def on_close; end # Fired when a client is disconnected.
+      def on_error(error); end # Fired when error occurs.
+
+      def initialize(*args)
+        app, options = args[0], args[1]
+        app, options = nil, app if app.is_a?(Hash)
+        @options = DEFAULT_OPTIONS.merge(options || {})
+        @app = app
+      end
+
+      def call(env)
+        if(env['HTTP_CONNECTION'].to_s.downcase == 'upgrade' && env['HTTP_UPGRADE'].to_s.downcase == 'websocket')
+          @env = env
+          socket = env['async.connection']
+          @connection = Connection.new(self, socket)
+          @connection.dispatch(env) ? async_response : failure_response
+        elsif @app
+          @app.call(env)
+        else
+          not_fount_response
+        end
+      end
+
+      def close_websocket
+        if @connection
+          @connection.close_websocket
+        else
+          raise WebSocketError, "WebSocket not opened"
+        end
+      end
+
+      def send_data(data)
+        if @connection
+          @connection.send data
+        else
+          raise WebSocketError, "WebSocket not opened"
+        end
+      end
+
+      protected
+
+      def async_response
+        [-1, {}, []]
+      end
+
+      def failure_response
+        [ 400, { "Content-Type" => "text/plain" }, [ 'invalid data' ] ]
+      end
+
+      def not_fount_response
+        [ 404, { "Content-Type" => "text/plain" }, [ 'not found' ] ]
+      end
+
+    end
+  end
+end

data/lib/rack/websocket/connection.rb

@@ -0,0 +1,105 @@
+require 'addressable/uri'
+
+module Rack
+  module WebSocket
+    class Connection
+      include Debugger
+
+      def initialize(app, socket, options = {})
+        @app = app
+        @socket = socket
+        @options = options
+        @debug = options[:debug] || false
+
+        socket.websocket = self
+
+        debug [:initialize]
+      end
+
+      def trigger_on_message(msg)
+        @app.on_message(msg)
+      end
+      def trigger_on_open
+        @app.on_open
+      end
+      def trigger_on_close
+        @app.on_close
+      end
+      def trigger_on_error(error)
+        @app.on_error(error)
+      end
+
+      def method_missing(sym, *args, &block)
+        @socket.send sym, *args, &block
+      end
+
+      # Use this method to close the websocket connection cleanly
+      # This sends a close frame and waits for acknowlegement before closing
+      # the connection
+      def close_websocket
+        if @handler
+          @handler.close_websocket
+        else
+          # The handshake hasn't completed - should be safe to terminate
+          close_connection
+        end
+      end
+
+      def receive_data(data)
+        debug [:receive_data, data]
+
+        @handler.receive_data(data)
+      end
+
+      def unbind
+        debug [:unbind, :connection]
+
+        @handler.unbind if @handler
+      end
+
+      def dispatch(data)
+        debug [:inbound_headers, data]
+        @handler = HandlerFactory.build(self, data, @debug)
+        unless @handler
+          # The whole header has not been received yet.
+          return false
+        end
+        @handler.run
+        return true
+      rescue => e
+        debug [:error, e]
+        process_bad_request(e)
+        return false
+      end
+
+      def process_bad_request(reason)
+        trigger_on_error(reason)
+        send_data "HTTP/1.1 400 Bad request\r\n\r\n"
+        close_connection_after_writing
+      end
+
+      def send(data)
+        debug [:send, data]
+
+        if @handler
+          @handler.send_text_frame(data)
+        else
+          raise WebSocketError, "Cannot send data before onopen callback"
+        end
+      end
+
+      def close_with_error(message)
+        trigger_on_error(message)
+        close_connection_after_writing
+      end
+
+      def request
+        @handler ? @handler.request : {}
+      end
+
+      def state
+        @handler ? @handler.state : :handshake
+      end
+    end
+  end
+end

data/lib/rack/websocket/debugger.rb

@@ -0,0 +1,17 @@
+module Rack
+  module WebSocket
+    module Debugger
+
+      private
+
+      def debug(*data)
+        if @debug
+          require 'pp'
+          pp data
+          puts
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/websocket/extensions/thin/connection.rb

@@ -0,0 +1,71 @@
+module Rack
+  module WebSocket
+    module Extensions
+      module Thin
+        module Connection
+
+          def self.included(thin_conn)
+            thin_conn.class_eval do
+              alias :pre_process_without_websocket :pre_process
+              alias :pre_process :pre_process_with_websocket
+
+              alias :receive_data_without_websocket :receive_data
+              alias :receive_data :receive_data_with_websocket
+
+              alias :unbind_without_websocket :unbind
+              alias :unbind :unbind_with_websocket
+
+              alias :receive_data_without_flash_policy_file :receive_data
+              alias :receive_data :receive_data_with_flash_policy_file
+            end
+          end
+
+          attr_accessor :websocket
+
+          def websocket?
+            !self.websocket.nil?
+          end
+
+          def pre_process_with_websocket
+            @request.env['async.connection'] = self
+            pre_process_without_websocket
+          end
+
+          def receive_data_with_websocket(data)
+            if self.websocket?
+              self.websocket.receive_data(data)
+            else
+              receive_data_without_websocket(data)
+            end
+          end
+
+          def unbind_with_websocket
+            if self.websocket?
+              self.websocket.unbind
+            else
+              unbind_without_websocket
+            end
+          end
+
+          def receive_data_with_flash_policy_file(data)
+            # thin require data to be proper http request - in it's not
+            # then @request.parse raises exception and data isn't parsed
+            # by futher methods. Here we only check if it is flash
+            # policy file request ("<policy-file-request/>\000") and
+            # if so then flash policy file is returned. if not then
+            # rest of request is handled.
+            if (data == "<policy-file-request/>\000")
+              file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
+              # ignore errors - we will close this anyway
+              send_data(file) rescue nil
+              close_connection_after_writing
+            else
+              receive_data_without_flash_policy_file(data)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/rack/websocket/extensions/thin.rb

@@ -0,0 +1,16 @@
+module Rack
+  module WebSocket
+    module Extensions
+      module Thin
+
+        autoload :Connection, "#{::File.dirname(__FILE__)}/thin/connection"
+
+        def self.included(thin)
+          thin_connection = thin.const_get(:Connection)
+          thin_connection.send(:include, Thin.const_get(:Connection))
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/websocket/framing03.rb

@@ -0,0 +1,178 @@
+# encoding: BINARY
+
+module Rack
+  module WebSocket
+    module Framing03
+      
+      def initialize_framing
+        @data = ''
+        @application_data_buffer = '' # Used for MORE frames
+      end
+      
+      def process_data(newdata)
+        error = false
+
+        while !error && @data.size > 1
+          pointer = 0
+
+          more = (@data.getbyte(pointer) & 0b10000000) == 0b10000000
+          # Ignoring rsv1-3 for now
+          opcode = @data.getbyte(0) & 0b00001111
+          pointer += 1
+
+          # Ignoring rsv4
+          length = @data.getbyte(pointer) & 0b01111111
+          pointer += 1
+
+          payload_length = case length
+          when 127 # Length defined by 8 bytes
+            # Check buffer size
+            if @data.getbyte(pointer+8-1) == nil
+              debug [:buffer_incomplete, @data.inspect]
+              error = true
+              next
+            end
+            
+            # Only using the last 4 bytes for now, till I work out how to
+            # unpack 8 bytes. I'm sure 4GB frames will do for now :)
+            l = @data[(pointer+4)..(pointer+7)].unpack('N').first
+            pointer += 8
+            l
+          when 126 # Length defined by 2 bytes
+            # Check buffer size
+            if @data.getbyte(pointer+2-1) == nil
+              debug [:buffer_incomplete, @data.inspect]
+              error = true
+              next
+            end
+            
+            l = @data[pointer..(pointer+1)].unpack('n').first
+            pointer += 2
+            l
+          else
+            length
+          end
+
+          # Check buffer size
+          if @data.getbyte(pointer+payload_length-1) == nil
+            debug [:buffer_incomplete, @data.inspect]
+            error = true
+            next
+          end
+
+          # Throw away data up to pointer
+          @data.slice!(0...pointer)
+
+          # Read application data
+          application_data = @data.slice!(0...payload_length)
+
+          frame_type = opcode_to_type(opcode)
+
+          if frame_type == :continuation && !@frame_type
+            raise WebSocketError, 'Continuation frame not expected'
+          end
+
+          if more
+            debug [:moreframe, frame_type, application_data]
+            @application_data_buffer << application_data
+            @frame_type = frame_type
+          else
+            # Message is complete
+            if frame_type == :continuation
+              @application_data_buffer << application_data
+              message(@frame_type, '', @application_data_buffer)
+              @application_data_buffer = ''
+              @frame_type = nil
+            else
+              message(frame_type, '', application_data)
+            end
+          end
+        end # end while
+      end
+      
+      def send_frame(frame_type, application_data)
+        if @state == :closing && data_frame?(frame_type)
+          raise WebSocketError, "Cannot send data frame since connection is closing"
+        end
+
+        frame = ''
+
+        opcode = type_to_opcode(frame_type)
+        byte1 = opcode # since more, rsv1-3 are 0
+        frame << byte1
+
+        length = application_data.size
+        if length <= 125
+          byte2 = length # since rsv4 is 0
+          frame << byte2
+        elsif length < 65536 # write 2 byte length
+          frame << 126
+          frame << [length].pack('n')
+        else # write 8 byte length
+          frame << 127
+          frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+        end
+
+        frame << application_data
+
+        @connection.send_data(frame)
+      end
+
+      def send_text_frame(data)
+        send_frame(:text, data)
+      end
+
+      private
+
+      def message(message_type, extension_data, application_data)
+        case message_type
+        when :close
+          if @state == :closing
+            # TODO: Check that message body matches sent data
+            # We can close connection immediately since there is no more data
+            # is allowed to be sent or received on this connection
+            @connection.close_connection
+            @state = :closed
+          else
+            # Acknowlege close
+            # The connection is considered closed
+            send_frame(:close, application_data)
+            @state = :closed
+            @connection.close_connection_after_writing
+          end
+        when :ping
+          # Pong back the same data
+          send_frame(:pong, application_data)
+        when :pong
+          # TODO: Do something. Complete a deferrable established by a ping?
+        when :text, :binary
+          @connection.trigger_on_message(application_data)
+        end
+      end
+
+      FRAME_TYPES = {
+        :continuation => 0,
+        :close => 1,
+        :ping => 2,
+        :pong => 3,
+        :text => 4,
+        :binary => 5
+      }
+      FRAME_TYPES_INVERSE = FRAME_TYPES.invert
+      # Frames are either data frames or control frames
+      DATA_FRAMES = [:text, :binary, :continuation]
+
+      def type_to_opcode(frame_type)
+        FRAME_TYPES[frame_type] || raise("Unknown frame type")
+      end
+
+      def opcode_to_type(opcode)
+        FRAME_TYPES_INVERSE[opcode] || raise("Unknown opcode")
+      end
+
+      def data_frame?(type)
+        DATA_FRAMES.include?(type)
+      end
+    end
+  end
+end