websocket-driver 0.5.4-java → 0.6.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c6f967537a9e90a5e34627cc7b9738443976081
-  data.tar.gz: 7d8b0e815c6bc9fe96d63e397b0af3600df3d3ed
+  metadata.gz: 4c10bbc50ea2348fbb23d243ca2c26ca10b7852c
+  data.tar.gz: b4fae4fc45971242b4cd24d142c6abd25818fdb7
 SHA512:
-  metadata.gz: 617369b8f735060d83e95b573dd17a7ae795675c1f3b056c20416547d884f7d17de56fcde9de9c3daea23d5db1d024dc12d269ff4fa20c2b0aa786d91f829a83
-  data.tar.gz: 39f201f433cb3814f3833faef99af9678dc2887c87550343e317e087fc76fb258af32dc9e84dfd07499bbfcb362344b803f48f0d4fef5f6e6a2c01ca12d5617a
+  metadata.gz: f53a36ffb90e346faa9662e8fb270b20e3b4ac78eba3c51a1511b432c38bfcfe22ea783eac3a31f035a4d9c65d45f72bbc880ba4c0e71832edc3117614506d78
+  data.tar.gz: 0ad4d8184eeff96b45eb40f308059a84dbe19f12146d10f0edc7496005854e527127e8b26a24b0d526c0a0033c8449dfea91d7e8d3150f3b110dfb8227de7f2f

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+### 0.6.0 / 2015-07-08
+
+* Use `SecureRandom` to generate the `Sec-WebSocket-Key` header
+* Allow the parser to recover cleanly if event listeners raise an error
+* Let the `on()` method take a lambda as a positional argument rather than a block
+* Add a `pong` method for sending unsolicited pong frames
+
 ### 0.5.4 / 2015-03-29
 
 * Don't emit extra close frames if we receive a close frame after we already

data/README.md

@@ -21,7 +21,7 @@ this module up to some I/O object, it will do all of this for you:
 * 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
 * Recombine fragmented messages
-* Dispatch text, binary, ping and close frames
+* Dispatch text, binary, ping, pong and close frames
 * Manage the socket-closing handshake process
 * Automatically reply to ping frames with a matching pong
 * Apply masking to messages sent by the client
@@ -54,6 +54,7 @@ Server-side sockets require one additional method:
   * `HTTP_CONNECTION`
   * `HTTP_HOST`
   * `HTTP_ORIGIN`
+  * `HTTP_SEC_WEBSOCKET_EXTENSIONS`
   * `HTTP_SEC_WEBSOCKET_KEY`
   * `HTTP_SEC_WEBSOCKET_KEY1`
   * `HTTP_SEC_WEBSOCKET_KEY2`
@@ -145,7 +146,7 @@ module Connection
   def initialize
     @driver = WebSocket::Driver.server(self)
 
-    @driver.on(:connect) do
+    @driver.on :connect, -> (event) do
       if WebSocket::Driver.websocket?(@driver.env)
         @driver.start
       else
@@ -153,8 +154,8 @@ module Connection
       end
     end
 
-    @driver.on(:message) { |e| @driver.text(e.data) }
-    @driver.on(:close)   { |e| close_connection_after_writing }
+    @driver.on :message, -> (e) { @driver.text(e.data) }
+    @driver.on :close,   -> (e) { close_connection_after_writing }
   end
 
   def receive_data(data)
@@ -213,7 +214,7 @@ start sending incoming data to `driver.parse(data)` as normal, and call
 ```rb
 proxy = driver.proxy('http://username:password@proxy.example.com')
 
-proxy.on :connect do
+proxy.on :connect, -> (event) do
   driver.start
 end
 ```
@@ -225,7 +226,7 @@ In the event that proxy connection fails, `proxy` will emit an `:error`. You can
 inspect the proxy's response via `proxy.status` and `proxy.headers`.
 
 ```rb
-proxy.on :error do |error|
+proxy.on :error, -> (error) do
   puts error.message
   puts proxy.status
   puts proxy.headers.inspect
@@ -273,25 +274,25 @@ Note that most of these methods are commands: if they produce data that should
 be sent over the socket, they will give this to you by calling
 `socket.write(string)`.
 
-#### `driver.on('open') { |event| }`
+#### `driver.on 'open', -> (event) { }`
 
-Sets the callback block to execute when the socket becomes open.
+Adds a callback block to execute when the socket becomes open.
 
-#### `driver.on('message') { |event| }`
+#### `driver.on 'message', -> (event) { }`
 
-Sets the callback block to execute when a message is received. `event` will have
-a `data` attribute containing either a string in the case of a text message or
-an array of integers in the case of a binary message.
+Adds a callback block to execute when a message is received. `event` will have a
+`data` attribute containing either a string in the case of a text message or an
+array of integers in the case of a binary message.
 
-#### `driver.on('error') { |event| }`
+#### `driver.on 'error', -> (event) { }`
 
-Sets the callback to execute when a protocol error occurs due to the other peer
+Adds a callback to execute when a protocol error occurs due to the other peer
 sending an invalid byte sequence. `event` will have a `message` attribute
 describing the error.
 
-#### `driver.on('close') { |event| }`
+#### `driver.on 'close', -> (event) { }`
 
-Sets the callback block to execute when the socket becomes closed. The `event`
+Adds a callback block to execute when the socket becomes closed. The `event`
 object has `code` and `reason` attributes.
 
 #### `driver.add_extension(extension)`
@@ -339,6 +340,15 @@ when the socket receives a pong frame whose content matches `string`. Returns
 `false` if frames can no longer be sent, or if the driver does not support
 ping/pong.
 
+#### `driver.pong(string = '')`
+
+Sends a pong frame over the socket, queueing it if necessary. `string` is
+optional. Returns `false` if frames can no longer be sent, or if the driver does
+not support ping/pong.
+
+You don't need to call this when a ping frame is received; pings are replied to
+automatically by the driver. This method is for sending unsolicited pongs.
+
 #### `driver.close`
 
 Initiates the closing handshake if the socket is still open. For drivers with no

data/lib/websocket/driver.rb

@@ -56,6 +56,7 @@ module WebSocket
     autoload :Hybi,         root + '/hybi'
     autoload :Proxy,        root + '/proxy'
     autoload :Server,       root + '/server'
+    autoload :StreamReader, root + '/stream_reader'
 
     include EventEmitter
     attr_reader :protocol, :ready_state
@@ -65,6 +66,7 @@ module WebSocket
       Driver.validate_options(options, [:max_length, :masking, :require_masking, :protocols])
 
       @socket      = socket
+      @reader      = StreamReader.new
       @options     = options
       @max_length  = options[:max_length] || MAX_LENGTH
       @headers     = Headers.new
@@ -108,6 +110,10 @@ module WebSocket
       false
     end
 
+    def pong(*args)
+      false
+    end
+
     def close(reason = nil, code = nil)
       return false unless @ready_state == 1
       @ready_state = 3

data/lib/websocket/driver/client.rb

@@ -3,7 +3,7 @@ module WebSocket
 
     class Client < Hybi
       def self.generate_key
-        Base64.encode64((1..16).map { rand(255).chr } * '').strip
+        Base64.strict_encode64(SecureRandom.random_bytes(16))
       end
 
       attr_reader :status, :headers
@@ -32,7 +32,7 @@ module WebSocket
         end
 
         if uri.user
-          auth = Base64.encode64([uri.user, uri.password] * ':').gsub(/\n/, '')
+          auth = Base64.strict_encode64([uri.user, uri.password] * ':')
           @headers['Authorization'] = 'Basic ' + auth
         end
       end
@@ -80,8 +80,8 @@ module WebSocket
 
       def fail_handshake(message)
         message = "Error during WebSocket handshake: #{message}"
-        emit(:error, ProtocolError.new(message))
         @ready_state = 3
+        emit(:error, ProtocolError.new(message))
         emit(:close, CloseEvent.new(ERRORS[:protocol_error], message))
       end
 
@@ -124,8 +124,8 @@ module WebSocket
 
         begin
           @extensions.activate(@headers['Sec-WebSocket-Extensions'])
-        rescue ::WebSocket::Extensions::ExtensionError => e
-          return fail_handshake(e.message)
+        rescue ::WebSocket::Extensions::ExtensionError => error
+          return fail_handshake(error.message)
         end
       end
     end

data/lib/websocket/driver/draft75.rb

@@ -26,7 +26,9 @@ module WebSocket
       def parse(buffer)
         return if @ready_state > 1
 
-        buffer.each_byte do |data|
+        @reader.put(buffer)
+
+        @reader.each_byte do |data|
           case @stage
             when -1 then
               @body << data
@@ -52,8 +54,8 @@ module WebSocket
 
             when 2 then
               if data == 0xFF
-                emit(:message, MessageEvent.new(Driver.encode(@buffer, :utf8)))
                 @stage = 0
+                emit(:message, MessageEvent.new(Driver.encode(@buffer, :utf8)))
               else
                 if @length
                   @skipped += 1

data/lib/websocket/driver/event_emitter.rb

@@ -6,16 +6,20 @@ module WebSocket
         @listeners = Hash.new { |h,k| h[k] = [] }
       end
 
-      def add_listener(event, &listener)
+      def add_listener(event, callable = nil, &block)
+        listener = callable || block
         @listeners[event.to_s] << listener
+        listener
       end
 
-      def on(event, &listener)
-        add_listener(event, &listener)
+      def on(event, callable = nil, &block)
+        add_listener(event, callable, &block)
       end
 
-      def remove_listener(event, &listener)
+      def remove_listener(event, callable = nil, &block)
+        listener = callable || block
         @listeners[event.to_s].delete(listener)
+        listener
       end
 
       def remove_all_listeners(event = nil)

data/lib/websocket/driver/hybi.rb

@@ -4,12 +4,11 @@ module WebSocket
     class Hybi < Driver
       root = File.expand_path('../hybi', __FILE__)
 
-      autoload :Frame,        root + '/frame'
-      autoload :Message,      root + '/message'
-      autoload :StreamReader, root + '/stream_reader'
+      autoload :Frame,   root + '/frame'
+      autoload :Message, root + '/message'
 
       def self.generate_accept(key)
-        Base64.encode64(Digest::SHA1.digest(key + GUID)).strip
+        Base64.strict_encode64(Digest::SHA1.digest(key + GUID))
       end
 
       GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
@@ -55,7 +54,6 @@ module WebSocket
         super
 
         @extensions      = ::WebSocket::Extensions.new
-        @reader          = StreamReader.new
         @stage           = 0
         @masking         = options[:masking]
         @protocols       = options[:protocols] || []
@@ -108,15 +106,16 @@ module WebSocket
             when 3 then
               buffer = @reader.read(4)
               if buffer
-                @frame.masking_key = buffer
                 @stage = 4
+                @frame.masking_key = buffer
               end
 
             when 4 then
               buffer = @reader.read(@frame.length)
+
               if buffer
-                emit_frame(buffer)
                 @stage = 0
+                emit_frame(buffer)
               end
 
             else
@@ -138,6 +137,10 @@ module WebSocket
         frame(message, :ping)
       end
 
+      def pong(message = '')
+        frame(message, :pong)
+      end
+
       def close(reason = nil, code = nil)
         reason ||= ''
         code   ||= ERRORS[:normal_closure]
@@ -188,6 +191,9 @@ module WebSocket
 
         send_frame(frame)
         true
+
+      rescue ::WebSocket::Extensions::ExtensionError => error
+        fail(:extension_error, error.message)
       end
 
     private
@@ -231,16 +237,13 @@ module WebSocket
         end
 
         @socket.write(buffer.pack('C*'))
-
-      rescue ::WebSocket::Extensions::ExtensionError => e
-        fail(:extension_error, e.message)
       end
 
       def handshake_response
         begin
           extensions = @extensions.generate_response(@socket.env['HTTP_SEC_WEBSOCKET_EXTENSIONS'])
-        rescue => e
-          fail(:protocol_error, e.message)
+        rescue => error
+          fail(:protocol_error, error.message)
           return nil
         end
 
@@ -251,19 +254,21 @@ module WebSocket
         headers.join("\r\n")
       end
 
-      def shutdown(code, reason)
-        frame(reason, :close, code) if @ready_state < 2
+      def shutdown(code, reason, error = false)
         @frame = @message = nil
-        @ready_state = 3
         @stage = 5
-        emit(:close, CloseEvent.new(code, reason))
         @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
-        emit(:error, ProtocolError.new(message))
-        shutdown(ERRORS[type], message)
+        shutdown(ERRORS[type], message, true)
       end
 
       def parse_opcode(data)
@@ -277,6 +282,8 @@ module WebSocket
         @frame.rsv3   = rsvs[2]
         @frame.opcode = (data & 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}" +
@@ -295,37 +302,34 @@ module WebSocket
         if @message and OPENING_OPCODES.include?(@frame.opcode)
           return fail(:protocol_error, 'Received new data frame but previous continuous frame is unfinished')
         end
-
-        @stage = 1
       end
 
       def parse_length(data)
         @frame.masked = (data & MASK) == MASK
-        if @require_masking and not @frame.masked
-          return fail(:unacceptable, 'Received unmasked frame but masking is required')
-        end
-
         @frame.length = (data & LENGTH)
 
         if @frame.length >= 0 and @frame.length <= 125
-          return unless check_frame_length
           @stage = @frame.masked ? 3 : 4
+          return unless check_frame_length
         else
-          @frame.length_bytes = (@frame.length == 126) ? 2 : 8
           @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 = integer(buffer)
+        @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
-
-        @stage  = @frame.masked ? 3 : 4
       end
 
       def check_frame_length
@@ -404,8 +408,8 @@ module WebSocket
         else
           fail(:encoding_error, 'Could not decode a text frame as UTF-8')
         end
-      rescue ::WebSocket::Extensions::ExtensionError => e
-        fail(:extension_error, e.message)
+      rescue ::WebSocket::Extensions::ExtensionError => error
+        fail(:extension_error, error.message)
       end
 
       def integer(buffer)

data/lib/websocket/driver/proxy.rb

@@ -25,7 +25,7 @@ module WebSocket
         @headers['Proxy-Connection'] = 'keep-alive'
 
         if @url.user
-          auth = Base64.encode64([@url.user, @url.password] * ':').gsub(/\n/, '')
+          auth = Base64.strict_encode64([@url.user, @url.password] * ':')
           @headers['Proxy-Authorization'] = 'Basic ' + auth
         end
       end
@@ -56,7 +56,7 @@ module WebSocket
         @headers = Headers.new(@http.headers)
 
         if @status == 200
-          emit(:connect)
+          emit(:connect, ConnectEvent.new)
         else
           message = "Can't establish a connection to the server at #{@socket.url}"
           emit(:error, ProtocolError.new(message))

data/lib/websocket/driver/stream_reader.rb

@@ -0,0 +1,55 @@
+module WebSocket
+  class Driver
+
+    class StreamReader
+      # Try to minimise the number of reallocations done:
+      MINIMUM_AUTOMATIC_PRUNE_OFFSET = 128
+
+      def initialize
+        @buffer = Driver.encode('', :binary)
+        @offset = 0
+      end
+
+      def put(buffer)
+        return unless buffer and buffer.bytesize > 0
+        @buffer << Driver.encode(buffer, :binary)
+      end
+
+      # Read bytes from the data:
+      def read(length)
+        return nil if (@offset + length) > @buffer.bytesize
+
+        chunk = @buffer.byteslice(@offset, length)
+        @offset += chunk.bytesize
+
+        prune if @offset > MINIMUM_AUTOMATIC_PRUNE_OFFSET
+
+        return chunk
+      end
+
+      def each_byte
+        prune
+
+        @buffer.each_byte do |value|
+          @offset += 1
+          yield value
+        end
+      end
+
+    private
+
+      def prune
+        buffer_size = @buffer.bytesize
+
+        if @offset > buffer_size
+          @buffer = Driver.encode('', :binary)
+        else
+          @buffer = @buffer.byteslice(@offset, buffer_size - @offset)
+        end
+
+        @offset = 0
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: websocket-driver
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: java
 authors:
 - James Coglan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-29 00:00:00.000000000 Z
+date: 2015-07-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-extensions
@@ -102,9 +102,9 @@ files:
 - lib/websocket/driver/hybi.rb
 - lib/websocket/driver/hybi/frame.rb
 - lib/websocket/driver/hybi/message.rb
-- lib/websocket/driver/hybi/stream_reader.rb
 - lib/websocket/driver/proxy.rb
 - lib/websocket/driver/server.rb
+- lib/websocket/driver/stream_reader.rb
 - lib/websocket/driver/utf8_match.rb
 - lib/websocket/http.rb
 - lib/websocket/http/headers.rb

data/lib/websocket/driver/hybi/stream_reader.rb

@@ -1,28 +0,0 @@
-module WebSocket
-  class Driver
-
-    class Hybi
-      class StreamReader
-        def initialize
-          @buffer = Driver.encode('', :binary)
-        end
-
-        def put(string)
-          return unless string and string.bytesize > 0
-          @buffer << Driver.encode(string, :binary)
-        end
-
-        def read(length)
-          buffer_size = @buffer.bytesize
-          return nil if length > buffer_size
-
-          chunk   = @buffer.byteslice(0, length)
-          @buffer = @buffer.byteslice(length, buffer_size - length)
-
-          chunk
-        end
-      end
-    end
-
-  end
-end