sonixlabs-em-websocket 0.3.7

data/lib/em-websocket/framing03.rb

@@ -0,0 +1,167 @@
+# encoding: BINARY
+
+module EventMachine
+  module WebSocket
+    module Framing03
+
+      # Set the max frame lenth to very high value (10MB) until there is a
+      # limit specified in the spec to protect against malicious attacks
+      MAXIMUM_FRAME_LENGTH = 10 * 1024 * 1024
+
+      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) ^ fin
+          # 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]
+              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]
+              error = true
+              next
+            end
+            
+            l = @data[pointer..(pointer+1)].unpack('n').first
+            pointer += 2
+            l
+          else
+            length
+          end
+
+          # Addition to the spec to protect against malicious requests
+          if payload_length > MAXIMUM_FRAME_LENGTH
+            raise DataError, "Frame length too long (#{payload_length} bytes)"
+          end
+
+          # Check buffer size
+          if @data.getbyte(pointer+payload_length-1) == nil
+            debug [:buffer_incomplete, @data]
+            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
+            # The message type is passed in the first frame
+            @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)
+        debug [:sending_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
+
+      # This allows flipping the more bit to fin for draft 04
+      def fin; false; 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(DataError, "Unknown opcode")
+      end
+
+      def data_frame?(type)
+        DATA_FRAMES.include?(type)
+      end
+    end
+  end
+end

data/lib/em-websocket/framing04.rb

@@ -0,0 +1,15 @@
+# encoding: BINARY
+
+module EventMachine
+  module WebSocket
+    # The only difference between draft 03 framing and draft 04 framing is 
+    # that the MORE bit has been changed to a FIN bit
+    module Framing04
+      include Framing03
+
+      private
+      
+      def fin; true; end
+    end
+  end
+end

data/lib/em-websocket/framing05.rb

@@ -0,0 +1,168 @@
+# encoding: BINARY
+
+module EventMachine
+  module WebSocket
+    module Framing05
+      
+      # Set the max frame lenth to very high value (10MB) until there is a
+      # limit specified in the spec to protect against malicious attacks
+      MAXIMUM_FRAME_LENGTH = 10 * 1024 * 1024
+      
+      def initialize_framing
+        @data = MaskedString.new
+        @application_data_buffer = '' # Used for MORE frames
+      end
+      
+      def process_data(newdata)
+        error = false
+
+        while !error && @data.size > 5 # mask plus first byte present
+          pointer = 0
+
+          @data.read_mask
+          pointer += 4
+
+          fin = (@data.getbyte(pointer) & 0b10000000) == 0b10000000
+          # Ignoring rsv1-3 for now
+          opcode = @data.getbyte(pointer) & 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]
+              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.getbytes(pointer+4, 4).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]
+              error = true
+              next
+            end
+            
+            l = @data.getbytes(pointer, 2).unpack('n').first
+            pointer += 2
+            l
+          else
+            length
+          end
+
+          # Addition to the spec to protect against malicious requests
+          if payload_length > MAXIMUM_FRAME_LENGTH
+            raise DataError, "Frame length too long (#{payload_length} bytes)"
+          end
+
+          # Check buffer size
+          if @data.getbyte(pointer+payload_length-1) == nil
+            debug [:buffer_incomplete, @data]
+            error = true
+            next
+          end
+
+          # Read application data
+          application_data = @data.getbytes(pointer, payload_length)
+          pointer += payload_length
+          
+          # Throw away data up to pointer
+          @data.unset_mask
+          @data.slice!(0...pointer)
+
+          frame_type = opcode_to_type(opcode)
+
+          if frame_type == :continuation && !@frame_type
+            raise WebSocketError, 'Continuation frame not expected'
+          end
+
+          if !fin
+            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)
+        debug [:sending_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 | 0b10000000 # fin bit set, 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
+
+      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(DataError, "Unknown opcode")
+      end
+
+      def data_frame?(type)
+        DATA_FRAMES.include?(type)
+      end
+    end
+  end
+end

data/lib/em-websocket/framing07.rb

@@ -0,0 +1,180 @@
+# encoding: BINARY
+
+module EventMachine
+  module WebSocket
+    module Framing07
+      
+      attr_accessor :mask_outbound_messages, :require_masked_inbound_messages
+
+      def initialize_framing
+        @data = MaskedString.new
+        @application_data_buffer = '' # Used for MORE frames
+        @mask_outbound_messages = false
+        @require_masked_inbound_messages = true
+      end
+      
+      def process_data(newdata)
+        error = false
+
+        while !error && @data.size >= 2
+          pointer = 0
+
+          fin = (@data.getbyte(pointer) & 0b10000000) == 0b10000000
+          # Ignoring rsv1-3 for now
+          opcode = @data.getbyte(pointer) & 0b00001111
+          pointer += 1
+
+          mask = (@data.getbyte(pointer) & 0b10000000) == 0b10000000
+          length = @data.getbyte(pointer) & 0b01111111
+          pointer += 1
+
+          if require_masked_inbound_messages
+            raise WebSocketError, 'Data from client must be masked' unless mask
+          end
+
+          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]
+              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.getbytes(pointer+4, 4).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]
+              error = true
+              next
+            end
+            
+            l = @data.getbytes(pointer, 2).unpack('n').first
+            pointer += 2
+            l
+          else
+            length
+          end
+
+          # Compute the expected frame length
+          frame_length = pointer + payload_length
+          frame_length += 4 if mask
+
+          # Check buffer size
+          if @data.getbyte(frame_length - 1) == nil
+            debug [:buffer_incomplete, @data]
+            error = true
+            next
+          end
+
+          # Remove frame header
+          @data.slice!(0...pointer)
+          pointer = 0
+
+          # Read application data (unmasked if required)
+          @data.read_mask if mask
+          pointer += 4 if mask
+          application_data = @data.getbytes(pointer, payload_length)
+          pointer += payload_length
+          @data.unset_mask if mask
+          
+          # Throw away data up to pointer
+          @data.slice!(0...pointer)
+
+          frame_type = opcode_to_type(opcode)
+
+          if frame_type == :continuation && !@frame_type
+            raise WebSocketError, 'Continuation frame not expected'
+          end
+
+          if !fin
+            debug [:moreframe, frame_type, application_data]
+            @application_data_buffer << application_data
+            # The message type is passed in the first frame
+            @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)
+        debug [:sending_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 | 0b10000000 # fin bit set, rsv1-3 are 0
+        frame << byte1
+
+        mask = mask_outbound_messages ? 0b10000000 : 0b00000000 # must be masked if from client
+        length = application_data.size
+        if length <= 125
+          byte2 = length # since rsv4 is 0
+          frame << (mask | byte2)
+        elsif length < 65536 # write 2 byte length
+          frame << (mask | 126)
+          frame << [length].pack('n')
+        else # write 8 byte length
+          frame << (mask | 127)
+          frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+        end
+
+        if mask_outbound_messages
+          frame << MaskedString.create_masked_string(application_data)
+        else
+          frame << application_data
+        end
+
+        @connection.send_data(frame)
+      end
+
+      def send_text_frame(data)
+        send_frame(:text, data)
+      end
+
+      private
+
+      FRAME_TYPES = {
+        :continuation => 0,
+        :text => 1,
+        :binary => 2,
+        :close => 8,
+        :ping => 9,
+        :pong => 10,
+      }
+      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(DataError, "Unknown opcode")
+      end
+
+      def data_frame?(type)
+        DATA_FRAMES.include?(type)
+      end
+    end
+  end
+end

data/lib/em-websocket/framing76.rb

@@ -0,0 +1,114 @@
+# encoding: BINARY
+
+module EventMachine
+  module WebSocket
+    module Framing76
+      
+      # Set the max frame lenth to very high value (10MB) until there is a
+      # limit specified in the spec to protect against malicious attacks
+      MAXIMUM_FRAME_LENGTH = 10 * 1024 * 1024
+      
+      def initialize_framing
+        @data = ''
+      end
+      
+      def process_data(newdata)
+        debug [:message, @data]
+
+        # This algorithm comes straight from the spec
+        # http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76#section-5.3
+
+        error = false
+
+        while !error
+          return if @data.size == 0
+
+          pointer = 0
+          frame_type = @data.getbyte(pointer)
+          pointer += 1
+
+          if (frame_type & 0x80) == 0x80
+            # If the high-order bit of the /frame type/ byte is set
+            length = 0
+
+            loop do
+              return false if !@data.getbyte(pointer)
+              b = @data.getbyte(pointer)
+              pointer += 1
+              b_v = b & 0x7F
+              length = length * 128 + b_v
+              break unless (b & 0x80) == 0x80
+            end
+
+            # Addition to the spec to protect against malicious requests
+            if length > MAXIMUM_FRAME_LENGTH
+              raise DataError, "Frame length too long (#{length} bytes)"
+            end
+
+            if @data.getbyte(pointer+length-1) == nil
+              debug [:buffer_incomplete, @data]
+              # Incomplete data - leave @data to accumulate
+              error = true
+            else
+              # Straight from spec - I'm sure this isn't crazy...
+              # 6. Read /length/ bytes.
+              # 7. Discard the read bytes.
+              @data = @data[(pointer+length)..-1]
+
+              # If the /frame type/ is 0xFF and the /length/ was 0, then close
+              if length == 0
+                @connection.send_data("\xff\x00")
+                @state = :closing
+                @connection.close_connection_after_writing
+              else
+                error = true
+              end
+            end
+          else
+            # If the high-order bit of the /frame type/ byte is _not_ set
+
+            if @data.getbyte(0) != 0x00
+              # Close the connection since this buffer can never match
+              raise DataError, "Invalid frame received"
+            end
+
+            # Addition to the spec to protect against malicious requests
+            if @data.size > MAXIMUM_FRAME_LENGTH
+              raise DataError, "Frame length too long (#{@data.size} bytes)"
+            end
+
+            # Optimization to avoid calling slice! unnecessarily
+            error = true and next unless newdata =~ /\xff/
+
+            msg = @data.slice!(/\A\x00[^\xff]*\xff/)
+            if msg
+              msg.gsub!(/\A\x00|\xff\z/, '')
+              if @state == :closing
+                debug [:ignored_message, msg]
+              else
+                msg.force_encoding('UTF-8') if msg.respond_to?(:force_encoding)
+                @connection.trigger_on_message(msg)
+              end
+            else
+              error = true
+            end
+          end
+        end
+
+        false
+      end
+      
+      # frames need to start with 0x00-0x7f byte and end with
+      # an 0xFF byte. Per spec, we can also set the first
+      # byte to a value betweent 0x80 and 0xFF, followed by
+      # a leading length indicator
+      def send_text_frame(data)
+        debug [:sending_text_frame, data]
+        ary = ["\x00", data, "\xff"]
+        ary.collect{ |s| s.force_encoding('UTF-8') if s.respond_to?(:force_encoding) }
+        @connection.send_data(ary.join)
+      end
+
+    end
+  end
+end

data/lib/em-websocket/handler.rb

@@ -0,0 +1,56 @@
+module EventMachine
+  module WebSocket
+    class Handler
+      include Debugger
+
+      attr_reader :request, :state
+
+      def initialize(connection, request, debug = false)
+        @connection, @request = connection, request
+        @debug = debug
+        @state = :handshake
+        initialize_framing
+      end
+
+      def run_server
+        @connection.send_data handshake_server
+        @state = :connected
+        @connection.trigger_on_open
+      end
+
+      def run_client
+        self.mask_outbound_messages = true
+        self.require_masked_inbound_messages = false
+        @connection.send_data handshake_client
+      end
+
+      # Handshake response
+      def handshake
+        # Implemented in subclass
+      end
+
+      def handshake_server
+        handshake  #backwards compatibility
+      end
+
+      # Handshake initiation
+      def handshake_client
+        # Implemented in subclass
+      end
+
+      def receive_data(data)
+        @data << data
+        process_data(data)
+      end
+
+      def close_websocket(code, body)
+        # Implemented in subclass
+      end
+
+      def unbind
+        @state = :closed
+        @connection.trigger_on_close
+      end
+    end
+  end
+end

data/lib/em-websocket/handler03.rb

@@ -0,0 +1,10 @@
+module EventMachine
+  module WebSocket
+    class Handler03 < Handler
+      include Handshake76
+      include Framing03
+      include MessageProcessor03
+      include Close03
+    end
+  end
+end