em-websocket 0.4.0 → 0.5.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1cd5fdedbceef9a4d9c5e9a4eef17dd18ab5f6aee6d2d67c65ccc35e2cdadc2a
+  data.tar.gz: 820c1ade3a0a9ac81e6828d8187553dc2c27a6b709d25853dc0e19a277eb4141
+SHA512:
+  metadata.gz: ed42c46f3d9166206516e6180a76eaf6e47b86e8b30d9037aae5237214cbfe19307dd7e07e61e689412eba3ed8604e71d7a5e067132ec51200817459c4db3b36
+  data.tar.gz: 6f89807d825e4fef41d910f7e3d3e5c609f73b0abfaea5267e84e735c441dd8227a4c9585ff42ef7a63598d05b2bd652541081f611426e79332d7270f8b51b9a

data/CHANGELOG.rdoc

@@ -1,6 +1,40 @@
 = Changelog
 
-== 0.4.0 / ?
+== 0.5.1 / 2014-04-23
+
+- new features:
+  - Support for receiving binary messages
+
+- changed:
+  - Allow additional close codes to be sent by apps
+  - Raise better errors on missing Sec-WebSocket-Key2
+  - Updated http_parser.rb dependency to 0.6.0
+
+- bug fixes:
+  - Abort if HTTP request URI is invalid
+  - Force close connections that have been sent a close handshake after a timeout
+
+- improved spec compliance on:
+  - Missing continuation frames
+  - Fragmented control frames
+  - Close behaviour after protocol errors
+
+== 0.5.0 / 2013-03-05
+
+- new features:
+  - onclose handler is now passed a hash containing  was_clean (set to true in drafts 03 and above when a connection is closed with a closing handshake, either by the server or the client), the close code, and reason (drafts 06 and above). Close code 1005 indicates that no code was supplied, and 1006 that the connection was closed abnormally.
+  - use Connection#support_close_codes? to easily check whether close codes are supported by the WebSocket protocol (drafts 06 and above)
+  - closes connection with 1007 close code if text frame contains invalid UTF8
+  - added Handshake#secure? for checking whether the connection is secure (either ssl or behind an ssl proxy)
+
+- changed:
+  - Defaults to sending no close code rather than 1000 (consistent with browsers)
+  - Allows sending a 3xxx close code
+  - Renamed Connection#close_websocket to Connection#close (again for consistency with browsers). Old method is available till 0.6.
+  - Sends reasons with internally generated closure (previously only sent code)
+  - Echos close code when replying to close handshake
+
+== 0.4.0 / 2013-01-22
 
 - new features:
   - on_open handler is now passed a handshake object which exposes the request headers, path, and query parameters

data/Gemfile

@@ -1,3 +1,9 @@
 source "http://rubygems.org"
 
 gemspec
+
+gem "em-websocket-client", git: "git@github.com:movitto/em-websocket-client.git", branch: "expose-websocket-api"
+gem "em-spec", "~> 0.2.6"
+gem "em-http-request", "~> 1.1.1"
+gem "rspec", "~> 3.5.0"
+gem "rake"

data/LICENCE

@@ -0,0 +1,7 @@
+Copyright (c) 2009-2014 Ilya Grigorik, Martyn Loughran
+
+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/README.md

@@ -1,8 +1,9 @@
 # EM-WebSocket
 
-EventMachine based, async, Ruby WebSocket server. Take a look at examples directory, or check out the blog post below:
+[![Gem Version](https://badge.fury.io/rb/em-websocket.png)](http://rubygems.org/gems/em-websocket)
+[![Analytics](https://ga-beacon.appspot.com/UA-71196-10/em-websocket/readme)](https://github.com/igrigorik/ga-beacon)
 
-* [Ruby & Websockets: TCP for the Web](http://www.igvita.com/2009/12/22/ruby-websockets-tcp-for-the-browser/)
+EventMachine based, async, Ruby WebSocket server. Take a look at examples directory, or check out the blog post: [Ruby & Websockets: TCP for the Web](http://www.igvita.com/2009/12/22/ruby-websockets-tcp-for-the-browser/).
 
 ## Simple server example
 
@@ -31,9 +32,52 @@ EM.run {
 }
 ```
 
+## Protocols supported, and protocol specific functionality
+
+Supports all WebSocket protocols in use in the wild (and a few that are not): drafts 75, 76, 1-17, rfc.
+
+While some of the changes between protocols are unimportant from the point of view of application developers, a few drafts did introduce new functionality. It's possible to easily test for this functionality by using
+
+### Ping & pong supported
+
+Call `ws.pingable?` to check whether ping & pong is supported by the protocol in use.
+
+It's possible to send a ping frame (`ws.ping(body = '')`), which the client must respond to with a pong, or the server can send an unsolicited pong frame (`ws.pong(body = '')`) which the client should not respond to. These methods can be used regardless of protocol version; they return true if the protocol supports ping&pong or false otherwise.
+
+When receiving a ping, the server will automatically respond with a pong as the spec requires (so you should _not_ write an onping handler that replies with a pong), however it is possible to bind to ping & pong events if desired by using the `onping` and `onpong` methods.
+
+### Healthchecks
+
+It's possible to send a regular `HTTP GET` request to the `/healthcheck` endpoint and receive a `200` response from the server.
+
+### Close codes and reasons
+
+A WebSocket connection can be closed cleanly, regardless of protocol, by calling `ws.close(code = nil, body = nil)`.
+
+Early protocols just close the TCP connection, draft 3 introduced a close handshake, and draft 6 added close codes and reasons to the close handshake. Call `ws.supports_close_codes?` to check whether close codes are supported (i.e. the protocol version is 6 or above).
+
+The `onclose` callback is passed a hash which may contain following keys (depending on the protocol version):
+
+* `was_clean`: boolean indicating whether the connection was closed via the close handshake.
+* `code`: the close code. There are two special close codes which the server may set (as defined in the WebSocket spec):
+  * 1005: no code was supplied
+  * 1006: abnormal closure (the same as `was_clean: false`)
+* `reason`: the close reason
+
+Acceptable close codes are defined in the WebSocket rfc (<http://tools.ietf.org/html/rfc6455#section-7.4>). The following codes can be supplies when calling `ws.close(code)`:
+
+* 1000: a generic normal close
+* range 3xxx: reserved for libraries, frameworks, and applications (and can be registered with IANA)
+* range 4xxx: for private use
+
+If unsure use a code in the 4xxx range. em-websocket may also close a connection with one of the following close codes:
+
+* 1002: WebSocket protocol error.
+* 1009: Message too big to process. By default em-websocket will accept frames up to 10MB in size. If a frame is larger than this the connection will be closed without reading the frame data. The limit can be overriden globally (`EM::WebSocket.max_frame_size = bytes`) or on a specific connection (`ws.max_frame_size = bytes`).
+
 ## Secure server
 
-It is possible to accept secure `wss://` connections by passing `:secure => true` when opening the connection. Pass a `:tls_options` hash containing keys as described in http://eventmachine.rubyforge.org/EventMachine/Connection.html#start_tls-instance_method
+It is possible to accept secure `wss://` connections by passing `:secure => true` when opening the connection. Pass a `:tls_options` hash containing keys as described in http://www.rubydoc.info/github/eventmachine/eventmachine/EventMachine/Connection:start_tls
 
 **Warning**: Safari 5 does not currently support prompting on untrusted SSL certificates therefore using a self signed certificate may leave you scratching your head.
 
@@ -51,6 +95,8 @@ EM::WebSocket.start({
 end
 ```
 
+It's possible to check whether an incoming connection is secure by reading `handshake.secure?` in the onopen callback.
+
 ## Running behind an SSL Proxy/Terminator, like Stunnel
 
 The `:secure_proxy => true` option makes it possible to use em-websocket behind a secure SSL proxy/terminator like [Stunnel](http://www.stunnel.org/) which does the actual encryption & decryption.
@@ -98,7 +144,3 @@ Using flash emulation does require some minimal support from em-websocket which
 * [Twitter AMQP WebSocket Example](http://github.com/rubenfonseca/twitter-amqp-websocket-example)
 * examples/multicast.rb - broadcast all ruby tweets to all subscribers
 * examples/echo.rb - server <> client exchange via a websocket
-
-# License
-
-The MIT License - Copyright (c) 2009 Ilya Grigorik

data/em-websocket.gemspec

@@ -11,8 +11,7 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/igrigorik/em-websocket"
   s.summary     = %q{EventMachine based WebSocket server}
   s.description = %q{EventMachine based WebSocket server}
-
-  s.rubyforge_project = "em-websocket"
+  s.license     = 'MIT'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
@@ -20,10 +19,5 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency("eventmachine", ">= 0.12.9")
-  s.add_dependency("http_parser.rb", '~> 0.5.3')
-  s.add_development_dependency('em-spec', '~> 0.2.6')
-  s.add_development_dependency("eventmachine")
-  s.add_development_dependency('em-http-request', '~> 0.2.6')
-  s.add_development_dependency('rspec', "~> 2.12.0")
-  s.add_development_dependency('rake')
+  s.add_dependency("http_parser.rb", '~> 0')
 end

data/examples/test.html

@@ -12,7 +12,9 @@
         var Socket = "MozWebSocket" in window ? MozWebSocket : WebSocket;
         var ws = new Socket("ws://localhost:8080/foo/bar?hello=world");
         ws.onmessage = function(evt) { debug("Received: " + evt.data); };
-        ws.onclose = function() { debug("socket closed"); };
+        ws.onclose = function(event) {
+          debug("Closed - code: " + event.code + ", reason: " + event.reason + ", wasClean: " + event.wasClean);
+        };
         ws.onopen = function() {
           debug("connected...");
           ws.send("hello server");

data/lib/em-websocket/close03.rb

@@ -5,7 +5,10 @@ module EventMachine
         # TODO: Ideally send body data and check that it matches in ack
         send_frame(:close, '')
         @state = :closing
+        start_close_timeout
       end
+
+      def supports_close_codes?; false; end
     end
   end
 end

data/lib/em-websocket/close05.rb

@@ -5,7 +5,10 @@ module EventMachine
         # TODO: Ideally send body data and check that it matches in ack
         send_frame(:close, "\x53")
         @state = :closing
+        start_close_timeout
       end
+
+      def supports_close_codes?; false; end
     end
   end
 end

data/lib/em-websocket/close06.rb

@@ -10,7 +10,10 @@ module EventMachine
           send_frame(:close, '')
         end
         @state = :closing
+        start_close_timeout
       end
+
+      def supports_close_codes?; true; end
     end
   end
 end

data/lib/em-websocket/close75.rb

@@ -2,9 +2,10 @@ module EventMachine
   module WebSocket
     module Close75
       def close_websocket(code, body)
-        @state = :closed
         @connection.close_connection_after_writing
       end
+
+      def supports_close_codes?; false; end
     end
   end
 end

data/lib/em-websocket/connection.rb

@@ -10,26 +10,30 @@ module EventMachine
       def onclose(&blk);    @onclose = blk;   end
       def onerror(&blk);    @onerror = blk;   end
       def onmessage(&blk);  @onmessage = blk; end
+      def onbinary(&blk);   @onbinary = blk; end
       def onping(&blk);     @onping = blk;    end
       def onpong(&blk);     @onpong = blk;    end
 
       def trigger_on_message(msg)
-        @onmessage.call(msg) if @onmessage
+        @onmessage.call(msg) if defined? @onmessage
+      end
+      def trigger_on_binary(msg)
+        @onbinary.call(msg) if defined? @onbinary
       end
       def trigger_on_open(handshake)
-        @onopen.call(handshake) if @onopen
+        @onopen.call(handshake) if defined? @onopen
       end
-      def trigger_on_close
-        @onclose.call if @onclose
+      def trigger_on_close(event = {})
+        @onclose.call(event) if defined? @onclose
       end
       def trigger_on_ping(data)
-        @onping.call(data) if @onping
+        @onping.call(data) if defined? @onping
       end
       def trigger_on_pong(data)
-        @onpong.call(data) if @onpong
+        @onpong.call(data) if defined? @onpong
       end
       def trigger_on_error(reason)
-        return false unless @onerror
+        return false unless defined? @onerror
         @onerror.call(reason)
         true
       end
@@ -40,6 +44,10 @@ module EventMachine
         @secure = options[:secure] || false
         @secure_proxy = options[:secure_proxy] || false
         @tls_options = options[:tls_options] || {}
+        @close_timeout = options[:close_timeout]
+        @outbound_limit = options[:outbound_limit] || 0
+
+        @handler = nil
 
         debug [:initialize]
       end
@@ -47,17 +55,17 @@ module EventMachine
       # Use this method to close the websocket connection cleanly
       # This sends a close frame and waits for acknowlegement before closing
       # the connection
-      def close_websocket(code = nil, body = nil)
-        if code && !(4000..4999).include?(code)
-          raise "Application code may only use codes in the range 4000-4999"
+      def close(code = nil, body = nil)
+        if code && !acceptable_close_code?(code)
+          raise "Application code may only use codes from 1000, 3000-4999"
         end
 
-        # If code not defined then set to 1000 (normal closure)
-        code ||= 1000
-
         close_websocket_private(code, body)
       end
 
+      # Deprecated, to be removed in version 0.6
+      alias :close_websocket :close
+
       def post_init
         start_tls(@tls_options) if @secure
       end
@@ -70,17 +78,25 @@ module EventMachine
         else
           dispatch(data)
         end
-      rescue WSProtocolError => e
-        debug [:error, e]
-        trigger_on_error(e)
-        close_websocket_private(e.code)
       rescue => e
         debug [:error, e]
-        # These are application errors - raise unless onerror defined
-        trigger_on_error(e) || raise(e)
+
         # There is no code defined for application errors, so use 3000
         # (which is reserved for frameworks)
-        close_websocket_private(3000)
+        close_websocket_private(3000, "Application error")
+
+        # These are application errors - raise unless onerror defined
+        trigger_on_error(e) || raise(e)
+      end
+
+      def send_data(data)
+        if @outbound_limit > 0 &&
+            get_outbound_data_size + data.bytesize > @outbound_limit
+          abort(:outbound_limit_reached)
+          return 0
+        end
+
+        super(data)
       end
 
       def unbind
@@ -94,7 +110,9 @@ module EventMachine
       end
 
       def dispatch(data)
-        if data.match(/\A<policy-file-request\s*\/>/)
+        if data.match(%r|^GET /healthcheck|)
+          send_healthcheck_response
+        elsif data.match(/\A<policy-file-request\s*\/>/)
           send_flash_cross_domain_file
         else
           @handshake ||= begin
@@ -113,7 +131,7 @@ module EventMachine
               debug [:error, e]
               trigger_on_error(e)
               # Handshake errors require the connection to be aborted
-              abort
+              abort(:handshake_error)
             }
 
             handshake
@@ -123,6 +141,23 @@ module EventMachine
         end
       end
 
+      def send_healthcheck_response
+        debug [:healthcheck, 'OK']
+
+        healthcheck_res = ["HTTP/1.1 200 OK"]
+        healthcheck_res << "Content-Type: text/plain"
+        healthcheck_res << "Content-Length: 2"
+
+        healthcheck_res = healthcheck_res.join("\r\n") + "\r\n\r\nOK"
+
+        send_data healthcheck_res
+
+        # handle the healthcheck request transparently
+        # no need to notify the user about this connection
+        @onclose = nil
+        close_connection_after_writing
+      end
+
       def send_flash_cross_domain_file
         file =  '<?xml version="1.0"?><cross-domain-policy><allow-access-from domain="*" to-ports="*"/></cross-domain-policy>'
         debug [:cross_domain, file]
@@ -219,10 +254,23 @@ module EventMachine
         end
       end
 
+      def supports_close_codes?
+        if @handler
+          @handler.supports_close_codes?
+        else
+          raise WebSocketError, "Cannot test before onopen callback"
+        end
+      end
+
       def state
         @handler ? @handler.state : :handshake
       end
 
+      # Returns the IP address for the remote peer
+      def remote_ip
+        get_peername[2,6].unpack('nC4')[1..4].join('.')
+      end
+
       # Returns the maximum frame size which this connection is configured to
       # accept. This can be set globally or on a per connection basis, and
       # defaults to a value of 10MB if not set.
@@ -232,24 +280,68 @@ module EventMachine
       # correct close code (1009) immediately after receiving the frame header
       #
       def max_frame_size
-        @max_frame_size || WebSocket.max_frame_size
+        defined?(@max_frame_size) ? @max_frame_size : WebSocket.max_frame_size
+      end
+
+      def close_timeout
+        @close_timeout || WebSocket.close_timeout
       end
 
       private
 
       # As definited in draft 06 7.2.2, some failures require that the server
       # abort the websocket connection rather than close cleanly
-      def abort
+      def abort(reason)
+        debug [:abort, reason]
         close_connection
       end
 
-      def close_websocket_private(code, body = nil)
+      def close_websocket_private(code, body)
         if @handler
           debug [:closing, code]
           @handler.close_websocket(code, body)
         else
           # The handshake hasn't completed - should be safe to terminate
-          abort
+          abort(:handshake_incomplete)
+        end
+      end
+
+      # Allow applications to close with 1000, 1003, 1008, 1011, 3xxx or 4xxx.
+      #
+      # em-websocket uses a few other codes internally which should not be
+      # used by applications
+      #
+      # Browsers generally allow connections to be closed with code 1000,
+      # 3xxx, and 4xxx. em-websocket allows closing with a few other codes
+      # which seem reasonable (for discussion see
+      # https://github.com/igrigorik/em-websocket/issues/98)
+      #
+      # Usage from the rfc:
+      #
+      # 1000 indicates a normal closure
+      #
+      # 1003 indicates that an endpoint is terminating the connection
+      # because it has received a type of data it cannot accept
+      #
+      # 1008 indicates that an endpoint is terminating the connection because
+      # it has received a message that violates its policy
+      #
+      # 1011 indicates that a server is terminating the connection because it
+      # encountered an unexpected condition that prevented it from fulfilling
+      # the request
+      #
+      # Status codes in the range 3000-3999 are reserved for use by libraries,
+      # frameworks, and applications
+      #
+      # Status codes in the range 4000-4999 are reserved for private use and
+      # thus can't be registered
+      #
+      def acceptable_close_code?(code)
+        case code
+        when 1000, 1003, 1008, 1011, (3000..4999)
+          true
+        else
+          false
         end
       end
     end

data/lib/em-websocket/framing03.rb

@@ -6,9 +6,10 @@ module EventMachine
       def initialize_framing
         @data = ''
         @application_data_buffer = '' # Used for MORE frames
+        @frame_type = nil
       end
       
-      def process_data(newdata)
+      def process_data
         error = false
 
         while !error && @data.size > 1
@@ -150,7 +151,7 @@ module EventMachine
       end
 
       def opcode_to_type(opcode)
-        FRAME_TYPES_INVERSE[opcode] || raise(WSProtocolError, "Unknown opcode")
+        FRAME_TYPES_INVERSE[opcode] || raise(WSProtocolError, "Unknown opcode #{opcode}")
       end
 
       def data_frame?(type)

data/lib/em-websocket/framing05.rb

@@ -6,9 +6,10 @@ module EventMachine
       def initialize_framing
         @data = MaskedString.new
         @application_data_buffer = '' # Used for MORE frames
+        @frame_type = nil
       end
       
-      def process_data(newdata)
+      def process_data
         error = false
 
         while !error && @data.size > 5 # mask plus first byte present
@@ -151,7 +152,7 @@ module EventMachine
       end
 
       def opcode_to_type(opcode)
-        FRAME_TYPES_INVERSE[opcode] || raise(WSProtocolError, "Unknown opcode")
+        FRAME_TYPES_INVERSE[opcode] || raise(WSProtocolError, "Unknown opcode #{opcode}")
       end
 
       def data_frame?(type)

data/lib/em-websocket/framing07.rb

@@ -7,9 +7,10 @@ module EventMachine
       def initialize_framing
         @data = MaskedString.new
         @application_data_buffer = '' # Used for MORE frames
+        @frame_type = nil
       end
       
-      def process_data(newdata)
+      def process_data
         error = false
 
         while !error && @data.size >= 2
@@ -86,8 +87,19 @@ module EventMachine
 
           frame_type = opcode_to_type(opcode)
 
-          if frame_type == :continuation && !@frame_type
-            raise WSProtocolError, 'Continuation frame not expected'
+          if frame_type == :continuation
+            if !@frame_type
+              raise WSProtocolError, 'Continuation frame not expected'
+            end
+          else # Not a continuation frame
+            if @frame_type && data_frame?(frame_type)
+              raise WSProtocolError, "Continuation frame expected"
+            end
+          end
+
+          # Validate that control frames are not fragmented
+          if !fin && !data_frame?(frame_type)
+            raise WSProtocolError, 'Control frames must not be fragmented'
           end
 
           if !fin
@@ -162,7 +174,7 @@ module EventMachine
       end
 
       def opcode_to_type(opcode)
-        FRAME_TYPES_INVERSE[opcode] || raise(WSProtocolError, "Unknown opcode")
+        FRAME_TYPES_INVERSE[opcode] || raise(WSProtocolError, "Unknown opcode #{opcode}")
       end
 
       def data_frame?(type)

data/lib/em-websocket/framing76.rb

@@ -7,7 +7,7 @@ module EventMachine
         @data = ''
       end
       
-      def process_data(newdata)
+      def process_data
         debug [:message, @data]
 
         # This algorithm comes straight from the spec
@@ -71,9 +71,6 @@ module EventMachine
               raise WSMessageTooBigError, "Frame length too long (#{@data.size} bytes)"
             end
 
-            # Optimization to avoid calling slice! unnecessarily
-            error = true and next unless newdata =~ /\xff/
-
             msg = @data.slice!(/\A\x00[^\xff]*\xff/)
             if msg
               msg.gsub!(/\A\x00|\xff\z/, '')

data/lib/em-websocket/handler.rb

@@ -2,7 +2,7 @@ module EventMachine
   module WebSocket
     class Handler
       def self.klass_factory(version)
-        handler_klass = case version
+        case version
         when 75
           Handler75
         when 76
@@ -38,21 +38,49 @@ module EventMachine
         @connection = connection
         @debug = debug
         @state = :connected
+        @close_timer = nil
         initialize_framing
       end
 
       def receive_data(data)
         @data << data
-        process_data(data)
+        process_data
+      rescue WSProtocolError => e
+        fail_websocket(e)
       end
 
       def close_websocket(code, body)
         # Implemented in subclass
       end
 
+      # Used to avoid un-acked and unclosed remaining open indefinitely
+      def start_close_timeout
+        @close_timer = EM::Timer.new(@connection.close_timeout) {
+          @connection.close_connection
+          e = WSProtocolError.new("Close handshake un-acked after #{@connection.close_timeout}s, closing tcp connection")
+          @connection.trigger_on_error(e)
+        }
+      end
+
+      # This corresponds to "Fail the WebSocket Connection" in the spec.
+      def fail_websocket(e)
+        debug [:error, e]
+        close_websocket(e.code, e.message)
+        @connection.close_connection_after_writing
+        @connection.trigger_on_error(e)
+      end
+
       def unbind
         @state = :closed
-        @connection.trigger_on_close
+
+        @close_timer.cancel if @close_timer
+
+        @close_info = defined?(@close_info) ? @close_info : {
+          :code => 1006,
+          :was_clean => false,
+        }
+
+        @connection.trigger_on_close(@close_info)
       end
 
       def ping

data/lib/em-websocket/handler76.rb

@@ -1,3 +1,5 @@
+# encoding: BINARY
+
 module EventMachine
   module WebSocket
     class Handler76 < Handler