websocket-rack 0.1.4 → 0.2.1

data/lib/rack/websocket/connection.rb

@@ -1,112 +0,0 @@
-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
-        socket.comm_inactivity_timeout = 0
-
-        if socket.comm_inactivity_timeout != 0
-          puts "WARNING: You are using old EventMachine version. " +
-               "Please consider updating to EM version >= 1.0.0 " +
-               "or running Thin using thin-websocket."
-        end
-
-        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.inspect] if @debug
-        @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

@@ -1,17 +0,0 @@
-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/framing03.rb

@@ -1,178 +0,0 @@
-# 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

data/lib/rack/websocket/framing76.rb

@@ -1,115 +0,0 @@
-# encoding: BINARY
-
-module Rack
-  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
-              @connection.close_with_error(DataError.new("Frame length too long (#{length} bytes)"))
-              return false
-            end
-
-            if @data.getbyte(pointer+length-1) == nil
-              debug [:buffer_incomplete, @data.inspect]
-              # 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
-              @connection.close_with_error(DataError.new("Invalid frame received"))
-            end
-
-            # Addition to the spec to protect against malicious requests
-            if @data.size > MAXIMUM_FRAME_LENGTH
-              @connection.close_with_error(DataError.new("Frame length too long (#{@data.size} bytes)"))
-              return false
-            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)
-        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/rack/websocket/handler03.rb

@@ -1,14 +0,0 @@
-module Rack
-  module WebSocket
-    class Handler03 < Handler
-      include Handshake76
-      include Framing03
-
-      def close_websocket
-        # TODO: Should we send data and check the response matches?
-        send_frame(:close, '')
-        @state = :closing
-      end
-    end
-  end
-end

data/lib/rack/websocket/handler75.rb

@@ -1,8 +0,0 @@
-module Rack
-  module WebSocket
-    class Handler75 < Handler
-      include Handshake75
-      include Framing76
-    end
-  end
-end

data/lib/rack/websocket/handler76.rb

@@ -1,11 +0,0 @@
-module Rack
-  module WebSocket
-    class Handler76 < Handler
-      include Handshake76
-      include Framing76
-
-      # "\377\000" is octet version and "\xff\x00" is hex version
-      TERMINATE_STRING = "\xff\x00"
-    end
-  end
-end

data/lib/rack/websocket/handler_factory.rb

@@ -1,61 +0,0 @@
-module Rack
-  module WebSocket
-    class HandlerFactory
-
-      def self.build(connection, data, debug = false)
-        request = Rack::Request.new(data)
-
-        unless request.env['rack.input'].nil?
-          request.env['rack.input'].rewind
-          remains = request.env['rack.input'].read
-        else
-          # The whole header has not been received yet.
-          return nil
-        end
-
-        unless request.get?
-          raise HandshakeError, "Must be GET request"
-        end
-
-        version = request.env['HTTP_SEC_WEBSOCKET_KEY1'] ? 76 : 75
-        case version
-        when 75
-          if !remains.empty?
-            raise HandshakeError, "Extra bytes after header"
-          end
-        when 76
-          if remains.length < 8
-            # The whole third-key has not been received yet.
-            return nil
-          elsif remains.length > 8
-            raise HandshakeError, "Extra bytes after third key"
-          end
-          request.env['HTTP_THIRD_KEY'] = remains
-        else
-          raise WebSocketError, "Must not happen"
-        end
-
-        unless request.env['HTTP_CONNECTION'] == 'Upgrade' and request.env['HTTP_UPGRADE'] == 'WebSocket'
-          raise HandshakeError, "Connection and Upgrade headers required"
-        end
-
-        # transform headers
-        request.env['rack.url_scheme'] = (request.scheme == 'https' ? "wss" : "ws")
-
-        if version = request.env['HTTP_SEC_WEBSOCKET_DRAFT']
-          if version == '1' || version == '2' || version == '3'
-            # We'll use handler03 - I believe they're all compatible
-            Handler03.new(connection, request, debug)
-          else
-            # According to spec should abort the connection
-            raise WebSocketError, "Unknown draft version: #{version}"
-          end
-        elsif request.env['HTTP_SEC_WEBSOCKET_KEY1']
-          Handler76.new(connection, request, debug)
-        else
-          Handler75.new(connection, request, debug)
-        end
-      end
-    end
-  end
-end

data/lib/rack/websocket/handshake75.rb

@@ -1,21 +0,0 @@
-module Rack
-  module WebSocket
-    module Handshake75
-      def handshake
-        location  = "#{request.env['rack.url_scheme']}://#{request.host}"
-        location << ":#{request.port}" if request.port > 0
-        location << request.path
-
-        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-Location: #{location}\r\n\r\n"
-
-        debug [:upgrade_headers, upgrade]
-
-        return upgrade
-      end
-    end
-  end
-end

data/lib/rack/websocket/handshake76.rb

@@ -1,71 +0,0 @@
-require 'digest/md5'
-
-module Rack
-  module WebSocket
-    module Handshake76
-      def handshake
-        challenge_response = solve_challenge(
-          request.env['HTTP_SEC_WEBSOCKET_KEY1'],
-          request.env['HTTP_SEC_WEBSOCKET_KEY2'],
-          request.env['HTTP_THIRD_KEY']
-        )
-
-        location  = "#{request.env['rack.url_scheme']}://#{request.host}"
-        location << ":#{request.port}" if request.port > 0
-        location << request.path
-
-        upgrade =  "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-        upgrade << "Upgrade: WebSocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "Sec-WebSocket-Location: #{location}\r\n"
-        upgrade << "Sec-WebSocket-Origin: #{request.env['HTTP_ORIGIN']}\r\n"
-        if protocol = request.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
-          validate_protocol!(protocol)
-          upgrade << "Sec-WebSocket-Protocol: #{protocol}\r\n"
-        end
-        upgrade << "\r\n"
-        upgrade << challenge_response
-
-        debug [:upgrade_headers, upgrade]
-
-        return upgrade
-      end
-
-      private
-
-      def solve_challenge(first, second, third)
-        # Refer to 5.2 4-9 of the draft 76
-        sum = [numbers_over_spaces(first)].pack("N*") +
-          [numbers_over_spaces(second)].pack("N*") +
-          third
-        Digest::MD5.digest(sum)
-      end
-
-      def numbers_over_spaces(string)
-        numbers = string.scan(/[0-9]/).join.to_i
-
-        spaces = string.scan(/ /).size
-        # As per 5.2.5, abort the connection if spaces are zero.
-        raise HandshakeError, "Websocket Key1 or Key2 does not contain spaces - this is a symptom of a cross-protocol attack" if spaces == 0
-
-        # As per 5.2.6, abort if numbers is not an integral multiple of spaces
-        if numbers % spaces != 0
-          raise HandshakeError, "Invalid Key #{string.inspect}"
-        end
-
-        quotient = numbers / spaces
-
-        if quotient > 2**32-1
-          raise HandshakeError, "Challenge computation out of range for key #{string.inspect}"
-        end
-
-        return quotient
-      end
-
-      def validate_protocol!(protocol)
-        raise HandshakeError, "Invalid WebSocket-Protocol: empty" if protocol.empty?
-        # TODO: Validate characters
-      end
-    end
-  end
-end

data/spec/helper.rb

@@ -1,44 +0,0 @@
-require 'rubygems'
-require 'rspec'
-require 'pp'
-require 'stringio'
-
-require 'rack/websocket'
-
-Rspec.configure do |c|
-  c.mock_with :rspec
-end
-
-def format_request(r)
-  data = {}
-  data['REQUEST_METHOD'] = r[:method] if r[:method]
-  data['PATH_INFO'] = r[:path] if r[:path]
-  data['SERVER_PORT'] = r[:port] if r[:port] && r[:port] != 80
-  r[:headers].each do |key, value|
-    data['HTTP_' + key.upcase.gsub('-','_')] = value
-  end
-  data['rack.input'] = StringIO.new(r[:body]) if r[:body]
-  # data = "#{r[:method]} #{r[:path]} HTTP/1.1\r\n"
-  # header_lines = r[:headers].map { |k,v| "#{k}: #{v}" }
-  # data << [header_lines, '', r[:body]].join("\r\n")
-  data
-end
-
-def format_response(r)
-  data = "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
-  header_lines = r[:headers].map { |k,v| "#{k}: #{v}" }
-  data << [header_lines, '', r[:body]].join("\r\n")
-  data
-end
-
-def handler(request, secure = false)
-  connection = Object.new
-  secure_hash = secure ? {'rack.url_scheme' => 'https'} : {}
-  Rack::WebSocket::HandlerFactory.build(connection, format_request(request).merge(secure_hash))
-end
-
-RSpec::Matchers.define :send_handshake do |response|
-  match do |actual|
-    actual.handshake.lines.sort == format_response(response).lines.sort
-  end
-end