kinetic_sdk 5.0.19 → 5.0.20

data/gems/websocket-driver-0.6.5/ext/websocket-driver/WebsocketMaskService.java

@@ -1,55 +0,0 @@
-package com.jcoglan.websocket;
-
-import java.lang.Long;
-import java.io.IOException;
-
-import org.jruby.Ruby;
-import org.jruby.RubyClass;
-import org.jruby.RubyModule;
-import org.jruby.RubyObject;
-import org.jruby.RubyString;
-import org.jruby.anno.JRubyMethod;
-import org.jruby.runtime.ObjectAllocator;
-import org.jruby.runtime.ThreadContext;
-import org.jruby.runtime.builtin.IRubyObject;
-import org.jruby.runtime.load.BasicLibraryService;
-
-public class WebsocketMaskService implements BasicLibraryService {
-  private Ruby runtime;
-
-  public boolean basicLoad(Ruby runtime) throws IOException {
-    this.runtime = runtime;
-    RubyModule websocket = runtime.defineModule("WebSocket");
-
-    RubyClass webSocketMask = websocket.defineClassUnder("Mask", runtime.getObject(), new ObjectAllocator() {
-      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
-        return new WebsocketMask(runtime, rubyClass);
-      }
-    });
-
-    webSocketMask.defineAnnotatedMethods(WebsocketMask.class);
-    return true;
-  }
-
-  public class WebsocketMask extends RubyObject {
-    public WebsocketMask(final Ruby runtime, RubyClass rubyClass) {
-      super(runtime, rubyClass);
-    }
-
-    @JRubyMethod
-    public IRubyObject mask(ThreadContext context, IRubyObject payload, IRubyObject mask) {
-      if (mask.isNil()) return payload;
-
-      byte[] payload_a = ((RubyString)payload).getBytes();
-      byte[] mask_a    = ((RubyString)mask).getBytes();
-      int i, n         = payload_a.length;
-
-      if (n == 0) return payload;
-
-      for (i = 0; i < n; i++) {
-        payload_a[i] ^= mask_a[i % 4];
-      }
-      return RubyString.newStringNoCopy(runtime, payload_a);
-    }
-  }
-}

data/gems/websocket-driver-0.6.5/ext/websocket-driver/extconf.rb

@@ -1,4 +0,0 @@
-require 'mkmf'
-extension_name = 'websocket_mask'
-dir_config(extension_name)
-create_makefile(extension_name)

data/gems/websocket-driver-0.6.5/ext/websocket-driver/websocket_mask.c

@@ -1,41 +0,0 @@
-#include <ruby.h>
-
-VALUE WebSocket = Qnil;
-VALUE WebSocketMask = Qnil;
-
-void Init_websocket_mask();
-VALUE method_websocket_mask(VALUE self, VALUE payload, VALUE mask);
-
-void
-Init_websocket_mask()
-{
-  WebSocket = rb_define_module("WebSocket");
-  WebSocketMask = rb_define_module_under(WebSocket, "Mask");
-  rb_define_singleton_method(WebSocketMask, "mask", method_websocket_mask, 2);
-}
-
-VALUE
-method_websocket_mask(VALUE self,
-                      VALUE payload,
-                      VALUE mask)
-{
-  char *payload_s, *mask_s, *unmasked_s;
-  long i, n;
-  VALUE unmasked;
-
-  if (mask == Qnil || RSTRING_LEN(mask) != 4) {
-    return payload;
-  }
-
-  payload_s = RSTRING_PTR(payload);
-  mask_s    = RSTRING_PTR(mask);
-  n         = RSTRING_LEN(payload);
-
-  unmasked   = rb_str_new(0, n);
-  unmasked_s = RSTRING_PTR(unmasked);
-
-  for (i = 0; i < n; i++) {
-    unmasked_s[i] = payload_s[i] ^ mask_s[i % 4];
-  }
-  return unmasked;
-}

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

@@ -1,140 +0,0 @@
-module WebSocket
-  class Driver
-
-    class Client < Hybi
-      VALID_SCHEMES = %w[ws wss]
-
-      def self.generate_key
-        Base64.strict_encode64(SecureRandom.random_bytes(16))
-      end
-
-      attr_reader :status, :headers
-
-      def initialize(socket, options = {})
-        super
-
-        @ready_state = -1
-        @key         = Client.generate_key
-        @accept      = Hybi.generate_accept(@key)
-        @http        = HTTP::Response.new
-
-        uri = URI.parse(@socket.url)
-        unless VALID_SCHEMES.include?(uri.scheme)
-          raise URIError, "#{socket.url} is not a valid WebSocket URL"
-        end
-
-        host      = uri.host + (uri.port ? ":#{uri.port}" : '')
-        path      = (uri.path == '') ? '/' : uri.path
-        @pathname = path + (uri.query ? '?' + uri.query : '')
-
-        @headers['Host']                  = host
-        @headers['Upgrade']               = 'websocket'
-        @headers['Connection']            = 'Upgrade'
-        @headers['Sec-WebSocket-Key']     = @key
-        @headers['Sec-WebSocket-Version'] = '13'
-
-        if @protocols.size > 0
-          @headers['Sec-WebSocket-Protocol'] = @protocols * ', '
-        end
-
-        if uri.user
-          auth = Base64.strict_encode64([uri.user, uri.password] * ':')
-          @headers['Authorization'] = 'Basic ' + auth
-        end
-      end
-
-      def version
-        'hybi-13'
-      end
-
-      def proxy(origin, options = {})
-        Proxy.new(self, origin, options)
-      end
-
-      def start
-        return false unless @ready_state == -1
-        @socket.write(handshake_request)
-        @ready_state = 0
-        true
-      end
-
-      def parse(chunk)
-        return if @ready_state == 3
-        return super if @ready_state > 0
-
-        @http.parse(chunk)
-        return fail_handshake('Invalid HTTP response') if @http.error?
-        return unless @http.complete?
-
-        validate_handshake
-        return if @ready_state == 3
-
-        open
-        parse(@http.body)
-      end
-
-    private 
-
-      def handshake_request
-        extensions = @extensions.generate_offer
-        @headers['Sec-WebSocket-Extensions'] = extensions if extensions
-
-        start   = "GET #{@pathname} HTTP/1.1"
-        headers = [start, @headers.to_s, '']
-        headers.join("\r\n")
-      end
-
-      def fail_handshake(message)
-        message = "Error during WebSocket handshake: #{message}"
-        @ready_state = 3
-        emit(:error, ProtocolError.new(message))
-        emit(:close, CloseEvent.new(ERRORS[:protocol_error], message))
-      end
-
-      def validate_handshake
-        @status  = @http.code
-        @headers = Headers.new(@http.headers)
-
-        unless @http.code == 101
-          return fail_handshake("Unexpected response code: #{@http.code}")
-        end
-
-        upgrade    = @http['Upgrade'] || ''
-        connection = @http['Connection'] || ''
-        accept     = @http['Sec-WebSocket-Accept'] || ''
-        protocol   = @http['Sec-WebSocket-Protocol'] || ''
-
-        if upgrade == ''
-          return fail_handshake("'Upgrade' header is missing")
-        elsif upgrade.downcase != 'websocket'
-          return fail_handshake("'Upgrade' header value is not 'WebSocket'")
-        end
-
-        if connection == ''
-          return fail_handshake("'Connection' header is missing")
-        elsif connection.downcase != 'upgrade'
-          return fail_handshake("'Connection' header value is not 'Upgrade'")
-        end
-
-        unless accept == @accept
-          return fail_handshake('Sec-WebSocket-Accept mismatch')
-        end
-
-        unless protocol == ''
-          if @protocols.include?(protocol)
-            @protocol = protocol
-          else
-            return fail_handshake('Sec-WebSocket-Protocol mismatch')
-          end
-        end
-
-        begin
-          @extensions.activate(@headers['Sec-WebSocket-Extensions'])
-        rescue ::WebSocket::Extensions::ExtensionError => error
-          return fail_handshake(error.message)
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,102 +0,0 @@
-module WebSocket
-  class Driver
-
-    class Draft75 < Driver
-      def initialize(socket, options = {})
-        super
-
-        @stage   = 0
-        @closing = false
-
-        @headers['Upgrade']            = 'WebSocket'
-        @headers['Connection']         = 'Upgrade'
-        @headers['WebSocket-Origin']   = @socket.env['HTTP_ORIGIN']
-        @headers['WebSocket-Location'] = @socket.url
-      end
-
-      def version
-        'hixie-75'
-      end
-
-      def close(reason = nil, code = nil)
-        return false if @ready_state == 3
-        @ready_state = 3
-        emit(:close, CloseEvent.new(nil, nil))
-        true
-      end
-
-      def parse(chunk)
-        return if @ready_state > 1
-
-        @reader.put(chunk)
-
-        @reader.each_byte do |octet|
-          case @stage
-            when -1 then
-              @body << octet
-              send_handshake_body
-
-            when 0 then
-              parse_leading_byte(octet)
-
-            when 1 then
-              @length = (octet & 0x7F) + 128 * @length
-
-              if @closing and @length.zero?
-                return close
-              elsif (octet & 0x80) != 0x80
-                if @length.zero?
-                  @stage = 0
-                else
-                  @skipped = 0
-                  @stage   = 2
-                end
-              end
-
-            when 2 then
-              if octet == 0xFF
-                @stage = 0
-                emit(:message, MessageEvent.new(Driver.encode(@buffer, UNICODE)))
-              else
-                if @length
-                  @skipped += 1
-                  @stage = 0 if @skipped == @length
-                else
-                  @buffer << octet
-                  return close if @buffer.size > @max_length
-                end
-              end
-          end
-        end
-      end
-
-      def frame(buffer, type = nil, error_type = nil)
-        return queue([buffer, type, error_type]) if @ready_state == 0
-        frame = [0x00, buffer, 0xFF].pack('CA*C')
-        @socket.write(frame)
-        true
-      end
-
-    private
-
-      def handshake_response
-        start   = 'HTTP/1.1 101 Web Socket Protocol Handshake'
-        headers = [start, @headers.to_s, '']
-        headers.join("\r\n")
-      end
-
-      def parse_leading_byte(octet)
-        if (octet & 0x80) == 0x80
-          @length = 0
-          @stage  = 1
-        else
-          @length  = nil
-          @skipped = nil
-          @buffer  = []
-          @stage   = 2
-        end
-      end
-    end
-
-  end
-end

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

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

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

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

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

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