websocket-driver 0.6.4 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4cf0e0cdac07ab4b3dd087f8d74b36613f3e9090
-  data.tar.gz: 3282dd2b2f10817324192f29966b14be4611a8b9
+SHA256:
+  metadata.gz: 11392831462e0bee833bdb3ac3f6f09de232e2e8cc7a19799ce0ebb8e7238ea1
+  data.tar.gz: 3b4555cc645e77d0166ff9657dc23c306bf48296e94a1520de703f9ab72120f1
 SHA512:
-  metadata.gz: b99062bf639a33cf257613632b7f5bf9f08d514c4c7d13de6ee022e62fb749632318c534087b5800b23e958b53389b96d9efb78ca324b3a17089ab13e3817736
-  data.tar.gz: 51dff6847b37deb3e0451dfbbfa220ab93fb149215cae124ef4fb94b52974c891c175bbab537ac3d6cc9c6e851e95fe6db805286639bb72051e6b57ca5cd01ad
+  metadata.gz: 378aaf1b46a663dccd4dbc8ec25e515e9acb7b2c760b7b62c199185e11466d9c2fd6482b17fb51157a03030e0c9065c7f6a6201c61a7f45fc940365cce036626
+  data.tar.gz: 783523c78a09ced14fe3e4be497b7fb5e6f22755d6b2dafa5b9b02ed72427512d7b70185dbff43e1df3a924fa086a28334403d7c02b5bc2762fbb33dcf339e3a

data/CHANGELOG.md

@@ -1,119 +1,147 @@
+### 0.7.3 / 2020-07-09
+
+- Let the client accept HTTP responses that have an empty reason phrase
+  following the `101` status code
+
+### 0.7.2 / 2020-05-22
+
+- Emit `ping` and `pong` events from the `Server` driver
+- Handle draft-76 handshakes correctly if the request's body is a frozen string
+
+### 0.7.1 / 2019-06-10
+
+- Catch any exceptions produced while generating a handshake response and send a
+  `400 Bad Request` response to the client
+- Pick the RFC-6455 protocol version if the request contains any of the headers
+  used by that version
+- Handle errors encountered while handling malformed draft-76 requests
+- Change license from MIT to Apache 2.0
+
+### 0.7.0 / 2017-09-11
+
+- Add `ping` and `pong` to the set of events users can listen to
+
+### 0.6.5 / 2017-01-22
+
+- Provide a pure-Ruby fallback for the native unmasking code
+
 ### 0.6.4 / 2016-05-20
 
-* Amend warnings issued when running with -W2
-* Make sure message strings passed in by the app are transcoded to UTF-8
-* Copy strings if necessary for frozen-string compatibility
+- Amend warnings issued when running with -W2
+- Make sure message strings passed in by the app are transcoded to UTF-8
+- Copy strings if necessary for frozen-string compatibility
 
 ### 0.6.3 / 2015-11-06
 
-* Reject draft-76 handshakes if their Sec-WebSocket-Key headers are invalid
-* Throw a more helpful error if a client is created with an invalid URL
+- Reject draft-76 handshakes if their Sec-WebSocket-Key headers are invalid
+- Throw a more helpful error if a client is created with an invalid URL
 
 ### 0.6.2 / 2015-07-18
 
-* When the peer sends a close frame with no error code, emit 1000
+- When the peer sends a close frame with no error code, emit 1000
 
 ### 0.6.1 / 2015-07-13
 
-* Fix how events are stored in `EventEmitter` to fix a backward-compatibility
+- Fix how events are stored in `EventEmitter` to fix a backward-compatibility
   violation introduced in the last release
-* Use the `Array#pack` and `String#unpack` methods for reading/writing numbers
+- Use the `Array#pack` and `String#unpack` methods for reading/writing numbers
   to buffers rather than including duplicate logic for this
 
 ### 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
+- 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
+- Don't emit extra close frames if we receive a close frame after we already
   sent one
-* Fail the connection when the driver receives an invalid
+- Fail the connection when the driver receives an invalid
   `Sec-WebSocket-Extensions` header
 
 ### 0.5.3 / 2015-02-22
 
-* Don't treat incoming data as WebSocket frames if a client driver is closed
+- Don't treat incoming data as WebSocket frames if a client driver is closed
   before receiving the server handshake
 
 ### 0.5.2 / 2015-02-19
 
-* Don't emit multiple `error` events
+- Don't emit multiple `error` events
 
 ### 0.5.1 / 2014-12-18
 
-* Don't allow drivers to be created with unrecognized options
+- Don't allow drivers to be created with unrecognized options
 
 ### 0.5.0 / 2014-12-13
 
-* Support protocol extensions via the websocket-extensions module
+- Support protocol extensions via the websocket-extensions module
 
 ### 0.4.0 / 2014-11-08
 
-* Support connection via HTTP proxies using `CONNECT`
+- Support connection via HTTP proxies using `CONNECT`
 
 ### 0.3.5 / 2014-10-04
 
-* Fix bug where the `Server` driver doesn't pass `ping` callbacks to its
+- Fix bug where the `Server` driver doesn't pass `ping` callbacks to its
   delegate
-* Fix an arity error when calling `fail_request`
-* Allow `close` to be called before `start` to close the driver
+- Fix an arity error when calling `fail_request`
+- Allow `close` to be called before `start` to close the driver
 
 ### 0.3.4 / 2014-07-06
 
-* Don't hold references to frame buffers after a message has been emitted
-* Make sure that `protocol` and `version` are exposed properly by the TCP driver
-* Correct HTTP header parsing based on RFC 7230; header names cannot contain
+- Don't hold references to frame buffers after a message has been emitted
+- Make sure that `protocol` and `version` are exposed properly by the TCP driver
+- Correct HTTP header parsing based on RFC 7230; header names cannot contain
   backslashes
 
 ### 0.3.3 / 2014-04-24
 
-* Fix problems with loading C and Java native extension code
-* Correct the acceptable characters used in the HTTP parser
-* Correct the draft-76 status line reason phrase
+- Fix problems with loading C and Java native extension code
+- Correct the acceptable characters used in the HTTP parser
+- Correct the draft-76 status line reason phrase
 
 ### 0.3.2 / 2013-12-29
 
-* Expand `max_length` to cover sequences of continuation frames and
+- Expand `max_length` to cover sequences of continuation frames and
   `draft-{75,76}`
-* Decrease default maximum frame buffer size to 64MB
-* Stop parsing when the protocol enters a failure mode, to save CPU cycles
+- Decrease default maximum frame buffer size to 64MB
+- Stop parsing when the protocol enters a failure mode, to save CPU cycles
 
 ### 0.3.1 / 2013-12-03
 
-* Add a `max_length` option to limit allowed frame size
+- Add a `max_length` option to limit allowed frame size
 
 ### 0.3.0 / 2013-09-09
 
-* Support client URLs with Basic Auth credentials
+- Support client URLs with Basic Auth credentials
 
 ### 0.2.3 / 2013-08-04
 
-* Fix bug in EventEmitter#emit when listeners are removed
+- Fix bug in EventEmitter#emit when listeners are removed
 
 ### 0.2.2 / 2013-08-04
 
-* Fix bug in EventEmitter#listener_count for unregistered events
+- Fix bug in EventEmitter#listener_count for unregistered events
 
 ### 0.2.1 / 2013-07-05
 
-* Queue sent messages if the client has not begun trying to connect
-* Encode all strings sent to I/O as `ASCII-8BIT`
+- Queue sent messages if the client has not begun trying to connect
+- Encode all strings sent to I/O as `ASCII-8BIT`
 
 ### 0.2.0 / 2013-05-12
 
-* Add API for setting and reading headers
-* Add Driver.server() method for getting a driver for TCP servers
+- Add API for setting and reading headers
+- Add Driver.server() method for getting a driver for TCP servers
 
 ### 0.1.0 / 2013-05-04
 
-* First stable release
+- First stable release
 
 ### 0.0.0 / 2013-04-22
 
-* First release
-* Proof of concept for people to try out
-* Might be unstable
+- First release
+- Proof of concept for people to try out
+- Might be unstable

data/LICENSE.md

@@ -0,0 +1,12 @@
+Copyright 2010-2020 James Coglan
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

data/README.md

@@ -10,21 +10,21 @@ pluggable I/O.
 Due to this design, you get a lot of things for free. In particular, if you hook
 this module up to some I/O object, it will do all of this for you:
 
-* Select the correct server-side driver to talk to the client
-* 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
+- Select the correct server-side driver to talk to the client
+- 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
-* Recombine fragmented messages
-* 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
+- 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
+- Recombine fragmented messages
+- 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
 
 This library was originally extracted from the [Faye](http://faye.jcoglan.com)
 project but now aims to provide simple WebSocket support for any Ruby server or
@@ -43,12 +43,12 @@ $ gem install websocket-driver
 To build either a server-side or client-side socket, the only requirement is
 that you supply a `socket` object with these methods:
 
-* `socket.url` - returns the full URL of the socket as a string.
-* `socket.write(string)` - writes the given string to a TCP stream.
+- `socket.url` - returns the full URL of the socket as a string.
+- `socket.write(string)` - writes the given string to a TCP stream.
 
 Server-side sockets require one additional method:
 
-* `socket.env` - returns a Rack-style env hash that will contain some of the
+- `socket.env` - returns a Rack-style env hash that will contain some of the
   following fields. Their values are strings containing the value of the named
   header, unless stated otherwise.
   * `HTTP_CONNECTION`
@@ -193,8 +193,8 @@ and send outgoing data.
 Client drivers have two additional methods for reading the HTTP data that was
 sent back by the server:
 
-* `driver.status` - the integer value of the HTTP status code
-* `driver.headers` - a hash-like object containing the response headers
+- `driver.status` - the integer value of the HTTP status code
+- `driver.headers` - a hash-like object containing the response headers
 
 
 ### HTTP Proxies
@@ -261,9 +261,9 @@ frames.
 The `options` argument is optional, and is a hash. It may contain the following
 keys:
 
-* `:max_length` - the maximum allowed size of incoming message frames, in bytes.
+- `:max_length` - the maximum allowed size of incoming message frames, in bytes.
   The default value is `2^26 - 1`, or 1 byte short of 64 MiB.
-* `:protocols` - an array of strings representing acceptable subprotocols for
+- `:protocols` - an array of strings representing acceptable subprotocols for
   use over the socket. The driver will negotiate one of these to use via the
   `Sec-WebSocket-Protocol` header if supported by the other peer.
 
@@ -274,27 +274,38 @@ 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) {}`
 
 Adds a callback block to execute when the socket becomes open.
 
-#### `driver.on :message, -> (event) { }`
+#### `driver.on :message, -> (event) {}`
 
 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) {}`
 
 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) {}`
 
 Adds a callback block to execute when the socket becomes closed. The `event`
 object has `code` and `reason` attributes.
 
+#### `driver.on :ping, -> (event) {}`
+
+Adds a callback block to execute when a ping is received. You do not need to
+handle this by sending a pong frame yourself; the driver handles this for you.
+
+#### `driver.on :pong, -> (event) {}`
+
+Adds a callback block to execute when a pong is received. If this was in
+response to a ping you sent, you can also handle this event via the
+`driver.ping(message) { ... }` callback.
+
 #### `driver.add_extension(extension)`
 
 Registers a protocol extension whose operation will be negotiated via the
@@ -367,27 +378,3 @@ Returns the WebSocket version in use as a string. Will either be `hixie-75`,
 Returns a string containing the selected subprotocol, if any was agreed upon
 using the `Sec-WebSocket-Protocol` mechanism. This value becomes available after
 `emit('open')` has fired.
-
-
-## License
-
-(The MIT License)
-
-Copyright (c) 2010-2016 James Coglan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the 'Software'), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ext/websocket-driver/WebsocketMaskService.java

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

data/ext/websocket-driver/websocket_mask.c

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

data/lib/websocket/driver.rb

@@ -19,7 +19,15 @@ module WebSocket
   class Driver
 
     root = File.expand_path('../driver', __FILE__)
-    require 'websocket_mask'
+
+    begin
+      # Load C native extension
+      require 'websocket_mask'
+    rescue LoadError
+      # Fall back to pure-Ruby implementation
+      require 'websocket/mask'
+    end
+
 
     if RUBY_PLATFORM =~ /java/
       require 'jruby'
@@ -42,6 +50,8 @@ module WebSocket
     ConnectEvent = Struct.new(nil)
     OpenEvent    = Struct.new(nil)
     MessageEvent = Struct.new(:data)
+    PingEvent    = Struct.new(:data)
+    PongEvent    = Struct.new(:data)
     CloseEvent   = Struct.new(:code, :reason)
 
     ProtocolError      = Class.new(StandardError)
@@ -91,8 +101,17 @@ module WebSocket
 
     def start
       return false unless @ready_state == 0
-      response = handshake_response
-      return false unless response
+
+      unless Driver.websocket?(@socket.env)
+        return fail_handshake(ProtocolError.new('Not a WebSocket request'))
+      end
+
+      begin
+        response = handshake_response
+      rescue => error
+        return fail_handshake(error)
+      end
+
       @socket.write(response)
       open unless @stage == -1
       true
@@ -124,6 +143,24 @@ module WebSocket
 
   private
 
+    def fail_handshake(error)
+      headers = Headers.new
+      headers['Content-Type'] = 'text/plain'
+      headers['Content-Length'] = error.message.bytesize
+
+      headers = ['HTTP/1.1 400 Bad Request', headers.to_s, error.message]
+      @socket.write(headers.join("\r\n"))
+      fail(:protocol_error, error.message)
+
+      false
+    end
+
+    def fail(type, message)
+      @ready_state = 2
+      emit(:error, ProtocolError.new(message))
+      close
+    end
+
     def open
       @ready_state = 1
       @queue.each { |message| frame(*message) }
@@ -145,10 +182,15 @@ module WebSocket
     end
 
     def self.rack(socket, options = {})
-      env = socket.env
-      if env['HTTP_SEC_WEBSOCKET_VERSION']
+      env     = socket.env
+      version = env['HTTP_SEC_WEBSOCKET_VERSION']
+      key     = env['HTTP_SEC_WEBSOCKET_KEY']
+      key1    = env['HTTP_SEC_WEBSOCKET_KEY1']
+      key2    = env['HTTP_SEC_WEBSOCKET_KEY2']
+
+      if version or key
         Hybi.new(socket, options.merge(:require_masking => true))
-      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
+      elsif key1 or key2
         Draft76.new(socket, options)
       else
         Draft75.new(socket, options)
@@ -173,7 +215,7 @@ module WebSocket
     def self.validate_options(options, valid_keys)
       options.keys.each do |key|
         unless valid_keys.include?(key)
-          raise ConfigurationError, "Unrecognized option: #{key.inspect}"
+          raise ConfigurationError, "Unrecognized option: #{ key.inspect }"
         end
       end
     end

data/lib/websocket/driver/client.rb

@@ -20,10 +20,10 @@ module WebSocket
 
         uri = URI.parse(@socket.url)
         unless VALID_SCHEMES.include?(uri.scheme)
-          raise URIError, "#{socket.url} is not a valid WebSocket URL"
+          raise URIError, "#{ socket.url } is not a valid WebSocket URL"
         end
 
-        host      = uri.host + (uri.port ? ":#{uri.port}" : '')
+        host      = uri.host + (uri.port ? ":#{ uri.port }" : '')
         path      = (uri.path == '') ? '/' : uri.path
         @pathname = path + (uri.query ? '?' + uri.query : '')
 
@@ -31,7 +31,7 @@ module WebSocket
         @headers['Upgrade']               = 'websocket'
         @headers['Connection']            = 'Upgrade'
         @headers['Sec-WebSocket-Key']     = @key
-        @headers['Sec-WebSocket-Version'] = '13'
+        @headers['Sec-WebSocket-Version'] = VERSION
 
         if @protocols.size > 0
           @headers['Sec-WebSocket-Protocol'] = @protocols * ', '
@@ -44,7 +44,7 @@ module WebSocket
       end
 
       def version
-        'hybi-13'
+        "hybi-#{ VERSION }"
       end
 
       def proxy(origin, options = {})
@@ -73,19 +73,19 @@ module WebSocket
         parse(@http.body)
       end
 
-    private 
+    private
 
       def handshake_request
         extensions = @extensions.generate_offer
         @headers['Sec-WebSocket-Extensions'] = extensions if extensions
 
-        start   = "GET #{@pathname} HTTP/1.1"
+        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}"
+        message = "Error during WebSocket handshake: #{ message }"
         @ready_state = 3
         emit(:error, ProtocolError.new(message))
         emit(:close, CloseEvent.new(ERRORS[:protocol_error], message))
@@ -96,7 +96,7 @@ module WebSocket
         @headers = Headers.new(@http.headers)
 
         unless @http.code == 101
-          return fail_handshake("Unexpected response code: #{@http.code}")
+          return fail_handshake("Unexpected response code: #{ @http.code }")
         end
 
         upgrade    = @http['Upgrade'] || ''

data/lib/websocket/driver/draft76.rb

@@ -6,9 +6,10 @@ module WebSocket
 
       def initialize(socket, options = {})
         super
-        input  = @socket.env['rack.input']
+        input  = (@socket.env['rack.input'] || StringIO.new('')).read
+        input  = input.dup if input.frozen?
         @stage = -1
-        @body  = (input ? input.read : String.new('')).force_encoding(BINARY)
+        @body  = input.force_encoding(BINARY)
 
         @headers.clear
         @headers['Upgrade'] = 'WebSocket'
@@ -29,7 +30,7 @@ module WebSocket
 
       def close(reason = nil, code = nil)
         return false if @ready_state == 3
-        @socket.write([0xFF, 0x00].pack('C*'))
+        @socket.write([0xFF, 0x00].pack('C*')) if @ready_state == 1
         @ready_state = 3
         emit(:close, CloseEvent.new(nil, nil))
         true
@@ -39,19 +40,20 @@ module WebSocket
 
       def handshake_response
         env     = @socket.env
-
         key1    = env['HTTP_SEC_WEBSOCKET_KEY1']
+        key2    = env['HTTP_SEC_WEBSOCKET_KEY2']
+
+        raise ProtocolError.new('Missing required header: Sec-WebSocket-Key1') unless key1
+        raise ProtocolError.new('Missing required header: Sec-WebSocket-Key2') unless key2
+
         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
+          raise ProtocolError.new('Client sent invalid Sec-WebSocket-Key headers')
         end
 
         @key_values = [number1 / spaces1, number2 / spaces2]
@@ -84,7 +86,8 @@ module WebSocket
       end
 
       def number_from_key(key)
-        key.scan(/[0-9]/).join('').to_i(10)
+        number = key.scan(/[0-9]/).join('')
+        number == '' ? Float::NAN : number.to_i(10)
       end
 
       def spaces_in_key(key)

data/lib/websocket/driver/headers.rb

@@ -25,7 +25,7 @@ module WebSocket
         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"
+        @lines << "#{ name.strip }: #{ value.to_s.strip }\r\n"
       end
 
       def inspect

data/lib/websocket/driver/hybi.rb

@@ -11,7 +11,8 @@ module WebSocket
         Base64.strict_encode64(Digest::SHA1.digest(key + GUID))
       end
 
-      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+      VERSION = '13'
+      GUID    = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
 
       BYTE       = 0b11111111
       FIN = MASK = 0b10000000
@@ -51,7 +52,7 @@ module WebSocket
       MIN_RESERVED_ERROR = 3000
       MAX_RESERVED_ERROR = 4999
 
-      PACK_FORMATS = {2 => 'n', 8 => 'Q>'}
+      PACK_FORMATS = { 2 => 'n', 8 => 'Q>' }
 
       def initialize(socket, options = {})
         super
@@ -68,22 +69,16 @@ module WebSocket
 
         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
+        else
+          @protocol = nil
         end
       end
 
       def version
-        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
+        "hybi-#{ VERSION }"
       end
 
       def add_extension(extension)
@@ -229,13 +224,24 @@ module WebSocket
       end
 
       def handshake_response
-        begin
-          extensions = @extensions.generate_response(@socket.env['HTTP_SEC_WEBSOCKET_EXTENSIONS'])
-        rescue => error
-          fail(:protocol_error, error.message)
-          return nil
+        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
+        version = @socket.env['HTTP_SEC_WEBSOCKET_VERSION']
+
+        unless version == VERSION
+          raise ProtocolError.new("Unsupported WebSocket version: #{ VERSION }")
+        end
+
+        unless sec_key
+          raise ProtocolError.new('Missing handshake request header: Sec-WebSocket-Key')
         end
 
+        @headers['Upgrade']              = 'websocket'
+        @headers['Connection']           = 'Upgrade'
+        @headers['Sec-WebSocket-Accept'] = Hybi.generate_accept(sec_key)
+
+        @headers['Sec-WebSocket-Protocol'] = @protocol if @protocol
+
+        extensions = @extensions.generate_response(@socket.env['HTTP_SEC_WEBSOCKET_EXTENSIONS'])
         @headers['Sec-WebSocket-Extensions'] = extensions if extensions
 
         start   = 'HTTP/1.1 101 Switching Protocols'
@@ -275,17 +281,17 @@ module WebSocket
 
         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 }")
+              "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}")
+          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}")
+          return fail(:protocol_error, "Received fragmented control frame: opcode = #{ @frame.opcode }")
         end
 
         if @message and OPENING_OPCODES.include?(@frame.opcode)
@@ -315,7 +321,7 @@ module WebSocket
         @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}")
+          return fail(:protocol_error, "Received control frame having too long payload: #{ @frame.length }")
         end
 
         return unless check_frame_length
@@ -368,12 +374,14 @@ module WebSocket
 
           when OPCODES[:ping] then
             frame(payload, :pong)
+            emit(:ping, PingEvent.new(payload))
 
           when OPCODES[:pong] then
             message = Driver.encode(payload, UNICODE)
             callback = @ping_callbacks[message]
             @ping_callbacks.delete(message)
             callback.call if callback
+            emit(:pong, PongEvent.new(payload))
         end
 
         emit_message if frame.final and MESSAGE_OPCODES.include?(opcode)

data/lib/websocket/driver/proxy.rb

@@ -4,7 +4,7 @@ module WebSocket
     class Proxy
       include EventEmitter
 
-      PORTS = {'ws' => 80, 'wss' => 443}
+      PORTS = { 'ws' => 80, 'wss' => 443 }
 
       attr_reader :status, :headers
 
@@ -20,7 +20,7 @@ module WebSocket
         @state   = 0
 
         @headers = Headers.new
-        @headers['Host'] = @origin.host + (@origin.port ? ":#{@origin.port}" : '')
+        @headers['Host'] = @origin.host + (@origin.port ? ":#{ @origin.port }" : '')
         @headers['Connection'] = 'keep-alive'
         @headers['Proxy-Connection'] = 'keep-alive'
 
@@ -41,7 +41,7 @@ module WebSocket
         @state = 1
 
         port    = @origin.port || PORTS[@origin.scheme]
-        start   = "CONNECT #{@origin.host}:#{port} HTTP/1.1"
+        start   = "CONNECT #{ @origin.host }:#{ port } HTTP/1.1"
         headers = [start, @headers.to_s, '']
 
         @socket.write(headers.join("\r\n"))
@@ -58,7 +58,7 @@ module WebSocket
         if @status == 200
           emit(:connect, ConnectEvent.new)
         else
-          message = "Can't establish a connection to the server at #{@socket.url}"
+          message = "Can't establish a connection to the server at #{ @socket.url }"
           emit(:error, ProtocolError.new(message))
         end
       end

data/lib/websocket/driver/server.rb

@@ -2,7 +2,7 @@ module WebSocket
   class Driver
 
     class Server < Driver
-      EVENTS = %w[open message error close]
+      EVENTS = %w[open message error close ping pong]
 
       def initialize(socket, options = {})
         super
@@ -17,9 +17,9 @@ module WebSocket
       def url
         return nil unless e = env
 
-        url  = "ws://#{e['HTTP_HOST']}"
+        url  = "ws://#{ e['HTTP_HOST'] }"
         url << e['PATH_INFO']
-        url << "?#{e['QUERY_STRING']}" unless e['QUERY_STRING'] == ''
+        url << "?#{ e['QUERY_STRING'] }" unless e['QUERY_STRING'] == ''
         url
       end
 

data/lib/websocket/http/request.rb

@@ -30,11 +30,11 @@ module WebSocket
         super
         @headers.each do |name, value|
           rack_name = name.upcase.gsub(/-/, '_')
-          rack_name = "HTTP_#{rack_name}" unless RESERVED_HEADERS.include?(name)
+          rack_name = "HTTP_#{ rack_name }" unless RESERVED_HEADERS.include?(name)
           @env[rack_name] = value
         end
         if host = @env['HTTP_HOST']
-          uri = URI.parse("http://#{host}")
+          uri = URI.parse("http://#{ host }")
           @env['SERVER_NAME'] = uri.host
           @env['SERVER_PORT'] = uri.port.to_s
         end

data/lib/websocket/http/response.rb

@@ -4,7 +4,7 @@ module WebSocket
     class Response
       include Headers
 
-      STATUS_LINE = /^(HTTP\/[0-9]+\.[0-9]+) ([0-9]{3}) ([\x20-\x7e]+)$/
+      STATUS_LINE = /^(HTTP\/[0-9]+\.[0-9]+) ([0-9]{3}) ([\x20-\x7e]*)$/
 
       attr_reader :code
 

data/lib/websocket/mask.rb

@@ -0,0 +1,14 @@
+module WebSocket
+  module Mask
+    def self.mask(payload, mask)
+      return payload if mask.nil? || payload.empty?
+
+      payload.tap do |result|
+        payload.bytesize.times do |i|
+          result.setbyte(i, payload.getbyte(i) ^ mask.getbyte(i % 4))
+        end
+      end
+    end
+
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: websocket-driver
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.3
 platform: ruby
 authors:
 - James Coglan
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-20 00:00:00.000000000 Z
+date: 2020-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-extensions
@@ -56,16 +56,16 @@ dependencies:
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -80,7 +80,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: jcoglan@gmail.com
 executables: []
 extensions:
@@ -89,8 +89,8 @@ extra_rdoc_files:
 - README.md
 files:
 - CHANGELOG.md
+- LICENSE.md
 - README.md
-- examples/tcp_server.rb
 - ext/websocket-driver/WebsocketMaskService.java
 - ext/websocket-driver/extconf.rb
 - ext/websocket-driver/websocket_mask.c
@@ -110,12 +110,13 @@ files:
 - lib/websocket/http/headers.rb
 - lib/websocket/http/request.rb
 - lib/websocket/http/response.rb
+- lib/websocket/mask.rb
 - lib/websocket/websocket_mask.rb
-homepage: http://github.com/faye/websocket-driver-ruby
+homepage: https://github.com/faye/websocket-driver-ruby
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -134,9 +135,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: WebSocket protocol handler with pluggable I/O
 test_files: []

data/examples/tcp_server.rb

@@ -1,28 +0,0 @@
-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) }
-    @driver.on(:close)   { |e| close_connection_after_writing }
-  end
-
-  def receive_data(data)
-    @driver.parse(data)
-  end
-
-  def write(data)
-    send_data(data)
-  end
-end
-
-EM.run {
-  EM.start_server('127.0.0.1', ARGV[0], Connection)
-}