em-websocket 0.3.7 → 0.5.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b5ae1d6db2d88e23c98fce247af5c18d9af7343d196cc85224d2d62e6f39cf6b
+  data.tar.gz: eff929c27eb3949705cf0e5438af33c7b05612c5e5deedaf2ea39a81f0308559
+SHA512:
+  metadata.gz: 301e06c551ea5414cd463a606fc709676932094bdf92743555cf5ecccb20fb0c0d7abe14c19a61942337ea8c60053bd59d7b31841178df9f05dbae3c6e66232f
+  data.tar.gz: 5020a0dd90126780266b55c197acadcbabc40044e5513b4461f4f4d9500d9ace38646c931aeb19fd638b852a68346b5cb44c48b9cc5e5b5f2e96e3a80ff2cbf4

data/CHANGELOG.rdoc

@@ -1,5 +1,57 @@
 = Changelog
 
+== 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
+  - Easily access the protocol version via Handshake#protocol_version
+  - Easily access the origin via Handshake#origin
+
+- changed:
+  - Removed Connection#request - change to using handshake passed to on_open
+
+- internals:
+  - Uses the http_parser.rb gem
+
+== 0.3.8 / 2012-07-12
+
+- bug fixes:
+  - Fixed support for Ruby 1.8.7 which was broken in 0.3.7
+
 == 0.3.7 / 2012-07-11
 
 - new features:

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,77 +1,142 @@
 # 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
 
 ```ruby
-EventMachine.run {
-
-    EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080) do |ws|
-        ws.onopen {
-          puts "WebSocket connection open"
-
-          # publish message to the client
-          ws.send "Hello Client"
-        }
-
-        ws.onclose { puts "Connection closed" }
-        ws.onmessage { |msg|
-          puts "Recieved message: #{msg}"
-          ws.send "Pong: #{msg}"
-        }
-    end
+require 'em-websocket'
+
+EM.run {
+  EM::WebSocket.run(:host => "0.0.0.0", :port => 8080) do |ws|
+    ws.onopen { |handshake|
+      puts "WebSocket connection open"
+
+      # Access properties on the EM::WebSocket::Handshake object, e.g.
+      # path, query_string, origin, headers
+
+      # Publish message to the client
+      ws.send "Hello Client, you connected to #{handshake.path}"
+    }
+
+    ws.onclose { puts "Connection closed" }
+
+    ws.onmessage { |msg|
+      puts "Recieved message: #{msg}"
+      ws.send "Pong: #{msg}"
+    }
+  end
 }
 ```
 
+## 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.
+
+### 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. Safari 5 does not currently support prompting on untrusted SSL certificates therefore using signed certificates is highly recommended. Pass a :tls_options hash containing keys as described in http://eventmachine.rubyforge.org/EventMachine/Connection.html#M000296
+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
 
-For example,
+**Warning**: Safari 5 does not currently support prompting on untrusted SSL certificates therefore using a self signed certificate may leave you scratching your head.
 
 ```ruby
-EventMachine::WebSocket.start({
-    :host => "0.0.0.0",
-    :port => 443
-    :secure => true,
-    :tls_options => {
-      :private_key_file => "/private/key",
-      :cert_chain_file => "/ssl/certificate"
-    }
+EM::WebSocket.start({
+  :host => "0.0.0.0",
+  :port => 443,
+  :secure => true,
+  :tls_options => {
+    :private_key_file => "/private/key",
+    :cert_chain_file => "/ssl/certificate"
+  }
 }) do |ws|
-...
+  # ...
+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.
+
+Note that this option is only required to support drafts 75 & 76 correctly (e.g. Safari 5.1.x & earlier, and Safari on iOS 5.x & earlier).
+
+```ruby
+EM::WebSocket.start({
+  :host => "0.0.0.0",
+  :port => 8080,
+  :secure_proxy => true
+}) do |ws|
+  # ...
 end
 ```
 
 ## Handling errors
 
-There are two kinds of errors that need to be handled - errors caused by incompatible WebSocket clients sending invalid data and errors in application code. They are handled as follows:
+There are two kinds of errors that need to be handled -- WebSocket protocol errors and errors in application code.
 
-Errors caused by invalid WebSocket data (for example invalid errors in the WebSocket handshake or invalid message frames) raise errors which descend from `EventMachine::WebSocket::WebSocketError`. Such errors are rescued internally and the WebSocket connection will be closed immediately or an error code sent to the browser in accordance to the WebSocket specification. However it is possible to be notified in application code on such errors by including an `onerror` callback.
+WebSocket protocol errors (for example invalid data in the handshake or invalid message frames) raise errors which descend from `EM::WebSocket::WebSocketError`. Such errors are rescued internally and the WebSocket connection will be closed immediately or an error code sent to the browser in accordance to the WebSocket specification. It is possible to be notified in application code of such errors by including an `onerror` callback.
 
 ```ruby
 ws.onerror { |error|
-  if e.kind_of?(EM::WebSocket::WebSocketError)
-    ...
+  if error.kind_of?(EM::WebSocket::WebSocketError)
+    # ...
   end
 }
 ```
 
-Application errors are treated differently. If no `onerror` callback has been defined these errors will propagate to the EventMachine reactor, typically causing your program to terminate. If you wish to handle exceptions, simply supply an `onerror callback` and check for exceptions which are not decendant from `EventMachine::WebSocket::WebSocketError`.
+Application errors are treated differently. If no `onerror` callback has been defined these errors will propagate to the EventMachine reactor, typically causing your program to terminate. If you wish to handle exceptions, simply supply an `onerror callback` and check for exceptions which are not descendant from `EM::WebSocket::WebSocketError`.
+
+It is also possible to log all errors when developing by including the `:debug => true` option when initialising the WebSocket server.
 
-It is also possible to log all errors when developing by including the `:debug => true` option when initialising the WebSocket connection.
+## Emulating WebSockets in older browsers
+
+It is possible to emulate WebSockets in older browsers using flash emulation. For example take a look at the [web-socket-js](https://github.com/gimite/web-socket-js) project.
+
+Using flash emulation does require some minimal support from em-websocket which is enabled by default. If flash connects to the WebSocket port and requests a policy file (which it will do if it fails to receive a policy file on port 843 after a timeout), em-websocket will return one. Also see <https://github.com/igrigorik/em-websocket/issues/61> for an example policy file server which you can run on port 843.
 
 ## Examples & Projects using em-websocket
 
-* [Pusher](http://pusherapp.com) - Realtime client push
+* [Pusher](http://pusher.com) - Realtime Messaging Service
 * [Livereload](https://github.com/mockko/livereload) - LiveReload applies CSS/JS changes to Safari or Chrome w/o reloading
 * [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/examples/echo.rb

@@ -1,8 +1,24 @@
 require File.expand_path('../../lib/em-websocket', __FILE__)
 
-EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080, :debug => true) do |ws|
-  ws.onopen    { ws.send "Hello Client!"}
-  ws.onmessage { |msg| ws.send "Pong: #{msg}" }
-  ws.onclose   { puts "WebSocket closed" }
-  ws.onerror   { |e| puts "Error: #{e.message}" }
-end
+EM.run {
+  EM::WebSocket.run(:host => "0.0.0.0", :port => 8080, :debug => false) do |ws|
+    ws.onopen { |handshake|
+      puts "WebSocket opened #{{
+        :path => handshake.path,
+        :query => handshake.query,
+        :origin => handshake.origin,
+      }}"
+
+      ws.send "Hello Client!"
+    }
+    ws.onmessage { |msg|
+      ws.send "Pong: #{msg}"
+    }
+    ws.onclose {
+      puts "WebSocket closed"
+    }
+    ws.onerror { |e|
+      puts "Error: #{e.message}"
+    }
+  end
+}

data/examples/test.html

@@ -1,8 +1,5 @@
 <html>
   <head>
-    <script src='js/swfobject.js'></script>
-    <script src='js/FABridge.js'></script>
-    <script src='js/web_socket.js'></script>
     <script>
       function init() {
         function debug(string) {
@@ -13,9 +10,11 @@
         }
 
         var Socket = "MozWebSocket" in window ? MozWebSocket : WebSocket;
-        var ws = new Socket("ws://localhost:8080/");
-        ws.onmessage = function(evt) { debug("Message: " + evt.data); };
-        ws.onclose = function() { debug("socket closed"); };
+        var ws = new Socket("ws://localhost:8080/foo/bar?hello=world");
+        ws.onmessage = function(evt) { debug("Received: " + evt.data); };
+        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.rb

@@ -4,12 +4,13 @@ require "eventmachine"
 
 %w[
   debugger websocket connection
+  handshake
   handshake75 handshake76 handshake04
   framing76 framing03 framing04 framing05 framing07
   close75 close03 close05 close06
   masking04
   message_processor_03 message_processor_06
-  handler_factory handler handler75 handler76 handler03 handler05 handler06 handler07 handler08 handler13
+  handler handler75 handler76 handler03 handler05 handler06 handler07 handler08 handler13
 ].each do |file|
   require "em-websocket/#{file}"
 end

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

@@ -1,5 +1,3 @@
-require 'addressable/uri'
-
 module EventMachine
   module WebSocket
     class Connection < EventMachine::Connection
@@ -12,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
-        @onopen.call if @onopen
+      def trigger_on_open(handshake)
+        @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,8 +42,12 @@ module EventMachine
         @options = options
         @debug = options[:debug] || false
         @secure = options[:secure] || false
+        @secure_proxy = options[:secure_proxy] || false
         @tls_options = options[:tls_options] || {}
-        @data = ''
+        @close_timeout = options[:close_timeout]
+        @outbound_limit = options[:outbound_limit] || 0
+
+        @handler = nil
 
         debug [:initialize]
       end
@@ -49,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
@@ -72,22 +78,25 @@ module EventMachine
         else
           dispatch(data)
         end
-      rescue HandshakeError => e
-        debug [:error, e]
-        trigger_on_error(e)
-        # Errors during the handshake require the connection to be aborted
-        abort
-      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
@@ -101,23 +110,54 @@ 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
-          return false
         else
-          debug [:inbound_headers, data]
-          @data << data
-          @handler = HandlerFactory.build(self, @data, @secure, @debug)
-          unless @handler
-            # The whole header has not been received yet.
-            return false
+          @handshake ||= begin
+            handshake = Handshake.new(@secure || @secure_proxy)
+
+            handshake.callback { |upgrade_response, handler_klass|
+              debug [:accepting_ws_version, handshake.protocol_version]
+              debug [:upgrade_response, upgrade_response]
+              self.send_data(upgrade_response)
+              @handler = handler_klass.new(self, @debug)
+              @handshake = nil
+              trigger_on_open(handshake)
+            }
+
+            handshake.errback { |e|
+              debug [:error, e]
+              trigger_on_error(e)
+              # Handshake errors require the connection to be aborted
+              abort(:handshake_error)
+            }
+
+            handshake
           end
-          @data = nil
-          @handler.run
-          return true
+
+          @handshake.receive_data(data)
         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]
@@ -139,7 +179,7 @@ module EventMachine
       # A WebSocketError may be raised if the connection is in an opening or a
       # closing state, or if the passed in data is not valid UTF-8
       #
-      def send(data)
+      def send_text(data)
         # If we're using Ruby 1.9, be pedantic about encodings
         if ENCODING_SUPPORTED
           # Also accept ascii only data in other encodings for convenience
@@ -161,7 +201,20 @@ module EventMachine
 
         # Revert data back to the original encoding (which we assume is UTF-8)
         # Doing this to avoid duping the string - there may be a better way
-        data.force_encoding(UTF8)
+        data.force_encoding(UTF8) if ENCODING_SUPPORTED
+        return nil
+      end
+
+      alias :send :send_text
+
+      # Send a WebSocket binary frame.
+      #
+      def send_binary(data)
+        if @handler
+          @handler.send_frame(:binary, data)
+        else
+          raise WebSocketError, "Cannot send binary before onopen callback"
+        end
       end
 
       # Send a ping to the client. The client must respond with a pong.
@@ -201,14 +254,23 @@ module EventMachine
         end
       end
 
-      def request
-        @handler ? @handler.request : {}
+      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.
@@ -218,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