faye-websocket 0.4.7 → 0.5.0

data/ext/faye_websocket_mask/FayeWebsocketMaskService.java

@@ -1,61 +0,0 @@
-package com.jcoglan.faye;
-
-import java.lang.Long;
-import java.io.IOException;
-
-import org.jruby.Ruby;
-import org.jruby.RubyArray;
-import org.jruby.RubyClass;
-import org.jruby.RubyFixnum;
-import org.jruby.RubyModule;
-import org.jruby.RubyObject;
-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 FayeWebsocketMaskService implements BasicLibraryService {
-  private Ruby runtime;
-
-  public boolean basicLoad(Ruby runtime) throws IOException {
-    this.runtime = runtime;
-    RubyModule faye = runtime.defineModule("Faye");
-
-    RubyClass webSocketMask = faye.defineClassUnder("WebSocketMask", 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) {
-      int n = ((RubyArray)payload).getLength(), i;
-      long p, m;
-      RubyArray unmasked = RubyArray.newArray(runtime, n);
-
-      long[] maskArray = {
-        (Long)((RubyArray)mask).get(0),
-        (Long)((RubyArray)mask).get(1),
-        (Long)((RubyArray)mask).get(2),
-        (Long)((RubyArray)mask).get(3)
-      };
-
-      for (i = 0; i < n; i++) {
-        p = (Long)((RubyArray)payload).get(i);
-        m = maskArray[i % 4];
-        unmasked.set(i, p ^ m);
-      }
-      return unmasked;
-    }
-  }
-}

data/ext/faye_websocket_mask/extconf.rb

@@ -1,5 +0,0 @@
-require 'mkmf'
-extension_name = 'faye_websocket_mask'
-dir_config(extension_name)
-create_makefile(extension_name)
-

data/ext/faye_websocket_mask/faye_websocket_mask.c

@@ -1,33 +0,0 @@
-#include <ruby.h>
-
-VALUE Faye = Qnil;
-VALUE FayeWebSocketMask = Qnil;
-
-void Init_faye_websocket_mask();
-VALUE method_faye_websocket_mask(VALUE self, VALUE payload, VALUE mask);
-
-void Init_faye_websocket_mask() {
-  Faye = rb_define_module("Faye");
-  FayeWebSocketMask = rb_define_module_under(Faye, "WebSocketMask");
-  rb_define_singleton_method(FayeWebSocketMask, "mask", method_faye_websocket_mask, 2);
-}
-
-VALUE method_faye_websocket_mask(VALUE self, VALUE payload, VALUE mask) {
-  int n = RARRAY_LEN(payload), i, p, m;
-  VALUE unmasked = rb_ary_new2(n);
-
-  int mask_array[] = {
-    NUM2INT(rb_ary_entry(mask, 0)),
-    NUM2INT(rb_ary_entry(mask, 1)),
-    NUM2INT(rb_ary_entry(mask, 2)),
-    NUM2INT(rb_ary_entry(mask, 3))
-  };
-
-  for (i = 0; i < n; i++) {
-    p = NUM2INT(rb_ary_entry(payload, i));
-    m = mask_array[i % 4];
-    rb_ary_store(unmasked, i, INT2NUM(p ^ m));
-  }
-  return unmasked;
-}
-

data/lib/faye/websocket/draft75_parser.rb

@@ -1,87 +0,0 @@
-module Faye
-  class WebSocket
-
-    class Draft75Parser
-      attr_reader :protocol
-
-      def initialize(web_socket, options = {})
-        @socket = web_socket
-        @stage  = 0
-      end
-
-      def version
-        'hixie-75'
-      end
-
-      def handshake_response
-        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
-        upgrade << "Upgrade: WebSocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
-        upgrade << "WebSocket-Location: #{@socket.url}\r\n"
-        upgrade << "\r\n"
-        upgrade
-      end
-
-      def open?
-        true
-      end
-
-      def parse(buffer)
-        buffer.each_byte do |data|
-          case @stage
-            when 0 then
-              parse_leading_byte(data)
-
-            when 1 then
-              value = (data & 0x7F)
-              @length = value + 128 * @length
-
-              if @closing and @length.zero?
-                @socket.close(nil, nil, false)
-              elsif (0x80 & data) != 0x80
-                if @length.zero?
-                  @socket.receive('')
-                  @stage = 0
-                else
-                  @buffer = []
-                  @stage = 2
-                end
-              end
-
-            when 2 then
-              if data == 0xFF
-                @socket.receive(WebSocket.encode(@buffer))
-                @stage = 0
-              else
-                @buffer << data
-                if @length and @buffer.size == @length
-                  @stage = 0
-                end
-              end
-          end
-        end
-
-        nil
-      end
-
-      def parse_leading_byte(data)
-        if (0x80 & data) == 0x80
-          @length = 0
-          @stage = 1
-        else
-          @length = nil
-          @buffer = []
-          @stage = 2
-        end
-      end
-
-      def frame(data, type = nil, error_type = nil)
-        return WebSocket.encode(data) if Array === data
-        ["\x00", data, "\xFF"].map(&WebSocket.method(:encode)) * ''
-      end
-    end
-
-  end
-end
-

data/lib/faye/websocket/draft76_parser.rb

@@ -1,84 +0,0 @@
-module Faye
-  class WebSocket
-
-    class Draft76Parser < Draft75Parser
-      def version
-        'hixie-76'
-      end
-
-      def handshake_response
-        env = @socket.env
-        signature = handshake_signature(env['rack.input'].read)
-
-        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
-        upgrade << "Upgrade: WebSocket\r\n"
-        upgrade << "Connection: Upgrade\r\n"
-        upgrade << "Sec-WebSocket-Origin: #{env['HTTP_ORIGIN']}\r\n"
-        upgrade << "Sec-WebSocket-Location: #{@socket.url}\r\n"
-        upgrade << "\r\n"
-        upgrade << signature if signature
-        upgrade
-      end
-
-      def handshake_signature(head)
-        return nil if head.empty?
-        env = @socket.env
-
-        key1   = env['HTTP_SEC_WEBSOCKET_KEY1']
-        value1 = number_from_key(key1) / spaces_in_key(key1)
-
-        key2   = env['HTTP_SEC_WEBSOCKET_KEY2']
-        value2 = number_from_key(key2) / spaces_in_key(key2)
-
-        @handshake_complete = true
-
-        Digest::MD5.digest(big_endian(value1) +
-                           big_endian(value2) +
-                           head)
-      end
-
-      def open?
-        !!@handshake_complete
-      end
-
-      def parse(data)
-        return super if @handshake_complete
-        handshake_signature(data)
-      end
-
-      def close(code = nil, reason = nil, &callback)
-        return if @closed
-        @socket.send([0xFF, 0x00]) if @closing
-        @closed = true
-        callback.call if callback
-      end
-
-    private
-
-      def parse_leading_byte(data)
-        return super unless data == 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
-
-      def big_endian(number)
-        string = ''
-        [24,16,8,0].each do |offset|
-          string << (number >> offset & 0xFF).chr
-        end
-        string
-      end
-    end
-
-  end
-end
-

data/lib/faye/websocket/hybi_parser.rb

@@ -1,321 +0,0 @@
-module Faye
-  class WebSocket
-
-    class HybiParser
-      root = File.expand_path('../hybi_parser', __FILE__)
-      autoload :Handshake, root + '/handshake'
-      autoload :StreamReader, root + '/stream_reader'
-
-      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
-      }
-
-      FRAGMENTED_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
-
-      attr_reader :protocol
-
-      def initialize(web_socket, options = {})
-        reset
-        @socket    = web_socket
-        @reader    = StreamReader.new
-        @stage     = 0
-        @masking   = options[:masking]
-        @protocols = options[:protocols]
-        @protocols = @protocols.split(/\s*,\s*/) if String === @protocols
-
-        @ping_callbacks = {}
-      end
-
-      def version
-        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
-      end
-
-      def handshake_response
-        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
-        return '' unless String === sec_key
-
-        accept    = Base64.encode64(Digest::SHA1.digest(sec_key + Handshake::GUID)).strip
-        protos    = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
-        supported = @protocols
-        proto     = nil
-
-        headers = [
-          "HTTP/1.1 101 Switching Protocols",
-          "Upgrade: websocket",
-          "Connection: Upgrade",
-          "Sec-WebSocket-Accept: #{accept}"
-        ]
-
-        if protos and supported
-          protos = protos.split(/\s*,\s*/) if String === protos
-          proto = protos.find { |p| supported.include?(p) }
-          if proto
-            @protocol = proto
-            headers << "Sec-WebSocket-Protocol: #{proto}"
-          end
-        end
-
-        (headers + ['','']).join("\r\n")
-      end
-
-      def create_handshake
-        Handshake.new(@socket.uri, @protocols)
-      end
-
-      def open?
-        true
-      end
-
-      def parse(data)
-        @reader.put(data.bytes.to_a)
-        buffer = true
-        while buffer
-          case @stage
-            when 0 then
-              buffer = @reader.read(1)
-              parse_opcode(buffer[0]) if buffer
-
-            when 1 then
-              buffer = @reader.read(1)
-              parse_length(buffer[0]) if buffer
-
-            when 2 then
-              buffer = @reader.read(@length_size)
-              parse_extended_length(buffer) if buffer
-
-            when 3 then
-              buffer = @reader.read(4)
-              if buffer
-                @mask  = buffer
-                @stage = 4
-              end
-
-            when 4 then
-              buffer = @reader.read(@length)
-              if buffer
-                @payload = buffer
-                emit_frame
-                @stage = 0
-              end
-          end
-        end
-
-        nil
-      end
-
-      def frame(data, type = nil, code = nil)
-        return nil if @closed
-
-        is_text = (String === data)
-        opcode  = OPCODES[type || (is_text ? :text : :binary)]
-        buffer  = data.respond_to?(:bytes) ? data.bytes.to_a : data
-        insert  = code ? 2 : 0
-        length  = buffer.size + insert
-        header  = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10)
-        offset  = header + (@masking ? 4 : 0)
-        masked  = @masking ? MASK : 0
-        frame   = Array.new(offset)
-
-        frame[0] = FIN | opcode
-
-        if length <= 125
-          frame[1] = masked | length
-        elsif length <= 65535
-          frame[1] = masked | 126
-          frame[2] = (length >> 8) & BYTE
-          frame[3] = length & BYTE
-        else
-          frame[1] = masked | 127
-          frame[2] = (length >> 56) & BYTE
-          frame[3] = (length >> 48) & BYTE
-          frame[4] = (length >> 40) & BYTE
-          frame[5] = (length >> 32) & BYTE
-          frame[6] = (length >> 24) & BYTE
-          frame[7] = (length >> 16) & BYTE
-          frame[8] = (length >> 8)  & BYTE
-          frame[9] = length & BYTE
-        end
-
-        if code
-          buffer = [(code >> 8) & BYTE, code & BYTE] + buffer
-        end
-
-        if @masking
-          mask = [rand(256), rand(256), rand(256), rand(256)]
-          frame[header...offset] = mask
-          buffer = WebSocketMask.mask(buffer, mask)
-        end
-
-        frame.concat(buffer)
-
-        WebSocket.encode(frame)
-      end
-
-      def ping(message = '', &callback)
-        @ping_callbacks[message] = callback if callback
-        @socket.send(message, :ping)
-      end
-
-      def close(code = nil, reason = nil, &callback)
-        return if @closed
-        @closing_callback ||= callback
-        @socket.send(reason || '', :close, code || ERRORS[:normal_closure])
-        @closed = true
-      end
-
-    private
-
-      def parse_opcode(data)
-        if [RSV1, RSV2, RSV3].any? { |rsv| (data & rsv) == rsv }
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-
-        @final   = (data & FIN) == FIN
-        @opcode  = (data & OPCODE)
-        @mask    = []
-        @payload = []
-
-        unless OPCODES.values.include?(@opcode)
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-
-        unless FRAGMENTED_OPCODES.include?(@opcode) or @final
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-
-        if @mode and OPENING_OPCODES.include?(@opcode)
-          return @socket.close(ERRORS[:protocol_error], nil, false)
-        end
-
-        @stage = 1
-      end
-
-      def parse_length(data)
-        @masked = (data & MASK) == MASK
-        @length = (data & LENGTH)
-
-        if @length <= 125
-          @stage = @masked ? 3 : 4
-        else
-          @length_size = (@length == 126) ? 2 : 8
-          @stage       = 2
-        end
-      end
-
-      def parse_extended_length(buffer)
-        @length = integer(buffer)
-        @stage  = @masked ? 3 : 4
-      end
-
-      def emit_frame
-        payload = @masked ? WebSocketMask.mask(@payload, @mask) : @payload
-
-        case @opcode
-          when OPCODES[:continuation] then
-            return @socket.close(ERRORS[:protocol_error], nil, false) unless @mode
-            @buffer.concat(payload)
-            if @final
-              message = @buffer
-              message = WebSocket.encode(message, true) if @mode == :text
-              reset
-              if message
-                @socket.receive(message)
-              else
-                @socket.close(ERRORS[:encoding_error], nil, false)
-              end
-            end
-
-          when OPCODES[:text] then
-            if @final
-              message = WebSocket.encode(payload, true)
-              if message
-                @socket.receive(message)
-              else
-                @socket.close(ERRORS[:encoding_error], nil, false)
-              end
-            else
-              @mode = :text
-              @buffer.concat(payload)
-            end
-
-          when OPCODES[:binary] then
-            if @final
-              @socket.receive(payload)
-            else
-              @mode = :binary
-              @buffer.concat(payload)
-            end
-
-          when OPCODES[:close] then
-            code = (payload.size >= 2) ? 256 * payload[0] + payload[1] : nil
-
-            unless (payload.size == 0) or
-                   (code && code >= 3000 && code < 5000) or
-                   ERROR_CODES.include?(code)
-              code = ERRORS[:protocol_error]
-            end
-
-            if payload.size > 125 or not WebSocket.valid_utf8?(payload[2..-1] || [])
-              code = ERRORS[:protocol_error]
-            end
-
-            reason = (payload.size > 2) ? WebSocket.encode(payload[2..-1], true) : nil
-            @socket.close(code, reason, false)
-            @closing_callback.call if @closing_callback
-
-          when OPCODES[:ping] then
-            return @socket.close(ERRORS[:protocol_error], nil, false) if payload.size > 125
-            @socket.send(payload, :pong)
-
-          when OPCODES[:pong] then
-            message = WebSocket.encode(payload, true)
-            callback = @ping_callbacks[message]
-            @ping_callbacks.delete(message)
-            callback.call if callback
-        end
-      end
-
-      def reset
-        @buffer = []
-        @mode   = nil
-      end
-
-      def integer(bytes)
-        number = 0
-        bytes.each_with_index do |data, i|
-          number += data << (8 * (bytes.size - 1 - i))
-        end
-        number
-      end
-    end
-
-  end
-end