kinetic_sdk 0.1.1

data/gems/websocket-driver-0.6.5/lib/websocket/driver/draft76.rb

@@ -0,0 +1,96 @@
+module WebSocket
+  class Driver
+
+    class Draft76 < Draft75
+      BODY_SIZE = 8
+
+      def initialize(socket, options = {})
+        super
+        input  = @socket.env['rack.input']
+        @stage = -1
+        @body  = (input ? input.read : String.new('')).force_encoding(BINARY)
+
+        @headers.clear
+        @headers['Upgrade'] = 'WebSocket'
+        @headers['Connection'] = 'Upgrade'
+        @headers['Sec-WebSocket-Origin'] = @socket.env['HTTP_ORIGIN']
+        @headers['Sec-WebSocket-Location'] = @socket.url
+      end
+
+      def version
+        'hixie-76'
+      end
+
+      def start
+        return false unless super
+        send_handshake_body
+        true
+      end
+
+      def close(reason = nil, code = nil)
+        return false if @ready_state == 3
+        @socket.write([0xFF, 0x00].pack('C*'))
+        @ready_state = 3
+        emit(:close, CloseEvent.new(nil, nil))
+        true
+      end
+
+    private
+
+      def handshake_response
+        env     = @socket.env
+
+        key1    = env['HTTP_SEC_WEBSOCKET_KEY1']
+        number1 = number_from_key(key1)
+        spaces1 = spaces_in_key(key1)
+
+        key2    = env['HTTP_SEC_WEBSOCKET_KEY2']
+        number2 = number_from_key(key2)
+        spaces2 = spaces_in_key(key2)
+
+        if number1 % spaces1 != 0 or number2 % spaces2 != 0
+          emit(:error, ProtocolError.new('Client sent invalid Sec-WebSocket-Key headers'))
+          close
+          return nil
+        end
+
+        @key_values = [number1 / spaces1, number2 / spaces2]
+
+        start   = 'HTTP/1.1 101 WebSocket Protocol Handshake'
+        headers = [start, @headers.to_s, '']
+        headers.join("\r\n")
+      end
+
+      def handshake_signature
+        return nil unless @body.bytesize >= BODY_SIZE
+
+        head = @body[0...BODY_SIZE]
+        Digest::MD5.digest((@key_values + [head]).pack('N2A*'))
+      end
+
+      def send_handshake_body
+        return unless signature = handshake_signature
+        @socket.write(signature)
+        @stage = 0
+        open
+        parse(@body[BODY_SIZE..-1]) if @body.bytesize > BODY_SIZE
+      end
+
+      def parse_leading_byte(octet)
+        return super unless octet == 0xFF
+        @closing = true
+        @length  = 0
+        @stage   = 1
+      end
+
+      def number_from_key(key)
+        key.scan(/[0-9]/).join('').to_i(10)
+      end
+
+      def spaces_in_key(key)
+        key.scan(/ /).size
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/event_emitter.rb

@@ -0,0 +1,54 @@
+module WebSocket
+  class Driver
+
+    module EventEmitter
+      def initialize
+        @listeners = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def add_listener(event, callable = nil, &block)
+        listener = callable || block
+        @listeners[event.to_s] << listener
+        listener
+      end
+
+      def on(event, callable = nil, &block)
+        if callable
+          add_listener(event, callable)
+        else
+          add_listener(event, &block)
+        end
+      end
+
+      def remove_listener(event, callable = nil, &block)
+        listener = callable || block
+        @listeners[event.to_s].delete(listener)
+        listener
+      end
+
+      def remove_all_listeners(event = nil)
+        if event
+          @listeners.delete(event.to_s)
+        else
+          @listeners.clear
+        end
+      end
+
+      def emit(event, *args)
+        @listeners[event.to_s].dup.each do |listener|
+          listener.call(*args)
+        end
+      end
+
+      def listener_count(event)
+        return 0 unless @listeners.has_key?(event.to_s)
+        @listeners[event.to_s].size
+      end
+
+      def listeners(event)
+        @listeners[event.to_s]
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/headers.rb

@@ -0,0 +1,45 @@
+module WebSocket
+  class Driver
+
+    class Headers
+      ALLOWED_DUPLICATES = %w[set-cookie set-cookie2 warning www-authenticate]
+
+      def initialize(received = {})
+        @raw = received
+        clear
+
+        @received = {}
+        @raw.each { |k,v| @received[HTTP.normalize_header(k)] = v }
+      end
+
+      def clear
+        @sent  = Set.new
+        @lines = []
+      end
+
+      def [](name)
+        @received[HTTP.normalize_header(name)]
+      end
+
+      def []=(name, value)
+        return if value.nil?
+        key = HTTP.normalize_header(name)
+        return unless @sent.add?(key) or ALLOWED_DUPLICATES.include?(key)
+        @lines << "#{name.strip}: #{value.to_s.strip}\r\n"
+      end
+
+      def inspect
+        @raw.inspect
+      end
+
+      def to_h
+        @raw.dup
+      end
+
+      def to_s
+        @lines.join('')
+      end
+    end
+
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/hybi/frame.rb

@@ -0,0 +1,20 @@
+module WebSocket
+  class Driver
+    class Hybi
+
+      class Frame
+        attr_accessor :final,
+                      :rsv1,
+                      :rsv2,
+                      :rsv3,
+                      :opcode,
+                      :masked,
+                      :masking_key,
+                      :length_bytes,
+                      :length,
+                      :payload
+      end
+
+    end
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/hybi/message.rb

@@ -0,0 +1,31 @@
+module WebSocket
+  class Driver
+    class Hybi
+
+      class Message
+        attr_accessor :rsv1,
+                      :rsv2,
+                      :rsv3,
+                      :opcode,
+                      :data
+
+        def initialize
+          @rsv1   = false
+          @rsv2   = false
+          @rsv3   = false
+          @opcode = nil
+          @data   = String.new('').force_encoding(BINARY)
+        end
+
+        def <<(frame)
+          @rsv1   ||= frame.rsv1
+          @rsv2   ||= frame.rsv2
+          @rsv3   ||= frame.rsv3
+          @opcode ||= frame.opcode
+          @data   <<  frame.payload
+        end
+      end
+
+    end
+  end
+end

data/gems/websocket-driver-0.6.5/lib/websocket/driver/hybi.rb

@@ -0,0 +1,406 @@
+module WebSocket
+  class Driver
+
+    class Hybi < Driver
+      root = File.expand_path('../hybi', __FILE__)
+
+      autoload :Frame,   root + '/frame'
+      autoload :Message, root + '/message'
+
+      def self.generate_accept(key)
+        Base64.strict_encode64(Digest::SHA1.digest(key + GUID))
+      end
+
+      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+      BYTE       = 0b11111111
+      FIN = MASK = 0b10000000
+      RSV1       = 0b01000000
+      RSV2       = 0b00100000
+      RSV3       = 0b00010000
+      OPCODE     = 0b00001111
+      LENGTH     = 0b01111111
+
+      OPCODES = {
+        :continuation => 0,
+        :text         => 1,
+        :binary       => 2,
+        :close        => 8,
+        :ping         => 9,
+        :pong         => 10
+      }
+
+      OPCODE_CODES    = OPCODES.values
+      MESSAGE_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,
+        :encoding_error       => 1007,
+        :policy_violation     => 1008,
+        :too_large            => 1009,
+        :extension_error      => 1010,
+        :unexpected_condition => 1011
+      }
+
+      ERROR_CODES        = ERRORS.values
+      DEFAULT_ERROR_CODE = 1000
+      MIN_RESERVED_ERROR = 3000
+      MAX_RESERVED_ERROR = 4999
+
+      PACK_FORMATS = {2 => 'n', 8 => 'Q>'}
+
+      def initialize(socket, options = {})
+        super
+
+        @extensions      = ::WebSocket::Extensions.new
+        @stage           = 0
+        @masking         = options[:masking]
+        @protocols       = options[:protocols] || []
+        @protocols       = @protocols.strip.split(/ *, */) if String === @protocols
+        @require_masking = options[:require_masking]
+        @ping_callbacks  = {}
+
+        @frame = @message = nil
+
+        return unless @socket.respond_to?(:env)
+
+        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
+        protos  = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
+
+        @headers['Upgrade']              = 'websocket'
+        @headers['Connection']           = 'Upgrade'
+        @headers['Sec-WebSocket-Accept'] = Hybi.generate_accept(sec_key)
+
+        if protos = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
+          protos = protos.split(/ *, */) if String === protos
+          @protocol = protos.find { |p| @protocols.include?(p) }
+          @headers['Sec-WebSocket-Protocol'] = @protocol if @protocol
+        end
+      end
+
+      def version
+        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
+      end
+
+      def add_extension(extension)
+        @extensions.add(extension)
+        true
+      end
+
+      def parse(chunk)
+        @reader.put(chunk)
+        buffer = true
+        while buffer
+          case @stage
+            when 0 then
+              buffer = @reader.read(1)
+              parse_opcode(buffer.getbyte(0)) if buffer
+
+            when 1 then
+              buffer = @reader.read(1)
+              parse_length(buffer.getbyte(0)) if buffer
+
+            when 2 then
+              buffer = @reader.read(@frame.length_bytes)
+              parse_extended_length(buffer) if buffer
+
+            when 3 then
+              buffer = @reader.read(4)
+              if buffer
+                @stage = 4
+                @frame.masking_key = buffer
+              end
+
+            when 4 then
+              buffer = @reader.read(@frame.length)
+
+              if buffer
+                @stage = 0
+                emit_frame(buffer)
+              end
+
+            else
+              buffer = nil
+          end
+        end
+      end
+
+      def binary(message)
+        frame(message, :binary)
+      end
+
+      def ping(message = '', &callback)
+        @ping_callbacks[message] = callback if callback
+        frame(message, :ping)
+      end
+
+      def pong(message = '')
+        frame(message, :pong)
+      end
+
+      def close(reason = nil, code = nil)
+        reason ||= ''
+        code   ||= ERRORS[:normal_closure]
+
+        if @ready_state <= 0
+          @ready_state = 3
+          emit(:close, CloseEvent.new(code, reason))
+          true
+        elsif @ready_state == 1
+          frame(reason, :close, code)
+          @ready_state = 2
+          true
+        else
+          false
+        end
+      end
+
+      def frame(buffer, type = nil, code = nil)
+        return queue([buffer, type, code]) if @ready_state <= 0
+        return false unless @ready_state == 1
+
+        message = Message.new
+        frame   = Frame.new
+        is_text = String === buffer
+
+        message.rsv1   = message.rsv2 = message.rsv3 = false
+        message.opcode = OPCODES[type || (is_text ? :text : :binary)]
+
+        payload = is_text ? buffer.bytes.to_a : buffer
+        payload = [code].pack(PACK_FORMATS[2]).bytes.to_a + payload if code
+        message.data = payload.pack('C*')
+
+        if MESSAGE_OPCODES.include?(message.opcode)
+          message = @extensions.process_outgoing_message(message)
+        end
+
+        frame.final       = true
+        frame.rsv1        = message.rsv1
+        frame.rsv2        = message.rsv2
+        frame.rsv3        = message.rsv3
+        frame.opcode      = message.opcode
+        frame.masked      = !!@masking
+        frame.masking_key = SecureRandom.random_bytes(4) if frame.masked
+        frame.length      = message.data.bytesize
+        frame.payload     = message.data
+
+        send_frame(frame)
+        true
+
+      rescue ::WebSocket::Extensions::ExtensionError => error
+        fail(:extension_error, error.message)
+      end
+
+    private
+
+      def send_frame(frame)
+        length = frame.length
+        buffer = []
+        masked = frame.masked ? MASK : 0
+
+        buffer[0] = (frame.final ? FIN : 0) |
+                    (frame.rsv1 ? RSV1 : 0) |
+                    (frame.rsv2 ? RSV2 : 0) |
+                    (frame.rsv3 ? RSV3 : 0) |
+                    frame.opcode
+
+        if length <= 125
+          buffer[1] = masked | length
+        elsif length <= 65535
+          buffer[1] = masked | 126
+          buffer[2..3] = [length].pack(PACK_FORMATS[2]).bytes.to_a
+        else
+          buffer[1] = masked | 127
+          buffer[2..9] = [length].pack(PACK_FORMATS[8]).bytes.to_a
+        end
+
+        if frame.masked
+          buffer.concat(frame.masking_key.bytes.to_a)
+          buffer.concat(Mask.mask(frame.payload, frame.masking_key).bytes.to_a)
+        else
+          buffer.concat(frame.payload.bytes.to_a)
+        end
+
+        @socket.write(buffer.pack('C*'))
+      end
+
+      def handshake_response
+        begin
+          extensions = @extensions.generate_response(@socket.env['HTTP_SEC_WEBSOCKET_EXTENSIONS'])
+        rescue => error
+          fail(:protocol_error, error.message)
+          return nil
+        end
+
+        @headers['Sec-WebSocket-Extensions'] = extensions if extensions
+
+        start   = 'HTTP/1.1 101 Switching Protocols'
+        headers = [start, @headers.to_s, '']
+        headers.join("\r\n")
+      end
+
+      def shutdown(code, reason, error = false)
+        @frame = @message = nil
+        @stage = 5
+        @extensions.close
+
+        frame(reason, :close, code) if @ready_state < 2
+        @ready_state = 3
+
+        emit(:error, ProtocolError.new(reason)) if error
+        emit(:close, CloseEvent.new(code, reason))
+      end
+
+      def fail(type, message)
+        return if @ready_state > 1
+        shutdown(ERRORS[type], message, true)
+      end
+
+      def parse_opcode(octet)
+        rsvs = [RSV1, RSV2, RSV3].map { |rsv| (octet & rsv) == rsv }
+
+        @frame = Frame.new
+
+        @frame.final  = (octet & FIN) == FIN
+        @frame.rsv1   = rsvs[0]
+        @frame.rsv2   = rsvs[1]
+        @frame.rsv3   = rsvs[2]
+        @frame.opcode = (octet & OPCODE)
+
+        @stage = 1
+
+        unless @extensions.valid_frame_rsv?(@frame)
+          return fail(:protocol_error,
+              "One or more reserved bits are on: reserved1 = #{@frame.rsv1 ? 1 : 0}" +
+              ", reserved2 = #{@frame.rsv2 ? 1 : 0 }" +
+              ", reserved3 = #{@frame.rsv3 ? 1 : 0 }")
+        end
+
+        unless OPCODES.values.include?(@frame.opcode)
+          return fail(:protocol_error, "Unrecognized frame opcode: #{@frame.opcode}")
+        end
+
+        unless MESSAGE_OPCODES.include?(@frame.opcode) or @frame.final
+          return fail(:protocol_error, "Received fragmented control frame: opcode = #{@frame.opcode}")
+        end
+
+        if @message and OPENING_OPCODES.include?(@frame.opcode)
+          return fail(:protocol_error, 'Received new data frame but previous continuous frame is unfinished')
+        end
+      end
+
+      def parse_length(octet)
+        @frame.masked = (octet & MASK) == MASK
+        @frame.length = (octet & LENGTH)
+
+        if @frame.length >= 0 and @frame.length <= 125
+          @stage = @frame.masked ? 3 : 4
+          return unless check_frame_length
+        else
+          @stage = 2
+          @frame.length_bytes = (@frame.length == 126) ? 2 : 8
+        end
+
+        if @require_masking and not @frame.masked
+          return fail(:unacceptable, 'Received unmasked frame but masking is required')
+        end
+      end
+
+      def parse_extended_length(buffer)
+        @frame.length = buffer.unpack(PACK_FORMATS[buffer.bytesize]).first
+        @stage = @frame.masked ? 3 : 4
+
+        unless MESSAGE_OPCODES.include?(@frame.opcode) or @frame.length <= 125
+          return fail(:protocol_error, "Received control frame having too long payload: #{@frame.length}")
+        end
+
+        return unless check_frame_length
+      end
+
+      def check_frame_length
+        length = @message ? @message.data.bytesize : 0
+
+        if length + @frame.length > @max_length
+          fail(:too_large, 'WebSocket frame length too large')
+          false
+        else
+          true
+        end
+      end
+
+      def emit_frame(buffer)
+        frame    = @frame
+        opcode   = frame.opcode
+        payload  = frame.payload = Mask.mask(buffer, @frame.masking_key)
+        bytesize = payload.bytesize
+        bytes    = payload.bytes.to_a
+
+        @frame = nil
+
+        case opcode
+          when OPCODES[:continuation] then
+            return fail(:protocol_error, 'Received unexpected continuation frame') unless @message
+            @message << frame
+
+          when OPCODES[:text], OPCODES[:binary] then
+            @message = Message.new
+            @message << frame
+
+          when OPCODES[:close] then
+            code   = (bytesize >= 2) ? payload.unpack(PACK_FORMATS[2]).first : nil
+            reason = (bytesize > 2)  ? Driver.encode(bytes[2..-1] || [], UNICODE) : nil
+
+            unless (bytesize == 0) or
+                   (code && code >= MIN_RESERVED_ERROR && code <= MAX_RESERVED_ERROR) or
+                   ERROR_CODES.include?(code)
+              code = ERRORS[:protocol_error]
+            end
+
+            if bytesize > 125 or (bytesize > 2 and reason.nil?)
+              code = ERRORS[:protocol_error]
+            end
+
+            shutdown(code || DEFAULT_ERROR_CODE, reason || '')
+
+          when OPCODES[:ping] then
+            frame(payload, :pong)
+
+          when OPCODES[:pong] then
+            message = Driver.encode(payload, UNICODE)
+            callback = @ping_callbacks[message]
+            @ping_callbacks.delete(message)
+            callback.call if callback
+        end
+
+        emit_message if frame.final and MESSAGE_OPCODES.include?(opcode)
+      end
+
+      def emit_message
+        message  = @extensions.process_incoming_message(@message)
+        @message = nil
+
+        payload = message.data
+
+        case message.opcode
+          when OPCODES[:text] then
+            payload = Driver.encode(payload, UNICODE)
+          when OPCODES[:binary]
+            payload = payload.bytes.to_a
+        end
+
+        if payload
+          emit(:message, MessageEvent.new(payload))
+        else
+          fail(:encoding_error, 'Could not decode a text frame as UTF-8')
+        end
+      rescue ::WebSocket::Extensions::ExtensionError => error
+        fail(:extension_error, error.message)
+      end
+    end
+
+  end
+end