websocket-driver 0.4.0-java → 0.5.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79be3fa7f1a4429fda1463f0ab0f809004b82593
-  data.tar.gz: eed2e51b0a21fade327b48c4dab184afb92cc7dd
+  metadata.gz: bc15766e2fa0e536038e29fadff1132446bce140
+  data.tar.gz: ad665aaf5f8088712fd10524cb99ab8911013215
 SHA512:
-  metadata.gz: 1f718f23af5483c2c30995c63b2d40a64d2077cc23fd1d0e34e551a9f7d06618883a7a45b5d884c4d334d1d7036263b93e52c8249bcee84146295fe8c8cd0506
-  data.tar.gz: f0486b76187ee8a9d750621aac8498ac4dd4b4ab7f2f8d9a19e7af9b6c35532cab2ebdfd25b17ed38721eccb4d918bc8adc7c0c19f2eb70d914d34f79cd2bec4
+  metadata.gz: f11999301bb7c87b560543d2668841fe03ddcfd2545f49009096c707a5d266ffedbc3430450579a36218b4d09c8925923cf27607d45a215d2cfb71832473bb96
+  data.tar.gz: 9c79cd87ff2541ee12d0b953f9993dae2db27460a39bb197a4115f68f727479794ecd943d5ab7fb57293d2fac7ddf59ceda291355e42b5fdb80be8ec93f48a54

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+### 0.5.0 / 2014-12-13
+
+* Support protocol extensions via the websocket-extensions module
+
 ### 0.4.0 / 2014-11-08
 
 * Support connection via HTTP proxies using `CONNECT`

data/README.md

@@ -14,6 +14,9 @@ hook this module up to some I/O object, it will do all of this for you:
 * Generate and send both server- and client-side handshakes
 * Recognize when the handshake phase completes and the WS protocol begins
 * Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
+* Negotiate and use extensions via the
+  [websocket-extensions](https://github.com/faye/websocket-extensions-ruby)
+  module
 * Buffer sent messages until the handshake process is finished
 * Deal with proxies that defer delivery of the draft-76 handshake body
 * Notify you when the socket is open and closed and when messages arrive
@@ -291,6 +294,13 @@ describing the error.
 Sets the callback block to execute when the socket becomes closed. The `event`
 object has `code` and `reason` attributes.
 
+#### `driver.add_extension(extension)`
+
+Registers a protocol extension whose operation will be negotiated via the
+`Sec-WebSocket-Extensions` header. `extension` is any extension compatible with
+the [websocket-extensions](https://github.com/faye/websocket-extensions-ruby)
+framework.
+
 #### `driver.set_header(name, value)`
 
 Sets a custom header to be sent as part of the handshake response, either from

data/examples/tcp_server.rb

@@ -2,10 +2,12 @@ require 'rubygems'
 require 'bundler/setup'
 require 'eventmachine'
 require 'websocket/driver'
+require 'permessage_deflate'
 
 module Connection
   def initialize
     @driver = WebSocket::Driver.server(self)
+    @driver.add_extension(PermessageDeflate)
 
     @driver.on(:connect) { |e| @driver.start if WebSocket::Driver.websocket? @driver.env }
     @driver.on(:message) { |e| @driver.frame(e.data) }

data/ext/websocket-driver/WebsocketMaskService.java

@@ -4,11 +4,10 @@ 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.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
@@ -39,27 +38,18 @@ public class WebsocketMaskService implements BasicLibraryService {
 
     @JRubyMethod
     public IRubyObject mask(ThreadContext context, IRubyObject payload, IRubyObject mask) {
-      if (mask.isNil() || ((RubyArray)mask).getLength() == 0) {
-        return payload;
-      }
+      if (mask.isNil()) return payload;
 
-      int n = ((RubyArray)payload).getLength(), i;
-      long p, m;
-      RubyArray unmasked = RubyArray.newArray(runtime, n);
+      byte[] payload_a = ((RubyString)payload).getBytes();
+      byte[] mask_a    = ((RubyString)mask).getBytes();
+      int i, n         = payload_a.length;
 
-      long[] maskArray = {
-        (Long)((RubyArray)mask).get(0),
-        (Long)((RubyArray)mask).get(1),
-        (Long)((RubyArray)mask).get(2),
-        (Long)((RubyArray)mask).get(3)
-      };
+      if (n == 0) return payload;
 
       for (i = 0; i < n; i++) {
-        p = (Long)((RubyArray)payload).get(i);
-        m = maskArray[i % 4];
-        unmasked.set(i, p ^ m);
+        payload_a[i] ^= mask_a[i % 4];
       }
-      return unmasked;
+      return RubyString.newStringNoCopy(runtime, payload_a);
     }
   }
 }

data/ext/websocket-driver/websocket_mask.c

@@ -6,32 +6,36 @@ VALUE WebSocketMask = Qnil;
 void Init_websocket_mask();
 VALUE method_websocket_mask(VALUE self, VALUE payload, VALUE mask);
 
-void Init_websocket_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) {
-  int n, i, p, m;
-  int mask_array[4];
+VALUE
+method_websocket_mask(VALUE self,
+                      VALUE payload,
+                      VALUE mask)
+{
+  char *payload_s, *mask_s, *unmasked_s;
+  int i, n;
   VALUE unmasked;
 
-  if (mask == Qnil || RARRAY_LEN(mask) == 0) {
+  if (mask == Qnil || RSTRING_LEN(mask) != 4) {
     return payload;
   }
 
-  n = RARRAY_LEN(payload);
-  unmasked = rb_ary_new2(n);
+  payload_s = RSTRING_PTR(payload);
+  mask_s    = RSTRING_PTR(mask);
+  n         = RSTRING_LEN(payload);
 
-  for (i = 0; i < 4; i++) {
-    mask_array[i] = NUM2INT(rb_ary_entry(mask, i));
-  }
+  unmasked   = rb_str_new(0, n);
+  unmasked_s = RSTRING_PTR(unmasked);
 
   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));
+    unmasked_s[i] = payload_s[i] ^ mask_s[i % 4];
   }
   return unmasked;
 }

data/lib/websocket/driver.rb

@@ -7,9 +7,11 @@
 require 'base64'
 require 'digest/md5'
 require 'digest/sha1'
+require 'securerandom'
 require 'set'
 require 'stringio'
 require 'uri'
+require 'websocket/extensions'
 
 module WebSocket
   autoload :HTTP, File.expand_path('../http', __FILE__)
@@ -73,6 +75,10 @@ module WebSocket
       STATES[@ready_state]
     end
 
+    def add_extension(extension)
+      false
+    end
+
     def set_header(name, value)
       return false unless @ready_state <= 0
       @headers[name] = value
@@ -139,29 +145,19 @@ module WebSocket
     end
 
     def self.encode(string, encoding = nil)
-      if Array === string
-        string = string.pack('C*')
-        encoding ||= :binary
-      else
-        encoding ||= :utf8
-      end
-      case encoding
-      when :binary
-        string.force_encoding('ASCII-8BIT') if string.respond_to?(:force_encoding)
-      when :utf8
-        string.force_encoding('UTF-8') if string.respond_to?(:force_encoding)
-        return nil unless valid_utf8?(string)
+      case string
+        when Array then
+          string = string.pack('C*')
+          encoding ||= :binary
+        when String then
+          encoding ||= :utf8
       end
+      encodings = {:utf8 => 'UTF-8', :binary => 'ASCII-8BIT'}
+      string.force_encoding(encodings[encoding]) if string.respond_to?(:force_encoding)
+      return nil if encoding == :utf8 and not valid_utf8?(string)
       string
     end
 
-    def self.utf8_string(string)
-      string = string.pack('C*') if Array === string
-      string.respond_to?(:force_encoding) ?
-          string.force_encoding('UTF-8') :
-          string
-    end
-
     def self.valid_utf8?(string)
       if defined?(UTF8_MATCH)
         UTF8_MATCH =~ string ? true : false
@@ -175,7 +171,7 @@ module WebSocket
       upgrade    = env['HTTP_UPGRADE']    || ''
 
       env['REQUEST_METHOD'] == 'GET' and
-      connection.downcase.split(/\s*,\s*/).include?('upgrade') and
+      connection.downcase.split(/ *, */).include?('upgrade') and
       upgrade.downcase == 'websocket'
     end
 

data/lib/websocket/driver/client.rb

@@ -57,14 +57,21 @@ module WebSocket
 
         @http.parse(buffer)
         return fail_handshake('Invalid HTTP response') if @http.error?
+        return unless @http.complete?
 
-        validate_handshake if @http.complete?
-        parse(@http.body) if @ready_state == 1
+        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")
@@ -114,7 +121,11 @@ module WebSocket
           end
         end
 
-        open
+        begin
+          @extensions.activate(@headers['Sec-WebSocket-Extensions'])
+        rescue ::WebSocket::Extensions::ExtensionError => e
+          return fail_handshake(e.message)
+        end
       end
     end
 

data/lib/websocket/driver/draft75.rb

@@ -25,9 +25,8 @@ module WebSocket
 
       def parse(buffer)
         return if @ready_state > 1
-        buffer = buffer.bytes if buffer.respond_to?(:bytes)
 
-        buffer.each do |data|
+        buffer.each_byte do |data|
           case @stage
             when -1 then
               @body << data

data/lib/websocket/driver/draft76.rb

@@ -8,7 +8,7 @@ module WebSocket
         super
         input  = @socket.env['rack.input']
         @stage = -1
-        @body  = input ? input.read.bytes.to_a : []
+        @body  = Driver.encode(input ? input.read : '', :binary)
 
         @headers.clear
         @headers['Upgrade'] = 'WebSocket'
@@ -44,16 +44,12 @@ module WebSocket
       end
 
       def handshake_signature
-        return nil unless @body.size >= BODY_SIZE
-
-        head = @body[0...BODY_SIZE].pack('C*')
-        head.force_encoding('ASCII-8BIT') if head.respond_to?(:force_encoding)
-
-        env = @socket.env
+        return nil unless @body.bytesize >= BODY_SIZE
 
+        head   = @body[0...BODY_SIZE]
+        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)
 
@@ -67,7 +63,7 @@ module WebSocket
         @socket.write(Driver.encode(signature, :binary))
         @stage = 0
         open
-        parse(@body[BODY_SIZE..-1]) if @body.size > BODY_SIZE
+        parse(@body[BODY_SIZE..-1]) if @body.bytesize > BODY_SIZE
       end
 
       def parse_leading_byte(data)
@@ -86,7 +82,7 @@ module WebSocket
       end
 
       def big_endian(number)
-        string = ''
+        string = Driver.encode('', :binary)
         [24, 16, 8, 0].each do |offset|
           string << (number >> offset & 0xFF).chr
         end

data/lib/websocket/driver/hybi.rb

@@ -3,6 +3,9 @@ module WebSocket
 
     class Hybi < Driver
       root = File.expand_path('../hybi', __FILE__)
+
+      autoload :Frame,        root + '/frame'
+      autoload :Message,      root + '/message'
       autoload :StreamReader, root + '/stream_reader'
 
       def self.generate_accept(key)
@@ -28,9 +31,9 @@ module WebSocket
         :pong         => 10
       }
 
-      OPCODE_CODES       = OPCODES.values
-      FRAGMENTED_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
-      OPENING_OPCODES    = OPCODES.values_at(:text, :binary)
+      OPCODE_CODES    = OPCODES.values
+      MESSAGE_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
+      OPENING_OPCODES = OPCODES.values_at(:text, :binary)
 
       ERRORS = {
         :normal_closure       => 1000,
@@ -50,13 +53,13 @@ module WebSocket
 
       def initialize(socket, options = {})
         super
-        reset
 
+        @extensions      = ::WebSocket::Extensions.new
         @reader          = StreamReader.new
         @stage           = 0
         @masking         = options[:masking]
         @protocols       = options[:protocols] || []
-        @protocols       = @protocols.strip.split(/\s*,\s*/) if String === @protocols
+        @protocols       = @protocols.strip.split(/ *, */) if String === @protocols
         @require_masking = options[:require_masking]
         @ping_callbacks  = {}
 
@@ -70,7 +73,7 @@ module WebSocket
         @headers['Sec-WebSocket-Accept'] = Hybi.generate_accept(sec_key)
 
         if protos = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
-          protos = protos.split(/\s*,\s*/) if String === protos
+          protos = protos.split(/ *, */) if String === protos
           @protocol = protos.find { |p| @protocols.include?(p) }
           @headers['Sec-WebSocket-Protocol'] = @protocol if @protocol
         end
@@ -80,35 +83,38 @@ module WebSocket
         "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
       end
 
+      def add_extension(extension)
+        @extensions.add(extension)
+        true
+      end
+
       def parse(data)
-        data = data.bytes.to_a if data.respond_to?(:bytes)
         @reader.put(data)
         buffer = true
         while buffer
           case @stage
             when 0 then
               buffer = @reader.read(1)
-              parse_opcode(buffer[0]) if buffer
+              parse_opcode(buffer.getbyte(0)) if buffer
 
             when 1 then
               buffer = @reader.read(1)
-              parse_length(buffer[0]) if buffer
+              parse_length(buffer.getbyte(0)) if buffer
 
             when 2 then
-              buffer = @reader.read(@length_size)
+              buffer = @reader.read(@frame.length_bytes)
               parse_extended_length(buffer) if buffer
 
             when 3 then
               buffer = @reader.read(4)
               if buffer
-                @mask  = buffer
+                @frame.masking_key = buffer
                 @stage = 4
               end
 
             when 4 then
-              buffer = @reader.read(@length)
+              buffer = @reader.read(@frame.length)
               if buffer
-                @payload = buffer
                 emit_frame(buffer)
                 @stage = 0
               end
@@ -119,59 +125,6 @@ module WebSocket
         end
       end
 
-      def frame(data, type = nil, code = nil)
-        return queue([data, type, code]) if @ready_state <= 0
-        return false unless @ready_state == 1
-
-        data = data.to_s unless Array === data
-        data = Driver.encode(data, :utf8) if String === data
-
-        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 = Mask.mask(buffer, mask)
-        end
-
-        frame.concat(buffer)
-
-        @socket.write(Driver.encode(frame, :binary))
-        true
-      end
-
       def text(message)
         frame(message, :text)
       end
@@ -202,9 +155,91 @@ module WebSocket
         end
       end
 
+      def frame(data, type = nil, code = nil)
+        return queue([data, type, code]) if @ready_state <= 0
+        return false unless @ready_state == 1
+
+        message = Message.new
+        frame   = Frame.new
+        is_text = String === data
+
+        message.rsv1   = message.rsv2 = message.rsv3 = false
+        message.opcode = OPCODES[type || (is_text ? :text : :binary)]
+
+        payload = is_text ? data.bytes.to_a : data
+        if code
+          payload = [(code >> 8) & BYTE, code & BYTE, *payload]
+        end
+        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
+      end
+
     private
 
+      def send_frame(frame)
+        length = frame.length
+        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10)
+        offset = header + (frame.masked ? 4 : 0)
+        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] = (length >> 8) & BYTE
+          buffer[3] = length & BYTE
+        else
+          buffer[1] = masked | 127
+          buffer[2] = (length >> 56) & BYTE
+          buffer[3] = (length >> 48) & BYTE
+          buffer[4] = (length >> 40) & BYTE
+          buffer[5] = (length >> 32) & BYTE
+          buffer[6] = (length >> 24) & BYTE
+          buffer[7] = (length >> 16) & BYTE
+          buffer[8] = (length >> 8)  & BYTE
+          buffer[9] = length & BYTE
+        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*'))
+
+      rescue ::WebSocket::Extensions::ExtensionError => e
+        fail(:extension_error, e.message)
+      end
+
       def handshake_response
+        extensions = @extensions.generate_response(@socket.env['HTTP_SEC_WEBSOCKET_EXTENSIONS'])
+        @headers['Sec-WebSocket-Extensions'] = extensions if extensions
+
         start   = 'HTTP/1.1 101 Switching Protocols'
         headers = [start, @headers.to_s, '']
         headers.join("\r\n")
@@ -212,9 +247,11 @@ module WebSocket
 
       def shutdown(code, reason)
         frame(reason, :close, code)
+        @frame = @message = nil
         @ready_state = 3
         @stage = 5
         emit(:close, CloseEvent.new(code, reason))
+        @extensions.close
       end
 
       def fail(type, message)
@@ -225,25 +262,30 @@ module WebSocket
       def parse_opcode(data)
         rsvs = [RSV1, RSV2, RSV3].map { |rsv| (data & rsv) == rsv }
 
-        if rsvs.any?
+        @frame = Frame.new
+
+        @frame.final  = (data & FIN) == FIN
+        @frame.rsv1   = rsvs[0]
+        @frame.rsv2   = rsvs[1]
+        @frame.rsv3   = rsvs[2]
+        @frame.opcode = (data & OPCODE)
+
+        unless @extensions.valid_frame_rsv?(@frame)
           return fail(:protocol_error,
-              "One or more reserved bits are on: reserved1 = #{rsvs[0] ? 1 : 0}" +
-              ", reserved2 = #{rsvs[1] ? 1 : 0 }" +
-              ", reserved3 = #{rsvs[2] ? 1 : 0 }")
+              "One or more reserved bits are on: reserved1 = #{@frame.rsv1 ? 1 : 0}" +
+              ", reserved2 = #{@frame.rsv2 ? 1 : 0 }" +
+              ", reserved3 = #{@frame.rsv3 ? 1 : 0 }")
         end
 
-        @final   = (data & FIN) == FIN
-        @opcode  = (data & OPCODE)
-
-        unless OPCODES.values.include?(@opcode)
-          return fail(:protocol_error, "Unrecognized frame opcode: #{@opcode}")
+        unless OPCODES.values.include?(@frame.opcode)
+          return fail(:protocol_error, "Unrecognized frame opcode: #{@frame.opcode}")
         end
 
-        unless FRAGMENTED_OPCODES.include?(@opcode) or @final
-          return fail(:protocol_error, "Received fragmented control frame: opcode = #{@opcode}")
+        unless MESSAGE_OPCODES.include?(@frame.opcode) or @frame.final
+          return fail(:protocol_error, "Received fragmented control frame: opcode = #{@frame.opcode}")
         end
 
-        if @mode and OPENING_OPCODES.include?(@opcode)
+        if @message and OPENING_OPCODES.include?(@frame.opcode)
           return fail(:protocol_error, 'Received new data frame but previous continuous frame is unfinished')
         end
 
@@ -251,36 +293,38 @@ module WebSocket
       end
 
       def parse_length(data)
-        @masked = (data & MASK) == MASK
-        if @require_masking and not @masked
+        @frame.masked = (data & MASK) == MASK
+        if @require_masking and not @frame.masked
           return fail(:unacceptable, 'Received unmasked frame but masking is required')
         end
 
-        @length = (data & LENGTH)
+        @frame.length = (data & LENGTH)
 
-        if @length >= 0 and @length <= 125
+        if @frame.length >= 0 and @frame.length <= 125
           return unless check_frame_length
-          @stage = @masked ? 3 : 4
+          @stage = @frame.masked ? 3 : 4
         else
-          @length_size = (@length == 126) ? 2 : 8
-          @stage       = 2
+          @frame.length_bytes = (@frame.length == 126) ? 2 : 8
+          @stage = 2
         end
       end
 
       def parse_extended_length(buffer)
-        @length = integer(buffer)
+        @frame.length = integer(buffer)
 
-        unless FRAGMENTED_OPCODES.include?(@opcode) or @length <= 125
-          return fail(:protocol_error, "Received control frame having too long payload: #{@length}")
+        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
 
-        @stage  = @masked ? 3 : 4
+        @stage  = @frame.masked ? 3 : 4
       end
 
       def check_frame_length
-        if @buffer.size + @length > @max_length
+        length = @message ? @message.data.bytesize : 0
+
+        if length + @frame.length > @max_length
           fail(:too_large, 'WebSocket frame length too large')
           false
         else
@@ -289,64 +333,37 @@ module WebSocket
       end
 
       def emit_frame(buffer)
-        payload  = Mask.mask(buffer, @mask)
-        is_final = @final
-        opcode   = @opcode
+        frame    = @frame
+        opcode   = frame.opcode
+        payload  = frame.payload = Mask.mask(buffer, @frame.masking_key)
+        bytesize = payload.bytesize
+        bytes    = payload.bytes.to_a
 
-        @final = @opcode = @length = @length_size = @masked = @mask = nil
+        @frame = nil
 
         case opcode
           when OPCODES[:continuation] then
-            return fail(:protocol_error, 'Received unexpected continuation frame') unless @mode
-            @buffer.concat(payload)
-            if is_final
-              message = @buffer
-              message = Driver.encode(message, :utf8) if @mode == :text
-              reset
-              if message
-                emit(:message, MessageEvent.new(message))
-              else
-                fail(:encoding_error, 'Could not decode a text frame as UTF-8')
-              end
-            end
+            return fail(:protocol_error, 'Received unexpected continuation frame') unless @message
+            @message << frame
 
-          when OPCODES[:text] then
-            if is_final
-              message = Driver.encode(payload, :utf8)
-              if message
-                emit(:message, MessageEvent.new(message))
-              else
-                fail(:encoding_error, 'Could not decode a text frame as UTF-8')
-              end
-            else
-              @mode = :text
-              @buffer.concat(payload)
-            end
-
-          when OPCODES[:binary] then
-            if is_final
-              emit(:message, MessageEvent.new(payload))
-            else
-              @mode = :binary
-              @buffer.concat(payload)
-            end
+          when OPCODES[:text], OPCODES[:binary] then
+            @message = Message.new
+            @message << frame
 
           when OPCODES[:close] then
-            code = (payload.size >= 2) ? 256 * payload[0] + payload[1] : nil
+            code   = (bytesize >= 2) ? 256 * bytes[0] + bytes[1] : nil
+            reason = (bytesize > 2)  ? Driver.encode(bytes[2..-1] || [], :utf8) : nil
 
-            unless (payload.size == 0) or
+            unless (bytesize == 0) or
                    (code && code >= MIN_RESERVED_ERROR && code <= MAX_RESERVED_ERROR) or
                    ERROR_CODES.include?(code)
               code = ERRORS[:protocol_error]
             end
 
-            message = Driver.encode(payload[2..-1] || [], :utf8)
-
-            if payload.size > 125 or message.nil?
+            if bytesize > 125 or (bytesize > 2 and reason.nil?)
               code = ERRORS[:protocol_error]
             end
 
-            reason = (payload.size > 2) ? message : ''
             shutdown(code, reason || '')
 
           when OPCODES[:ping] then
@@ -358,17 +375,36 @@ module WebSocket
             @ping_callbacks.delete(message)
             callback.call if callback
         end
+
+        emit_message if frame.final and MESSAGE_OPCODES.include?(opcode)
       end
 
-      def reset
-        @buffer = []
-        @mode   = nil
+      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, :utf8)
+          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 => e
+        fail(:extension_error, e.message)
       end
 
-      def integer(bytes)
+      def integer(buffer)
         number = 0
-        bytes.each_with_index do |data, i|
-          number += data << (8 * (bytes.size - 1 - i))
+        buffer.each_byte.with_index do |data, i|
+          number += data << (8 * (buffer.bytesize - 1 - i))
         end
         number
       end

data/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/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   = Driver.encode('', :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/lib/websocket/driver/hybi/stream_reader.rb

@@ -4,23 +4,22 @@ module WebSocket
     class Hybi
       class StreamReader
         def initialize
-          @queue = []
+          @buffer = Driver.encode('', :binary)
         end
 
-        def read(length)
-          read_bytes(length)
+        def put(string)
+          return unless string and string.bytesize > 0
+          @buffer << Driver.encode(string, :binary)
         end
 
-        def put(bytes)
-          return unless bytes and bytes.size > 0
-          @queue.concat(bytes)
-        end
+        def read(length)
+          buffer_size = @buffer.bytesize
+          return nil if length > buffer_size
 
-      private
+          chunk   = @buffer.byteslice(0, length)
+          @buffer = @buffer.byteslice(length, buffer_size - length)
 
-        def read_bytes(length)
-          return nil if length > @queue.size
-          @queue.shift(length)
+          chunk
         end
       end
     end

data/lib/websocket/driver/proxy.rb

@@ -44,7 +44,7 @@ module WebSocket
         start   = "CONNECT #{@origin.host}:#{port} HTTP/1.1"
         headers = [start, @headers.to_s, '']
 
-        @socket.write(headers.join("\r\n"))
+        @socket.write(Driver.encode(headers.join("\r\n"), :binary))
         true
       end
 

data/lib/websocket/driver/server.rb

@@ -22,7 +22,7 @@ module WebSocket
         url
       end
 
-      %w[set_header start state frame text binary ping close].each do |method|
+      %w[add_extension set_header start frame text binary ping close].each do |method|
         define_method(method) do |*args, &block|
           if @delegate
             @delegate.__send__(method, *args, &block)
@@ -47,7 +47,8 @@ module WebSocket
         return unless @http.complete?
 
         @delegate = Driver.rack(self, @options)
-        @delegate.on(:open) { open }
+        open
+
         EVENTS.each do |event|
           @delegate.on(event) { |e| emit(event, e) }
         end

data/lib/websocket/http/headers.rb

@@ -90,7 +90,15 @@ module WebSocket
 
       def header_line(line)
         return false unless parsed = line.scan(HEADER_LINE).first
-        @headers[HTTP.normalize_header(parsed[0])] = parsed[1].strip
+
+        key   = HTTP.normalize_header(parsed[0])
+        value = parsed[1].strip
+
+        if @headers.has_key?(key)
+          @headers[key] << ', ' << value
+        else
+          @headers[key] = value
+        end
         true
       end
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: websocket-driver
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: java
 authors:
 - James Coglan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-11-08 00:00:00.000000000 Z
+date: 2014-12-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-extensions
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  prerelease: false
+  type: :runtime
 - !ruby/object:Gem::Dependency
   name: eventmachine
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +38,20 @@ dependencies:
         version: '0'
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: permessage_deflate
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   version_requirements: !ruby/object:Gem::Requirement
@@ -65,22 +93,24 @@ files:
 - ext/websocket-driver/WebsocketMaskService.java
 - ext/websocket-driver/extconf.rb
 - examples/tcp_server.rb
-- lib/websocket/websocket_mask.rb
 - lib/websocket/driver.rb
 - lib/websocket/http.rb
-- lib/websocket/http/request.rb
-- lib/websocket/http/response.rb
-- lib/websocket/http/headers.rb
-- lib/websocket/driver/hybi.rb
+- lib/websocket/websocket_mask.rb
 - lib/websocket/driver/client.rb
+- lib/websocket/driver/draft75.rb
 - lib/websocket/driver/draft76.rb
+- lib/websocket/driver/event_emitter.rb
+- lib/websocket/driver/headers.rb
+- lib/websocket/driver/hybi.rb
 - lib/websocket/driver/proxy.rb
 - lib/websocket/driver/server.rb
-- lib/websocket/driver/draft75.rb
-- lib/websocket/driver/headers.rb
 - lib/websocket/driver/utf8_match.rb
-- lib/websocket/driver/event_emitter.rb
+- lib/websocket/driver/hybi/frame.rb
+- lib/websocket/driver/hybi/message.rb
 - lib/websocket/driver/hybi/stream_reader.rb
+- lib/websocket/http/headers.rb
+- lib/websocket/http/request.rb
+- lib/websocket/http/response.rb
 - lib/websocket_mask.jar
 homepage: http://github.com/faye/websocket-driver-ruby
 licenses: