[WIP] Begin implementing permessage-deflate.

Implement masking as a transform stream.
Optimise some special cases in StreamReader; return a new Buffer from read() immediately if there's enough buffered data, and if the read can be fulfilled entirely from the first queued buffer than take a slice rather than copying into a new buffer.
2014-05-11 22:32:15 +01:00 · 2014-05-11 22:07:34 +01:00 · 2014-05-11 13:33:51 +01:00 · 2014-05-09 15:35:40 +01:00 · 2014-05-08 16:35:21 +01:00
35 changed files with 1090 additions and 1775 deletions
@@ -1,2 +1 @@
 node_modules
-package-lock.json
@@ -0,0 +1,6 @@
+.git
+.gitignore
+.npmignore
+.travis.yml
+node_modules
+spec
@@ -1,21 +1,11 @@
-sudo: false
 language: node_js

 node_js:
+  - "0.6"
  - "0.8"
  - "0.10"
-  - "0.12"
-  - "4"
-  - "5"
-  - "6"
-  - "7"
-  - "8"
-  - "9"
-  - "10"
-  - "11"
-  - "12"
-  - "13"
-  - "14"
+  - "0.11"

 before_install:
-  - '[ "${TRAVIS_NODE_VERSION}" != "0.8" ] || npm install -g npm@~1.4.0'
+  - '[ "${TRAVIS_NODE_VERSION}" = "0.6" ] && npm conf set strict-ssl false || true'
+
@@ -1,142 +1,42 @@
-### 0.7.4 / 2020-05-22
-
- Avoid crashing if `process.version` does not contain any digits
- Emit `ping` and `pong` events from the `Server` driver
- Require http-parser-js >=0.5.1 which fixes the bug we addressed in 0.7.3
-
-### 0.7.3 / 2019-06-13
-
- Cap version of http-parser-js below 0.4.11, which introduced a bug that
-  prevents us from handling messages that are part of the same input buffer as
-  the handshake response if chunked encoding is specified
-
-### 0.7.2 / 2019-06-13
-
-(This version was pulled due to an error when publishing)
-
-### 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
- Use the `Buffer.alloc()` and `Buffer.from()` functions instead of the unsafe
-  `Buffer()` constructor
- 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
- Replace the bindings to Node's HTTP parser with `http-parser-js`
-
-### 0.6.5 / 2016-05-20
-
- Don't mutate buffers passed in by the application when masking
-
-### 0.6.4 / 2016-01-07
-
- If a number is given as input for a frame payload, send it as a string
-
-### 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
-
-### 0.6.2 / 2015-07-18
-
- When the peer sends a close frame with no error code, emit 1000
-
-### 0.6.1 / 2015-07-13
-
- Use the `buffer.{read,write}UInt{16,32}BE` methods for reading/writing numbers
-  to buffers rather than including duplicate logic for this
-
-### 0.6.0 / 2015-07-08
-
- Allow the parser to recover cleanly if event listeners raise an error
- 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
-  sent one
- 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
-  before receiving the server handshake
-
-### 0.5.2 / 2015-02-19
-
- Fix compatibility with the HTTP parser on io.js
- Use `websocket-extensions` to make sure messages and close frames are kept in
-  order
- Don't emit multiple `error` events
-
-### 0.5.1 / 2014-12-18
-
- Don't allow drivers to be created with unrecognized options
-
-### 0.5.0 / 2014-12-13
-
- Support protocol extensions via the websocket-extensions module
-
-### 0.4.0 / 2014-11-08
-
- Support connection via HTTP proxies using `CONNECT`
-
-### 0.3.6 / 2014-10-04
-
- It is now possible to call `close()` before `start()` and close the driver
-
-### 0.3.5 / 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
-
 ### 0.3.4 / 2014-05-08

- Don't hold memory-leaking references to I/O buffers after they have been
-  parsed
+* Don't hold memory-leaking references to I/O buffers after they have been parsed

 ### 0.3.3 / 2014-04-24

- Correct the draft-76 status line reason phrase
+* Correct the draft-76 status line reason phrase

 ### 0.3.2 / 2013-12-29

- Expand `maxLength` 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
+* Expand `maxLength` 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

 ### 0.3.1 / 2013-12-03

- Add a `maxLength` option to limit allowed frame size
- Don't pre-allocate a message buffer until the whole frame has arrived
- Fix compatibility with Node v0.11 `HTTPParser`
+* Add a `maxLength` option to limit allowed frame size
+* Don't pre-allocate a message buffer until the whole frame has arrived
+* Fix compatibility with Node v0.11 `HTTPParser`

 ### 0.3.0 / 2013-09-09

- Support client URLs with Basic Auth credentials
+* Support client URLs with Basic Auth credentials

 ### 0.2.2 / 2013-07-05

- No functional changes, just updates to package.json
+* No functional changes, just updates to package.json

 ### 0.2.1 / 2013-05-17

- Export the isSecureRequest() method since faye-websocket relies on it
- Queue sent messages in the client's initial state
+* Export the isSecureRequest() method since faye-websocket relies on it
+* Queue sent messages in the client's initial state

 ### 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
+
@@ -1,4 +0,0 @@
-# Code of Conduct
-
-All projects under the [Faye](https://github.com/faye) umbrella are covered by
-the [Code of Conduct](https://github.com/faye/code-of-conduct).
@@ -1,12 +0,0 @@
-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.
@@ -1,30 +1,27 @@
-# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.svg)](https://travis-ci.org/faye/websocket-driver-node)
+# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.png)](https://travis-ci.org/faye/websocket-driver-node)

 This module provides a complete implementation of the WebSocket protocols that
-can be hooked up to any I/O stream. It aims to simplify things by decoupling the
-protocol details from the I/O layer, such that users only need to implement code
-to stream data in and out of it without needing to know anything about how the
-protocol actually works. Think of it as a complete WebSocket system with
+can be hooked up to any I/O stream. It aims to simplify things by decoupling
+the protocol details from the I/O layer, such that users only need to implement
+code to stream data in and out of it without needing to know anything about how
+the protocol actually works. Think of it as a complete WebSocket system with
 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:
+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
-  [websocket-extensions](https://github.com/faye/websocket-extensions-node)
-  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
+* 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`
+* 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 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 Node-based
@@ -40,18 +37,18 @@ $ npm install websocket-driver

 ## Usage

-This module provides protocol drivers that have the same interface on the server
-and on the client. A WebSocket driver is an object with two duplex streams
-attached; one for incoming/outgoing messages and one for managing the wire
-protocol over an I/O stream. The full API is described below.
+This module provides protocol drivers that have the same interface on the
+server and on the client. A WebSocket driver is an object with two duplex
+streams attached; one for incoming/outgoing messages and one for managing the
+wire protocol over an I/O stream. The full API is described below.


 ### Server-side with HTTP

-A Node webserver emits a special event for 'upgrade' requests, and this is where
-you should handle WebSockets. You first check whether the request is a
-WebSocket, and if so you can create a driver and attach the request's I/O stream
-to it.
+A Node webserver emits a special event for 'upgrade' requests, and this is
+where you should handle WebSockets. You first check whether the request is a
+WebSocket, and if so you can create a driver and attach the request's I/O
+stream to it.

 ```js
 var http = require('http'),
@@ -137,83 +134,24 @@ var net = require('net'),
    websocket = require('websocket-driver');

 var driver = websocket.client('ws://www.example.com/socket'),
-    tcp = net.connect(80, 'www.example.com');
+    tcp = net.createConnection(80, 'www.example.com');

 tcp.pipe(driver.io).pipe(tcp);

-tcp.on('connect', function() {
-  driver.start();
-});
-
 driver.messages.on('data', function(message) {
  console.log('Got a message', message);
 });
-```
-
-Client drivers have two additional properties for reading the HTTP data that was
-sent back by the server:
-
- `driver.statusCode` - the integer value of the HTTP status code
- `driver.headers` - an object containing the response headers
-
-
-### HTTP Proxies
-
-The client driver supports connections via HTTP proxies using the `CONNECT`
-method. Instead of sending the WebSocket handshake immediately, it will send a
-`CONNECT` request, wait for a `200` response, and then proceed as normal.
-
-To use this feature, call `driver.proxy(url)` where `url` is the origin of the
-proxy, including a username and password if required. This produces a duplex
-stream that you should pipe in and out of your TCP connection to the proxy
-server. When the proxy emits `connect`, you can then pipe `driver.io` to your
-TCP stream and call `driver.start()`.
-
-```js
-var net = require('net'),
-    websocket = require('websocket-driver');
-
-var driver = websocket.client('ws://www.example.com/socket'),
-    proxy  = driver.proxy('http://username:password@proxy.example.com'),
-    tcp    = net.connect(80, 'proxy.example.com');
-
-tcp.pipe(proxy).pipe(tcp, { end: false });

 tcp.on('connect', function() {
-  proxy.start();
-});
-
-proxy.on('connect', function() {
-  driver.io.pipe(tcp).pipe(driver.io);
  driver.start();
 });
-
-driver.messages.on('data', function(message) {
-  console.log('Got a message', message);
-});
 ```

-The proxy's `connect` event is also where you should perform a TLS handshake on
-your TCP stream, if you are connecting to a `wss:` endpoint.
+Client drivers have two additional properties for reading the HTTP data that
+was sent back by the server:

-In the event that proxy connection fails, `proxy` will emit an `error`. You can
-inspect the proxy's response via `proxy.statusCode` and `proxy.headers`.
-
-```js
-proxy.on('error', function(error) {
-  console.error(error.message);
-  console.log(proxy.statusCode);
-  console.log(proxy.headers);
-});
-```
-
-Before calling `proxy.start()` you can set custom headers using
-`proxy.setHeader()`:
-
-```js
-proxy.setHeader('User-Agent', 'node');
-proxy.start();
-```
+* `driver.statusCode` - the integer value of the HTTP status code
+* `driver.headers` - an object containing the response headers


 ### Driver API
@@ -229,24 +167,24 @@ driver = websocket.client(url, options)
 The `http` method returns a driver chosen using the headers from a Node HTTP
 request object. The `server` method returns a driver that will parse an HTTP
 request and then decide which driver to use for it using the `http` method. The
-`client` method always returns a driver for the RFC version of the protocol with
-masking enabled on outgoing frames.
+`client` method always returns a driver for the RFC version of the protocol
+with masking enabled on outgoing frames.

 The `options` argument is optional, and is an object. It may contain the
 following fields:

- `maxLength` - the maximum allowed size of incoming message frames, in bytes.
+* `maxLength` - 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 use
-  over the socket. The driver will negotiate one of these to use via the
+* `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.

 A driver has two duplex streams attached to it:

- **`driver.io`** - this stream should be attached to an I/O socket like a TCP
-  stream. Pipe incoming TCP chunks to this stream for them to be parsed, and
-  pipe this stream back into TCP to send outgoing frames.
- **`driver.messages`** - this stream emits messages received over the
+* <b>`driver.io`</b> - this stream should be attached to an I/O socket like a
+  TCP stream. Pipe incoming TCP chunks to this stream for them to be parsed,
+  and pipe this stream back into TCP to send outgoing frames.
+* <b>`driver.messages`</b> - this stream emits messages received over the
  WebSocket.  Writing to it sends messages to the other peer by emitting frames
  via the `driver.io` stream.

@@ -254,16 +192,16 @@ All drivers respond to the following API methods, but some of them are no-ops
 depending on whether the client supports the behaviour.

 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 emitting `data` events on
-the `driver.io` stream.
+be sent over the socket, they will give this to you by emitting `data` events
+on the `driver.io` stream.

 #### `driver.on('open', function(event) {})`

-Adds a callback to execute when the socket becomes open.
+Sets the callback to execute when the socket becomes open.

 #### `driver.on('message', function(event) {})`

-Adds a callback to execute when a message is received. `event` will have a
+Sets the callback 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 a
 `Buffer` in the case of a binary message.

@@ -272,33 +210,15 @@ which emits strings for text messages and buffers for binary messages.

 #### `driver.on('error', function(event) {})`

-Adds a callback to execute when a protocol error occurs due to the other peer
+Sets the 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', function(event) {})`

-Adds a callback to execute when the socket becomes closed. The `event` object
+Sets the callback to execute when the socket becomes closed. The `event` object
 has `code` and `reason` attributes.

-#### `driver.on('ping', function(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', function(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, function() { ... })` callback.
-
-#### `driver.addExtension(extension)`
-
-Registers a protocol extension whose operation will be negotiated via the
-`Sec-WebSocket-Extensions` header. `extension` is any extension compatible with
-the [websocket-extensions](https://github.com/faye/websocket-extensions-node)
-framework.
-
 #### `driver.setHeader(name, value)`

 Sets a custom header to be sent as part of the handshake response, either from
@@ -309,7 +229,7 @@ when the headers are serialized and sent.

 Initiates the protocol by sending the handshake - either the response for a
 server-side driver or the request for a client-side one. This should be the
-first method you invoke.  Returns `true` if and only if a handshake was sent.
+first method you invoke.  Returns `true` iff a handshake was sent.

 #### `driver.parse(string)`

@@ -329,8 +249,8 @@ This method is equivalent to `driver.messages.write(string)`.
 #### `driver.binary(buffer)`

 Takes a `Buffer` and sends it as a binary message. Will queue and return `true`
-or `false` the same way as the `text` method. It will also return `false` if the
-driver does not support binary messages.
+or `false` the same way as the `text` method. It will also return `false` if
+the driver does not support binary messages.

 This method is equivalent to `driver.messages.write(buffer)`.

@@ -341,22 +261,13 @@ callback are both optional. If a callback is given, it will be invoked when the
 socket receives a pong frame whose content matches `string`. Returns `false` if
 frames can no longer be sent, or if the driver does not support ping/pong.

-#### `driver.pong(string = '')`
-
-Sends a pong frame over the socket, queueing it if necessary. `string` is
-optional. Returns `false` if frames can no longer be sent, or if the driver does
-not support ping/pong.
-
-You don't need to call this when a ping frame is received; pings are replied to
-automatically by the driver. This method is for sending unsolicited pongs.
-
 #### `driver.close()`

-Initiates the closing handshake if the socket is still open. For drivers with no
-closing handshake, this will result in the immediate execution of the
-`on('close')` driver. For drivers with a closing handshake, this sends a closing
-frame and `emit('close')` will execute when a response is received or a protocol
-error occurs.
+Initiates the closing handshake if the socket is still open. For drivers with
+no closing handshake, this will result in the immediate execution of the
+`on('close')` driver. For drivers with a closing handshake, this sends a
+closing frame and `emit('close')` will execute when a response is received or a
+protocol error occurs.

 #### `driver.version`

@@ -366,5 +277,31 @@ Returns the WebSocket version in use as a string. Will either be `hixie-75`,
 #### `driver.protocol`

 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.
+using the `Sec-WebSocket-Protocol` mechanism. This value becomes available
+after `emit('open')` has fired.
+
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2010-2014 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.
+
@@ -1,33 +0,0 @@
-'use strict';
-
-var net       = require('net'),
-    url       = require('url'),
-    websocket = require('..'),
-    deflate   = require('permessage-deflate');
-
-var DEFAULT_PORTS = { 'ws:': 80, 'wss:': 443 };
-
-var uri  = url.parse(process.argv[2]),
-    port = uri.port || DEFAULT_PORTS[uri.protocol],
-    conn = net.connect({ host: uri.hostname, port: port });
-
-var driver = websocket.client(uri.href);
-driver.addExtension(deflate);
-
-driver.on('open', function() {
-  driver.text('Hello, world');
-});
-
-driver.on('message', function(event) {
-  console.log(['message', event.data]);
-});
-
-driver.on('close', function(event) {
-  console.log(['close', event.code, event.reason]);
-  conn.end();
-});
-
-conn.pipe(driver.io);
-driver.io.pipe(conn);
-
-driver.start();
@@ -1,12 +1,10 @@
-'use strict';
-
 var net       = require('net'),
-    websocket = require('..'),
-    deflate   = require('permessage-deflate');
+    websocket = require('../lib/websocket/driver'),
+    deflate   = require('../lib/websocket/extensions/per_message_deflate');

 var server = net.createServer(function(connection) {
  var driver = websocket.server();
-  driver.addExtension(deflate);
+  driver.addExtension('permessage-deflate', deflate.create());

  driver.on('connect', function() {
    if (websocket.isWebSocket(driver)) driver.start();
@@ -22,3 +20,4 @@ var server = net.createServer(function(connection) {
 });

 server.listen(process.argv[2]);
+
@@ -1,13 +1,10 @@
-'use strict';
-
 // Protocol references:
-//
+// 
 // * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
 // * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
 // * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17

-var Base   = require('./driver/base'),
-    Client = require('./driver/client'),
+var Client = require('./driver/client'),
    Server = require('./driver/server');

 var Driver = {
@@ -32,12 +29,16 @@ var Driver = {
  },

  isWebSocket: function(request) {
-    return Base.isWebSocket(request);
-  },
+    if (request.method !== 'GET') return false;

-  validateOptions: function(options, validKeys) {
-    Base.validateOptions(options, validKeys);
+    var connection = request.headers.connection || '',
+        upgrade    = request.headers.upgrade || '';
+
+    return request.method === 'GET' &&
+           connection.toLowerCase().split(/\s*,\s*/).indexOf('upgrade') >= 0 &&
+           upgrade.toLowerCase() === 'websocket';
  }
 };

 module.exports = Driver;
+
@@ -1,24 +1,19 @@
-'use strict';
-
-var Buffer  = require('safe-buffer').Buffer,
-    Emitter = require('events').EventEmitter,
+var Emitter = require('events').EventEmitter,
    util    = require('util'),
    streams = require('../streams'),
-    Headers = require('./headers'),
-    Reader  = require('./stream_reader');
+    Headers = require('./headers');

 var Base = function(request, url, options) {
  Emitter.call(this);
-  Base.validateOptions(options || {}, ['maxLength', 'masking', 'requireMasking', 'protocols']);

-  this._request   = request;
-  this._reader    = new Reader();
-  this._options   = options || {};
-  this._maxLength = this._options.maxLength || this.MAX_LENGTH;
-  this._headers   = new Headers();
-  this.__queue    = [];
-  this.readyState = 0;
-  this.url        = url;
+  this._request    = request;
+  this._options    = options || {};
+  this._extensions = {};
+  this._maxLength  = this._options.maxLength || this.MAX_LENGTH;
+  this.__headers   = new Headers();
+  this.__queue     = [];
+  this.readyState  = 0;
+  this.url         = url;

  this.io = new streams.IO(this);
  this.messages = new streams.Messages(this);
@@ -26,22 +21,6 @@ var Base = function(request, url, options) {
 };
 util.inherits(Base, Emitter);

-Base.isWebSocket = function(request) {
-  var connection = request.headers.connection || '',
-      upgrade    = request.headers.upgrade || '';
-
-  return request.method === 'GET' &&
-         connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
-         upgrade.toLowerCase() === 'websocket';
-};
-
-Base.validateOptions = function(options, validKeys) {
-  for (var key in options) {
-    if (validKeys.indexOf(key) < 0)
-      throw new Error('Unrecognized option: ' + key);
-  }
-};
-
 var instance = {
  // This is 64MB, small enough for an average VPS to handle without
  // crashing from process out of memory
@@ -73,51 +52,27 @@ var instance = {
    });
  },

+  addExtension: function(name, extension) {
+    this._extensions[name] = extension;
+  },
+
  getState: function() {
    return this.STATES[this.readyState] || null;
  },

-  addExtension: function(extension) {
-    return false;
-  },
-
  setHeader: function(name, value) {
    if (this.readyState > 0) return false;
-    this._headers.set(name, value);
+    this.__headers.set(name, value);
    return true;
  },

  start: function() {
    if (this.readyState !== 0) return false;
-
-    if (!Base.isWebSocket(this._request))
-      return this._failHandshake(new Error('Not a WebSocket request'));
-
-    var response;
-
-    try {
-      response = this._handshakeResponse();
-    } catch (error) {
-      return this._failHandshake(error);
-    }
-
-    this._write(response);
+    this._write(this._handshakeResponse());
    if (this._stage !== -1) this._open();
    return true;
  },

-  _failHandshake: function(error) {
-    var headers = new Headers();
-    headers.set('Content-Type', 'text/plain');
-    headers.set('Content-Length', Buffer.byteLength(error.message, 'utf8'));
-
-    headers = ['HTTP/1.1 400 Bad Request', headers.toString(), error.message];
-    this._write(Buffer.from(headers.join('\r\n'), 'utf8'));
-    this._fail('protocol_error', error.message);
-
-    return false;
-  },
-
  text: function(message) {
    return this.frame(message);
  },
@@ -130,10 +85,6 @@ var instance = {
    return false;
  },

-  pong: function() {
-      return false;
-  },
-
  close: function(reason, code) {
    if (this.readyState !== 1) return false;
    this.readyState = 3;
@@ -156,18 +107,15 @@ var instance = {
  _write: function(chunk) {
    var io = this.io;
    if (io.readable) io.emit('data', chunk);
-  },
-
-  _fail: function(type, message) {
-    this.readyState = 2;
-    this.emit('error', new Error(message));
-    this.close();
  }
 };

 for (var key in instance)
  Base.prototype[key] = instance[key];

+Base.parseHeader = function(header) {
+  return Headers.parseHeader(header);
+};

 Base.ConnectEvent = function() {};

@@ -182,12 +130,5 @@ Base.MessageEvent = function(data) {
  this.data = data;
 };

-Base.PingEvent = function(data) {
-  this.data = data;
-};
-
-Base.PongEvent = function(data) {
-  this.data = data;
-};
-
 module.exports = Base;
+
@@ -1,56 +1,27 @@
-'use strict';
-
-var Buffer     = require('safe-buffer').Buffer,
-    crypto     = require('crypto'),
-    url        = require('url'),
+var url        = require('url'),
    util       = require('util'),
-    HttpParser = require('../http_parser'),
+    HttpParser = require('./http_parser'),
    Base       = require('./base'),
-    Hybi       = require('./hybi'),
-    Proxy      = require('./proxy');
+    Hybi       = require('./hybi');

-var Client = function(_url, options) {
-  this.version = 'hybi-' + Hybi.VERSION;
-  Hybi.call(this, null, _url, options);
+var Client = function(url, options) {
+  this.version = 'hybi-13';
+  Hybi.call(this, null, url, options);

  this.readyState = -1;
  this._key       = Client.generateKey();
  this._accept    = Hybi.generateAccept(this._key);
  this._http      = new HttpParser('response');
-
-  var uri  = url.parse(this.url),
-      auth = uri.auth && Buffer.from(uri.auth, 'utf8').toString('base64');
-
-  if (this.VALID_PROTOCOLS.indexOf(uri.protocol) < 0)
-    throw new Error(this.url + ' is not a valid WebSocket URL');
-
-  this._pathname = (uri.pathname || '/') + (uri.search || '');
-
-  this._headers.set('Host', uri.host);
-  this._headers.set('Upgrade', 'websocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('Sec-WebSocket-Key', this._key);
-  this._headers.set('Sec-WebSocket-Version', Hybi.VERSION);
-
-  if (this._protocols.length > 0)
-    this._headers.set('Sec-WebSocket-Protocol', this._protocols.join(', '));
-
-  if (auth)
-    this._headers.set('Authorization', 'Basic ' + auth);
 };
 util.inherits(Client, Hybi);

 Client.generateKey = function() {
-  return crypto.randomBytes(16).toString('base64');
+  var buffer = new Buffer(16), i = buffer.length;
+  while (i--) buffer[i] = ~~(Math.random() * 256);
+  return buffer.toString('base64');
 };

 var instance = {
-  VALID_PROTOCOLS: ['ws:', 'wss:'],
-
-  proxy: function(origin, options) {
-    return new Proxy(this, origin, options);
-  },
-
  start: function() {
    if (this.readyState !== -1) return false;
    this._write(this._handshakeRequest());
@@ -58,35 +29,40 @@ var instance = {
    return true;
  },

-  parse: function(chunk) {
-    if (this.readyState === 3) return;
-    if (this.readyState > 0) return Hybi.prototype.parse.call(this, chunk);
+  parse: function(data) {
+    if (this.readyState > 0) return Hybi.prototype.parse.call(this, data);

-    this._http.parse(chunk);
+    this._http.parse(data);
    if (!this._http.isComplete()) return;
-
+    
    this._validateHandshake();
-    if (this.readyState === 3) return;
-
-    this._open();
    this.parse(this._http.body);
  },

  _handshakeRequest: function() {
-    var extensions = this._extensions.generateOffer();
-    if (extensions)
-      this._headers.set('Sec-WebSocket-Extensions', extensions);
+    var uri = url.parse(this.url);

-    var start   = 'GET ' + this._pathname + ' HTTP/1.1',
-        headers = [start, this._headers.toString(), ''];
+    var headers = [ 'GET ' + (uri.pathname || '/') + (uri.search || '') + ' HTTP/1.1',
+                    'Host: ' + uri.hostname + (uri.port ? ':' + uri.port : ''),
+                    'Upgrade: websocket',
+                    'Connection: Upgrade',
+                    'Sec-WebSocket-Key: ' + this._key,
+                    'Sec-WebSocket-Version: 13'
+                  ];

-    return Buffer.from(headers.join('\r\n'), 'utf8');
+    if (this._protocols.length > 0)
+      headers.push('Sec-WebSocket-Protocol: ' + this._protocols.join(', '));
+
+    if (uri.auth)
+      headers.push('Authorization: Basic ' + new Buffer(uri.auth, 'utf8').toString('base64'));
+
+    return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
  },

  _failHandshake: function(message) {
    message = 'Error during WebSocket handshake: ' + message;
-    this.readyState = 3;
    this.emit('error', new Error(message));
+    this.readyState = 3;
    this.emit('close', new Base.CloseEvent(this.ERRORS.protocol_error, message));
  },

@@ -94,9 +70,6 @@ var instance = {
    this.statusCode = this._http.statusCode;
    this.headers    = this._http.headers;

-    if (this._http.error)
-      return this._failHandshake(this._http.error.message);
-
    if (this._http.statusCode !== 101)
      return this._failHandshake('Unexpected response code: ' + this._http.statusCode);

@@ -128,11 +101,7 @@ var instance = {
        this.protocol = protocol;
    }

-    try {
-      this._extensions.activate(this.headers['sec-websocket-extensions']);
-    } catch (e) {
-      return this._failHandshake(e.message);
-    }
+    this._open();
  }
 };

@@ -140,3 +109,4 @@ for (var key in instance)
  Client.prototype[key] = instance[key];

 module.exports = Client;
+
@@ -1,18 +1,10 @@
-'use strict';
-
-var Buffer = require('safe-buffer').Buffer,
-    Base   = require('./base'),
-    util   = require('util');
+var Base = require('./base'),
+    util = require('util');

 var Draft75 = function(request, url, options) {
  Base.apply(this, arguments);
-  this._stage  = 0;
+  this._stage = 0;
  this.version = 'hixie-75';
-
-  this._headers.set('Upgrade', 'WebSocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('WebSocket-Origin', this._request.headers.origin);
-  this._headers.set('WebSocket-Location', this.url);
 };
 util.inherits(Draft75, Base);

@@ -24,46 +16,46 @@ var instance = {
    return true;
  },

-  parse: function(chunk) {
+  parse: function(buffer) {
    if (this.readyState > 1) return;

-    this._reader.put(chunk);
-
-    this._reader.eachByte(function(octet) {
-      var message;
+    var data, message, value;
+    for (var i = 0, n = buffer.length; i < n; i++) {
+      data = buffer[i];

      switch (this._stage) {
        case -1:
-          this._body.push(octet);
+          this._body.push(data);
          this._sendHandshakeBody();
          break;

        case 0:
-          this._parseLeadingByte(octet);
+          this._parseLeadingByte(data);
          break;

        case 1:
-          this._length = (octet & 0x7F) + 128 * this._length;
+          value = (data & 0x7F);
+          this._length = value + 128 * this._length;

          if (this._closing && this._length === 0) {
            return this.close();
          }
-          else if ((octet & 0x80) !== 0x80) {
+          else if ((0x80 & data) !== 0x80) {
            if (this._length === 0) {
              this._stage = 0;
            }
            else {
              this._skipped = 0;
-              this._stage   = 2;
+              this._stage = 2;
            }
          }
          break;

        case 2:
-          if (octet === 0xFF) {
-            this._stage = 0;
-            message = Buffer.from(this._buffer).toString('utf8', 0, this._buffer.length);
+          if (data === 0xFF) {
+            message = new Buffer(this._buffer).toString('utf8', 0, this._buffer.length);
            this.emit('message', new Base.MessageEvent(message));
+            this._stage = 0;
          }
          else {
            if (this._length) {
@@ -71,48 +63,50 @@ var instance = {
              if (this._skipped === this._length)
                this._stage = 0;
            } else {
-              this._buffer.push(octet);
+              this._buffer.push(data);
              if (this._buffer.length > this._maxLength) return this.close();
            }
          }
          break;
      }
-    }, this);
+    }
  },

-  frame: function(buffer) {
-    if (this.readyState === 0) return this._queue([buffer]);
+  frame: function(data) {
+    if (this.readyState === 0) return this._queue([data]);
    if (this.readyState > 1) return false;

-    if (typeof buffer !== 'string') buffer = buffer.toString();
-
-    var length = Buffer.byteLength(buffer),
-        frame  = Buffer.allocUnsafe(length + 2);
+    var buffer = new Buffer(data, 'utf8'),
+        frame  = new Buffer(buffer.length + 2);

    frame[0] = 0x00;
-    frame.write(buffer, 1);
-    frame[frame.length - 1] = 0xFF;
+    frame[buffer.length + 1] = 0xFF;
+    buffer.copy(frame, 1);

    this._write(frame);
    return true;
  },

  _handshakeResponse: function() {
-    var start   = 'HTTP/1.1 101 Web Socket Protocol Handshake',
-        headers = [start, this._headers.toString(), ''];
-
-    return Buffer.from(headers.join('\r\n'), 'utf8');
+    return new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
+                      'Upgrade: WebSocket\r\n' +
+                      'Connection: Upgrade\r\n' +
+                      'WebSocket-Origin: ' + this._request.headers.origin + '\r\n' +
+                      'WebSocket-Location: ' + this.url + '\r\n' +
+                      this.__headers.toString() +
+                      '\r\n',
+                      'utf8');
  },

-  _parseLeadingByte: function(octet) {
-    if ((octet & 0x80) === 0x80) {
+  _parseLeadingByte: function(data) {
+    if ((0x80 & data) === 0x80) {
      this._length = 0;
-      this._stage  = 1;
+      this._stage = 1;
    } else {
      delete this._length;
      delete this._skipped;
      this._buffer = [];
-      this._stage  = 2;
+      this._stage = 2;
    }
  }
 };
@@ -121,3 +115,4 @@ for (var key in instance)
  Draft75.prototype[key] = instance[key];

 module.exports = Draft75;
+
@@ -1,18 +1,23 @@
-'use strict';
-
-var Buffer  = require('safe-buffer').Buffer,
-    Base    = require('./base'),
+var Base    = require('./base'),
    Draft75 = require('./draft75'),
    crypto  = require('crypto'),
    util    = require('util');


 var numberFromKey = function(key) {
-  return parseInt((key.match(/[0-9]/g) || []).join(''), 10);
+  return parseInt(key.match(/[0-9]/g).join(''), 10);
 };

 var spacesInKey = function(key) {
-  return (key.match(/ /g) || []).length;
+  return key.match(/ /g).length;
+};
+
+var bigEndian = function(number) {
+  var string = '';
+  [24, 16, 8, 0].forEach(function(offset) {
+    string += String.fromCharCode(number >> offset & 0xFF);
+  });
+  return string;
 };


@@ -21,13 +26,6 @@ var Draft76 = function(request, url, options) {
  this._stage  = -1;
  this._body   = [];
  this.version = 'hixie-76';
-
-  this._headers.clear();
-
-  this._headers.set('Upgrade', 'WebSocket');
-  this._headers.set('Connection', 'Upgrade');
-  this._headers.set('Sec-WebSocket-Origin', this._request.headers.origin);
-  this._headers.set('Sec-WebSocket-Location', this.url);
 };
 util.inherits(Draft76, Draft75);

@@ -43,49 +41,42 @@ var instance = {

  close: function() {
    if (this.readyState === 3) return false;
-    if (this.readyState === 1) this._write(Buffer.from([0xFF, 0x00]));
+    this._write(new Buffer([0xFF, 0x00]));
    this.readyState = 3;
    this.emit('close', new Base.CloseEvent(null, null));
    return true;
  },

  _handshakeResponse: function() {
-    var headers = this._request.headers,
-        key1    = headers['sec-websocket-key1'],
-        key2    = headers['sec-websocket-key2'];
-
-    if (!key1) throw new Error('Missing required header: Sec-WebSocket-Key1');
-    if (!key2) throw new Error('Missing required header: Sec-WebSocket-Key2');
-
-    var number1 = numberFromKey(key1),
-        spaces1 = spacesInKey(key1),
-
-        number2 = numberFromKey(key2),
-        spaces2 = spacesInKey(key2);
-
-    if (number1 % spaces1 !== 0 || number2 % spaces2 !== 0)
-      throw new Error('Client sent invalid Sec-WebSocket-Key headers');
-
-    this._keyValues = [number1 / spaces1, number2 / spaces2];
-
-    var start   = 'HTTP/1.1 101 WebSocket Protocol Handshake',
-        headers = [start, this._headers.toString(), ''];
-
-    return Buffer.from(headers.join('\r\n'), 'binary');
+    return new Buffer('HTTP/1.1 101 WebSocket Protocol Handshake\r\n' +
+                      'Upgrade: WebSocket\r\n' +
+                      'Connection: Upgrade\r\n' +
+                      'Sec-WebSocket-Origin: ' + this._request.headers.origin + '\r\n' +
+                      'Sec-WebSocket-Location: ' + this.url + '\r\n' +
+                      this.__headers.toString() +
+                      '\r\n',
+                      'binary');
  },

  _handshakeSignature: function() {
    if (this._body.length < this.BODY_SIZE) return null;
+    var body = new Buffer(this._body.slice(0, this.BODY_SIZE));

-    var md5    = crypto.createHash('md5'),
-        buffer = Buffer.allocUnsafe(8 + this.BODY_SIZE);
+    var headers = this._request.headers,

-    buffer.writeUInt32BE(this._keyValues[0], 0);
-    buffer.writeUInt32BE(this._keyValues[1], 4);
-    Buffer.from(this._body).copy(buffer, 8, 0, this.BODY_SIZE);
+        key1    = headers['sec-websocket-key1'],
+        value1  = numberFromKey(key1) / spacesInKey(key1),

-    md5.update(buffer);
-    return Buffer.from(md5.digest('binary'), 'binary');
+        key2    = headers['sec-websocket-key2'],
+        value2  = numberFromKey(key2) / spacesInKey(key2),
+
+        md5     = crypto.createHash('md5');
+
+    md5.update(bigEndian(value1));
+    md5.update(bigEndian(value2));
+    md5.update(body.toString('binary'));
+
+    return new Buffer(md5.digest('binary'), 'binary');
  },

  _sendHandshakeBody: function() {
@@ -101,9 +92,9 @@ var instance = {
      this.parse(this._body.slice(this.BODY_SIZE));
  },

-  _parseLeadingByte: function(octet) {
-    if (octet !== 0xFF)
-      return Draft75.prototype._parseLeadingByte.call(this, octet);
+  _parseLeadingByte: function(data) {
+    if (data !== 0xFF)
+      return Draft75.prototype._parseLeadingByte.call(this, data);

    this._closing = true;
    this._length  = 0;
@@ -115,3 +106,4 @@ for (var key in instance)
  Draft76.prototype[key] = instance[key];

 module.exports = Draft76;
+
@@ -1,16 +1,26 @@
-'use strict';
-
 var Headers = function() {
-  this.clear();
-};
-
-Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate'];
-
-Headers.prototype.clear = function() {
  this._sent  = {};
  this._lines = [];
 };

+Headers.parseHeader = function(header) {
+  if (!header) return [];
+
+  return header.split(/\s*,\s*/).map(function(value) {
+    var parts  = value.split(/\s*;\s*/),
+        name   = parts.shift(),
+        params = {};
+
+    parts.forEach(function(part) {
+      var pair = part.split(/\s*=\s*/);
+      params[pair[0]] = pair[1] || true;
+    });
+    return {name: name, params: params};
+  });
+};
+
+Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate']
+
 Headers.prototype.set = function(name, value) {
  if (value === undefined) return;

@@ -18,7 +28,7 @@ Headers.prototype.set = function(name, value) {
  value = this._strip(value);

  var key = name.toLowerCase();
-  if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) {
+  if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) < 0) {
    this._sent[key] = true;
    this._lines.push(name + ': ' + value + '\r\n');
  }
@@ -33,3 +43,4 @@ Headers.prototype._strip = function(string) {
 };

 module.exports = Headers;
+
@@ -0,0 +1,88 @@
+var HTTPParser = process.binding('http_parser').HTTPParser,
+    version    = HTTPParser.RESPONSE ? 6 : 4;
+
+var HttpParser = function(type) {
+  if (type === 'request')
+    this._parser = new HTTPParser(HTTPParser.REQUEST || 'request');
+  else
+    this._parser = new HTTPParser(HTTPParser.RESPONSE || 'response');
+
+  this._type     = type;
+  this._complete = false;
+  this.headers   = {};
+
+  var current = null,
+      self    = this;
+
+  this._parser.onHeaderField = function(b, start, length) {
+    current = b.toString('utf8', start, start + length).toLowerCase();
+  };
+
+  this._parser.onHeaderValue = function(b, start, length) {
+    self.set(current, b.toString('utf8', start, start + length));
+  };
+
+  this._parser.onHeadersComplete = this._parser[HTTPParser.kOnHeadersComplete] = function(info) {
+    self.method     = (typeof info.method === 'number') ? HttpParser.METHODS[info.method] : info.method;
+    self.statusCode = info.statusCode;
+    self.url        = info.url;
+    
+    var headers = info.headers, name, values;
+    if (!headers) return;
+
+    for (var i = 0, n = headers.length; i < n; i += 2)
+      self.set(headers[i].toLowerCase(), headers[i+1]);
+  };
+
+  this._parser.onMessageComplete = this._parser[HTTPParser.kOnMessageComplete] = function() {
+    self._complete = true;
+  };
+};
+
+HttpParser.METHODS = {
+  0:  'DELETE',
+  1:  'GET',
+  2:  'HEAD',
+  3:  'POST',
+  4:  'PUT',
+  5:  'CONNECT',
+  6:  'OPTIONS',
+  7:  'TRACE',
+  8:  'COPY',
+  9:  'LOCK',
+  10: 'MKCOL',
+  11: 'MOVE',
+  12: 'PROPFIND',
+  13: 'PROPPATCH',
+  14: 'SEARCH',
+  15: 'UNLOCK',
+  16: 'REPORT',
+  17: 'MKACTIVITY',
+  18: 'CHECKOUT',
+  19: 'MERGE',
+  24: 'PATCH'
+};
+
+HttpParser.prototype.set = function(name, value) {
+  var values = [];
+  if (this.headers.hasOwnProperty(name)) values.push(this.headers[name]);
+  values.push(value);
+  this.headers[name] = values.join(', ');
+};
+
+HttpParser.prototype.isComplete = function() {
+  return this._complete;
+};
+
+HttpParser.prototype.parse = function(data) {
+  var offset   = (version < 6) ? 1 : 0,
+      consumed = this._parser.execute(data, 0, data.length) + offset;
+
+  if (this._complete)
+    this.body = (consumed < data.length)
+              ? data.slice(consumed)
+              : new Buffer(0);
+};
+
+module.exports = HttpParser;
+
@@ -1,52 +1,33 @@
-'use strict';
-
-var Buffer     = require('safe-buffer').Buffer,
-    crypto     = require('crypto'),
-    util       = require('util'),
-    Extensions = require('websocket-extensions'),
-    Base       = require('./base'),
-    Frame      = require('./hybi/frame'),
-    Message    = require('./hybi/message');
+var crypto = require('crypto'),
+    util   = require('util'),
+    Base   = require('./base'),
+    Concat = require('./hybi/concat'),
+    Mask   = require('./hybi/mask'),
+    Reader = require('./hybi/stream_reader');

 var Hybi = function(request, url, options) {
  Base.apply(this, arguments);
+  this._reset();
+
+  this._reader    = new Reader({context: this});
+  this._masking   = this._options.masking;
+  this._protocols = this._options.protocols || [];
+
+  if (typeof this._protocols === 'string')
+    this._protocols = this._protocols.split(/\s*,\s*/);

-  this._extensions     = new Extensions();
-  this._stage          = 0;
-  this._masking        = this._options.masking;
-  this._protocols      = this._options.protocols || [];
  this._requireMasking = this._options.requireMasking;
  this._pingCallbacks  = {};

-  if (typeof this._protocols === 'string')
-    this._protocols = this._protocols.split(/ *, */);
-
-  if (!this._request) return;
-
-  var protos    = this._request.headers['sec-websocket-protocol'],
-      supported = this._protocols;
-
-  if (protos !== undefined) {
-    if (typeof protos === 'string') protos = protos.split(/ *, */);
-    this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
+  if (!this.version) {
+    var version = this._request.headers['sec-websocket-version'];
+    this.version = 'hybi-' + version;
  }

-  this.version = 'hybi-' + Hybi.VERSION;
+  this._reader.read(1, this._parseOpcode);
 };
 util.inherits(Hybi, Base);

-Hybi.VERSION = '13';
-
-Hybi.mask = function(payload, mask, offset) {
-  if (!mask || mask.length === 0) return payload;
-  offset = offset || 0;
-
-  for (var i = 0, n = payload.length - offset; i < n; i++) {
-    payload[offset + i] = payload[offset + i] ^ mask[i % 4];
-  }
-  return payload;
-};
-
 Hybi.generateAccept = function(key) {
  var sha1 = crypto.createHash('sha1');
  sha1.update(key + Hybi.GUID);
@@ -56,13 +37,14 @@ Hybi.generateAccept = function(key) {
 Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';

 var instance = {
-  FIN:    0x80,
-  MASK:   0x80,
-  RSV1:   0x40,
-  RSV2:   0x20,
-  RSV3:   0x10,
-  OPCODE: 0x0F,
-  LENGTH: 0x7F,
+  BYTE:   255,
+  FIN:    128,
+  MASK:   128,
+  RSV1:   64,
+  RSV2:   32,
+  RSV3:   16,
+  OPCODE: 15,
+  LENGTH: 127,

  OPCODES: {
    continuation: 0,
@@ -73,9 +55,11 @@ var instance = {
    pong:         10
  },

-  OPCODE_CODES:    [0, 1, 2, 8, 9, 10],
-  MESSAGE_OPCODES: [0, 1, 2],
-  OPENING_OPCODES: [1, 2],
+  OPCODE_CODES:       [0, 1, 2, 8, 9, 10],
+  FRAGMENTED_OPCODES: [0, 1, 2],
+  OPENING_OPCODES:    [1, 2],
+
+  TWO_POWERS: [0, 1, 2, 3, 4, 5, 6, 7].map(function(n) { return Math.pow(2, 8 * n) }),

  ERRORS: {
    normal_closure:       1000,
@@ -90,296 +74,217 @@ var instance = {
  },

  ERROR_CODES:        [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
-  DEFAULT_ERROR_CODE: 1000,
  MIN_RESERVED_ERROR: 3000,
  MAX_RESERVED_ERROR: 4999,

  // http://www.w3.org/International/questions/qa-forms-utf-8.en.php
  UTF8_MATCH: /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/,

-  addExtension: function(extension) {
-    this._extensions.add(extension);
+  parse: function(data) {
+    this._reader.write(data);
+  },
+
+  frame: function(data, type, code) {
+    if (this.readyState <= 0) return this._queue([data, type, code]);
+    if (this.readyState !== 1) return false;
+
+    if (data instanceof Array) data = new Buffer(data);
+
+    var isText = (typeof data === 'string'),
+        opcode = this.OPCODES[type || (isText ? 'text' : 'binary')],
+        buffer = isText ? new Buffer(data, 'utf8') : data,
+        insert = code ? 2 : 0,
+        length = buffer.length + insert,
+        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
+        offset = header + (this._masking ? 4 : 0),
+        masked = this._masking ? this.MASK : 0,
+        frame  = new Buffer(length + offset),
+        BYTE   = this.BYTE,
+        mask, i;
+
+    frame[0] = this.FIN | opcode;
+
+    if (length <= 125) {
+      frame[1] = masked | length;
+    } else if (length <= 65535) {
+      frame[1] = masked | 126;
+      frame[2] = ~~(length / 256);
+      frame[3] = length & BYTE;
+    } else {
+      frame[1] = masked | 127;
+      frame[2] = ~~(length / Math.pow(2, 56)) & BYTE;
+      frame[3] = ~~(length / Math.pow(2, 48)) & BYTE;
+      frame[4] = ~~(length / Math.pow(2, 40)) & BYTE;
+      frame[5] = ~~(length / Math.pow(2, 32)) & BYTE;
+      frame[6] = ~~(length / Math.pow(2, 24)) & BYTE;
+      frame[7] = ~~(length / Math.pow(2, 16)) & BYTE;
+      frame[8] = ~~(length / Math.pow(2, 8))  & BYTE;
+      frame[9] = length & BYTE;
+    }
+
+    if (code) {
+      frame[offset]     = ~~(code / 256) & BYTE;
+      frame[offset + 1] = code & BYTE;
+    }
+    buffer.copy(frame, offset + insert);
+
+    if (this._masking) {
+      mask = [~~(Math.random() * 256), ~~(Math.random() * 256),
+              ~~(Math.random() * 256), ~~(Math.random() * 256)];
+      new Buffer(mask).copy(frame, header);
+      Mask.mask(frame, mask, offset);
+    }
+
+    this._write(frame);
    return true;
  },

-  parse: function(chunk) {
-    this._reader.put(chunk);
-    var buffer = true;
-    while (buffer) {
-      switch (this._stage) {
-        case 0:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseOpcode(buffer[0]);
-          break;
-
-        case 1:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseLength(buffer[0]);
-          break;
-
-        case 2:
-          buffer = this._reader.read(this._frame.lengthBytes);
-          if (buffer) this._parseExtendedLength(buffer);
-          break;
-
-        case 3:
-          buffer = this._reader.read(4);
-          if (buffer) {
-            this._stage = 4;
-            this._frame.maskingKey = buffer;
-          }
-          break;
-
-        case 4:
-          buffer = this._reader.read(this._frame.length);
-          if (buffer) {
-            this._stage = 0;
-            this._emitFrame(buffer);
-          }
-          break;
-
-        default:
-          buffer = null;
-      }
-    }
-  },
-
  text: function(message) {
-    if (this.readyState > 1) return false;
    return this.frame(message, 'text');
  },

  binary: function(message) {
-    if (this.readyState > 1) return false;
    return this.frame(message, 'binary');
  },

  ping: function(message, callback) {
-    if (this.readyState > 1) return false;
    message = message || '';
    if (callback) this._pingCallbacks[message] = callback;
    return this.frame(message, 'ping');
  },

-  pong: function(message) {
-      if (this.readyState > 1) return false;
-      message = message ||'';
-      return this.frame(message, 'pong');
-  },
-
  close: function(reason, code) {
    reason = reason || '';
    code   = code   || this.ERRORS.normal_closure;

-    if (this.readyState <= 0) {
+    if (this.readyState === 0) {
      this.readyState = 3;
      this.emit('close', new Base.CloseEvent(code, reason));
      return true;
    } else if (this.readyState === 1) {
+      this.frame(reason, 'close', code);
      this.readyState = 2;
-      this._extensions.close(function() { this.frame(reason, 'close', code) }, this);
      return true;
    } else {
      return false;
    }
  },

-  frame: function(buffer, type, code) {
-    if (this.readyState <= 0) return this._queue([buffer, type, code]);
-    if (this.readyState > 2) return false;
-
-    if (buffer instanceof Array)    buffer = Buffer.from(buffer);
-    if (typeof buffer === 'number') buffer = buffer.toString();
-
-    var message = new Message(),
-        isText  = (typeof buffer === 'string'),
-        payload, copy;
-
-    message.rsv1   = message.rsv2 = message.rsv3 = false;
-    message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
-
-    payload = isText ? Buffer.from(buffer, 'utf8') : buffer;
-
-    if (code) {
-      copy = payload;
-      payload = Buffer.allocUnsafe(2 + copy.length);
-      payload.writeUInt16BE(code, 0);
-      copy.copy(payload, 2);
-    }
-    message.data = payload;
-
-    var onMessageReady = function(message) {
-      var frame = new Frame();
-
-      frame.final   = true;
-      frame.rsv1    = message.rsv1;
-      frame.rsv2    = message.rsv2;
-      frame.rsv3    = message.rsv3;
-      frame.opcode  = message.opcode;
-      frame.masked  = !!this._masking;
-      frame.length  = message.data.length;
-      frame.payload = message.data;
-
-      if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
-
-      this._sendFrame(frame);
-    };
-
-    if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
-      this._extensions.processOutgoingMessage(message, function(error, message) {
-        if (error) return this._fail('extension_error', error.message);
-        onMessageReady.call(this, message);
-      }, this);
-    else
-      onMessageReady.call(this, message);
-
-    return true;
-  },
-
-  _sendFrame: function(frame) {
-    var length = frame.length,
-        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
-        offset = header + (frame.masked ? 4 : 0),
-        buffer = Buffer.allocUnsafe(offset + length),
-        masked = frame.masked ? this.MASK : 0;
-
-    buffer[0] = (frame.final ? this.FIN : 0) |
-                (frame.rsv1 ? this.RSV1 : 0) |
-                (frame.rsv2 ? this.RSV2 : 0) |
-                (frame.rsv3 ? this.RSV3 : 0) |
-                frame.opcode;
-
-    if (length <= 125) {
-      buffer[1] = masked | length;
-    } else if (length <= 65535) {
-      buffer[1] = masked | 126;
-      buffer.writeUInt16BE(length, 2);
-    } else {
-      buffer[1] = masked | 127;
-      buffer.writeUInt32BE(Math.floor(length / 0x100000000), 2);
-      buffer.writeUInt32BE(length % 0x100000000, 6);
-    }
-
-    frame.payload.copy(buffer, offset);
-
-    if (frame.masked) {
-      frame.maskingKey.copy(buffer, header);
-      Hybi.mask(buffer, frame.maskingKey, offset);
-    }
-
-    this._write(buffer);
-  },
-
  _handshakeResponse: function() {
-    var secKey  = this._request.headers['sec-websocket-key'],
-        version = this._request.headers['sec-websocket-version'];
+    var secKey = this._request.headers['sec-websocket-key'];
+    if (!secKey) return '';

-    if (version !== Hybi.VERSION)
-      throw new Error('Unsupported WebSocket version: ' + version);
+    var accept    = Hybi.generateAccept(secKey),
+        offers    = Base.parseHeader(this._request.headers['sec-websocket-extensions']),
+        protos    = this._request.headers['sec-websocket-protocol'],
+        supported = this._protocols,
+        proto,

-    if (typeof secKey !== 'string')
-      throw new Error('Missing handshake request header: Sec-WebSocket-Key');
+        headers = [
+          'HTTP/1.1 101 Switching Protocols',
+          'Upgrade: websocket',
+          'Connection: Upgrade',
+          'Sec-WebSocket-Accept: ' + accept
+        ];

-    this._headers.set('Upgrade', 'websocket');
-    this._headers.set('Connection', 'Upgrade');
-    this._headers.set('Sec-WebSocket-Accept', Hybi.generateAccept(secKey));
+    if (protos !== undefined) {
+      if (typeof protos === 'string') protos = protos.split(/\s*,\s*/);
+      proto = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
+      if (proto) {
+        this.protocol = proto;
+        headers.push('Sec-WebSocket-Protocol: ' + proto);
+      }
+    }

-    if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
+    // TODO: implement a selection procedure for extensions
+    // see http://tools.ietf.org/html/draft-ietf-hybi-permessage-compression-17#section-5
+    var extensions = offers.map(function(offer) {
+      var ext = this._extensions[offer.name];
+      return ext && ext.createSession(offer.params);
+    }, this).filter(function(k) {
+      return k;
+    });

-    var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
-    if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions);
+    if (extensions.length > 0) {
+      extensions = extensions.map(function(e) { return e.responseHeader() });
+      headers.push('Sec-WebSocket-Extensions: ' + extensions.join(', '));
+    }

-    var start   = 'HTTP/1.1 101 Switching Protocols',
-        headers = [start, this._headers.toString(), ''];
-
-    return Buffer.from(headers.join('\r\n'), 'utf8');
+    return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
  },

-  _shutdown: function(code, reason, error) {
-    delete this._frame;
-    delete this._message;
-    this._stage = 5;
-
-    var sendCloseFrame = (this.readyState === 1);
-    this.readyState = 2;
-
-    this._extensions.close(function() {
-      if (sendCloseFrame) this.frame(reason, 'close', code);
-      this.readyState = 3;
-      if (error) this.emit('error', new Error(reason));
-      this.emit('close', new Base.CloseEvent(code, reason));
-    }, this);
+  _shutdown: function(code, reason) {
+    this.frame(reason, 'close', code);
+    this.readyState = 3;
+    this._reader.end();
+    this.emit('close', new Base.CloseEvent(code, reason));
  },

  _fail: function(type, message) {
-    if (this.readyState > 1) return;
-    this._shutdown(this.ERRORS[type], message, true);
+    this.emit('error', new Error(message));
+    this._shutdown(this.ERRORS[type], message);
  },

-  _parseOpcode: function(octet) {
+  _parseOpcode: function(buffer) {
+    var data = buffer[0];
+
    var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
-      return (octet & rsv) === rsv;
+      return (data & rsv) === rsv;
    });

-    var frame = this._frame = new Frame();
-
-    frame.final  = (octet & this.FIN) === this.FIN;
-    frame.rsv1   = rsvs[0];
-    frame.rsv2   = rsvs[1];
-    frame.rsv3   = rsvs[2];
-    frame.opcode = (octet & this.OPCODE);
-
-    this._stage = 1;
-
-    if (!this._extensions.validFrameRsv(frame))
+    if (rsvs.filter(function(rsv) { return rsv }).length > 0)
      return this._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 = ' + (rsvs[0] ? 1 : 0) +
+          ', reserved2 = ' + (rsvs[1] ? 1 : 0) +
+          ', reserved3 = ' + (rsvs[2] ? 1 : 0));

-    if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
-      return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.opcode);
+    this._final  = (data & this.FIN) === this.FIN;
+    this._opcode = (data & this.OPCODE);
+    this._mask   = null;

-    if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
-      return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode);
+    if (this.OPCODE_CODES.indexOf(this._opcode) < 0)
+      return this._fail('protocol_error', 'Unrecognized frame opcode: ' + this._opcode);

-    if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
+    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && !this._final)
+      return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + this._opcode);
+
+    if (this._mode && this.OPENING_OPCODES.indexOf(this._opcode) >= 0)
      return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
+
+    this._reader.read(1, this._parseLength);
  },

-  _parseLength: function(octet) {
-    var frame = this._frame;
-    frame.masked = (octet & this.MASK) === this.MASK;
-    frame.length = (octet & this.LENGTH);
+  _parseLength: function(buffer) {
+    var data = buffer[0];

-    if (frame.length >= 0 && frame.length <= 125) {
-      this._stage = frame.masked ? 3 : 4;
-      if (!this._checkFrameLength()) return;
-    } else {
-      this._stage = 2;
-      frame.lengthBytes = (frame.length === 126 ? 2 : 8);
-    }
-
-    if (this._requireMasking && !frame.masked)
+    this._masked = (data & this.MASK) === this.MASK;
+    if (this._requireMasking && !this._masked)
      return this._fail('unacceptable', 'Received unmasked frame but masking is required');
+
+    this._length = (data & this.LENGTH);
+
+    if (this._length >= 0 && this._length <= 125) {
+      if (!this._checkFrameLength()) return;
+      this._readMask();
+    } else {
+      var lengthSize = (this._length === 126 ? 2 : 8);
+      this._reader.read(lengthSize, this._parseExtendedLength);
+    }
  },

  _parseExtendedLength: function(buffer) {
-    var frame = this._frame;
-    frame.length = this._readUInt(buffer);
+    this._length = this._getInteger(buffer);

-    this._stage = frame.masked ? 3 : 4;
-
-    if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
-      return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length);
+    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && this._length > 125)
+      return this._fail('protocol_error', 'Received control frame having too long payload: ' + this._length);

    if (!this._checkFrameLength()) return;
+
+    this._readMask();
  },

  _checkFrameLength: function() {
-    var length = this._message ? this._message.length : 0;
-
-    if (length + this._frame.length > this._maxLength) {
+    if (this.__blength + this._length > this._maxLength) {
      this._fail('too_large', 'WebSocket frame length too large');
      return false;
    } else {
@@ -387,32 +292,64 @@ var instance = {
    }
  },

-  _emitFrame: function(buffer) {
-    var frame   = this._frame,
-        payload = frame.payload = Hybi.mask(buffer, frame.maskingKey),
-        opcode  = frame.opcode,
-        message,
-        code, reason,
-        callbacks, callback;
+  _readMask: function() {
+    if (this._masked)
+      this._reader.read(4, function(buffer) {
+        this._mask = new Mask(buffer);
+        this._readPayload();
+      });
+    else
+      this._readPayload();
+  },

-    delete this._frame;
+  _readPayload: function() {
+    var stream = this._reader.fork(this._length);
+    if (this._mask) {
+      stream.pipe(this._mask);
+      stream = this._mask;
+    }
+    stream.pipe(new Concat(this._emitFrame, this));
+  },
+
+  _emitFrame: function(payload) {
+    var opcode = this._opcode;

    if (opcode === this.OPCODES.continuation) {
-      if (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
-      this._message.pushFrame(frame);
+      if (!this._mode) return this._fail('protocol_error', 'Received unexpected continuation frame');
+      this._buffer(payload);
+      if (this._final) {
+        var message = Concat.concatBuffers(this.__buffer, this.__blength);
+        if (this._mode === 'text') message = this._encode(message);
+        this._reset();
+        if (message === null)
+          this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
+        else
+          this.emit('message', new Base.MessageEvent(message));
+      }
    }
-
-    if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
-      this._message = new Message();
-      this._message.pushFrame(frame);
+    else if (opcode === this.OPCODES.text) {
+      if (this._final) {
+        var message = this._encode(payload);
+        if (message === null)
+          this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
+        else
+          this.emit('message', new Base.MessageEvent(message));
+      } else {
+        this._mode = 'text';
+        this._buffer(payload);
+      }
    }
-
-    if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
-      return this._emitMessage(this._message);
-
-    if (opcode === this.OPCODES.close) {
-      code   = (payload.length >= 2) ? payload.readUInt16BE(0) : null;
-      reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
+    else if (opcode === this.OPCODES.binary) {
+      if (this._final) {
+        this.emit('message', new Base.MessageEvent(payload));
+      } else {
+        this._mode = 'binary';
+        this._buffer(payload);
+      }
+    }
+    else if (opcode === this.OPCODES.close) {
+      var code   = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null,
+          reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;

      if (!(payload.length === 0) &&
          !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
@@ -422,43 +359,32 @@ var instance = {
      if (payload.length > 125 || (payload.length > 2 && !reason))
        code = this.ERRORS.protocol_error;

-      this._shutdown(code || this.DEFAULT_ERROR_CODE, reason || '');
+      this._shutdown(code, reason || '');
    }
-
-    if (opcode === this.OPCODES.ping) {
+    else if (opcode === this.OPCODES.ping) {
      this.frame(payload, 'pong');
-      this.emit('ping', new Base.PingEvent(payload.toString()))
    }
-
-    if (opcode === this.OPCODES.pong) {
-      callbacks = this._pingCallbacks;
-      message   = this._encode(payload);
-      callback  = callbacks[message];
+    else if (opcode === this.OPCODES.pong) {
+      var callbacks = this._pingCallbacks,
+          message   = this._encode(payload),
+          callback  = callbacks[message];

      delete callbacks[message];
      if (callback) callback()
-
-      this.emit('pong', new Base.PongEvent(payload.toString()))
    }
+
+    this._reader.read(1, this._parseOpcode);
  },

-  _emitMessage: function(message) {
-    var message = this._message;
-    message.read();
+  _buffer: function(fragment) {
+    this.__buffer.push(fragment);
+    this.__blength += fragment.length;
+  },

-    delete this._message;
-
-    this._extensions.processIncomingMessage(message, function(error, message) {
-      if (error) return this._fail('extension_error', error.message);
-
-      var payload = message.data;
-      if (message.opcode === this.OPCODES.text) payload = this._encode(payload);
-
-      if (payload === null)
-        return this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
-      else
-        this.emit('message', new Base.MessageEvent(payload));
-    }, this);
+  _reset: function() {
+    this._mode     = null;
+    this.__buffer  = [];
+    this.__blength = 0;
  },

  _encode: function(buffer) {
@@ -469,11 +395,11 @@ var instance = {
    return buffer.toString('utf8', 0, buffer.length);
  },

-  _readUInt: function(buffer) {
-    if (buffer.length === 2) return buffer.readUInt16BE(0);
-
-    return buffer.readUInt32BE(0) * 0x100000000 +
-           buffer.readUInt32BE(4);
+  _getInteger: function(bytes) {
+    var number = 0;
+    for (var i = 0, n = bytes.length; i < n; i++)
+      number += bytes[i] * this.TWO_POWERS[n - 1 - i];
+    return number;
  }
 };

@@ -481,3 +407,4 @@ for (var key in instance)
  Hybi.prototype[key] = instance[key];

 module.exports = Hybi;
+
@@ -0,0 +1,45 @@
+var Stream = require('stream').Stream,
+    util   = require('util');
+
+var Concat = function(callback, context) {
+  this._callback = callback;
+  this._context  = context;
+  this._chunks   = [];
+  this._size     = 0;
+  this.writable  = true;
+};
+util.inherits(Concat, Stream);
+
+Concat.prototype.write = function(buffer) {
+  if (!this.writable) return false;
+  this._chunks.push(buffer);
+  this._size += buffer.length;
+  return true;
+};
+
+Concat.prototype.end = function(buffer) {
+  if (buffer) this.write(buffer);
+  this.writable = false;
+  this._callback.call(this._context, Concat.concatBuffers(this._chunks, this._size));
+};
+
+Concat.concatBuffers = function(chunks, size) {
+  if (size === undefined) {
+    size = 0;
+    var c = chunks.length;
+    while (c--) size += chunks[c].length;
+  }
+
+  var concat = new Buffer(size),
+      offset = 0;
+
+  for (var i = 0, n = chunks.length; i < n; i++) {
+    chunks[i].copy(concat, offset);
+    offset += chunks[i].length;
+  }
+  return concat;
+};
+
+Concat.prototype.destroy = function() {};
+
+module.exports = Concat;
@@ -1,21 +0,0 @@
-'use strict';
-
-var Frame = function() {};
-
-var instance = {
-  final:        false,
-  rsv1:         false,
-  rsv2:         false,
-  rsv3:         false,
-  opcode:       null,
-  masked:       false,
-  maskingKey:   null,
-  lengthBytes:  1,
-  length:       0,
-  payload:      null
-};
-
-for (var key in instance)
-  Frame.prototype[key] = instance[key];
-
-module.exports = Frame;
@@ -0,0 +1,43 @@
+var Stream = require('stream').Stream,
+    util   = require('util');
+
+var Mask = function(bytes) {
+  this.readable = this.writable = true;
+
+  this._bytes = bytes;
+  this._index = 0;
+};
+util.inherits(Mask, Stream);
+
+Mask.mask = function(payload, mask, offset, index) {
+  offset = offset || 0;
+  index  = index  || 0;
+
+  for (var i = 0, n = payload.length - offset; i < n; i++)
+    payload[offset + i] ^= mask[(index + i) % 4];
+};
+
+Mask.prototype.write = function(chunk) {
+  Mask.mask(chunk, this._bytes, 0, this._index);
+  this._index = (this._index + chunk.length) % 4;
+  this.emit('data', chunk);
+  return !this._paused;
+};
+
+Mask.prototype.end = function(chunk) {
+  if (chunk) this.write(chunk);
+  this.readable = this.writable = false;
+  this.emit('end');
+};
+
+Mask.prototype.pause = function() {
+  this._paused = true;
+};
+
+Mask.prototype.resume = function() {
+  this._paused = false;
+  this.emit('drain');
+};
+
+module.exports = Mask;
+
@@ -1,34 +0,0 @@
-'use strict';
-
-var Buffer = require('safe-buffer').Buffer;
-
-var Message = function() {
-  this.rsv1    = false;
-  this.rsv2    = false;
-  this.rsv3    = false;
-  this.opcode  = null;
-  this.length  = 0;
-  this._chunks = [];
-};
-
-var instance = {
-  read: function() {
-    return this.data = this.data || Buffer.concat(this._chunks, this.length);
-  },
-
-  pushFrame: function(frame) {
-    this.rsv1 = this.rsv1 || frame.rsv1;
-    this.rsv2 = this.rsv2 || frame.rsv2;
-    this.rsv3 = this.rsv3 || frame.rsv3;
-
-    if (this.opcode === null) this.opcode = frame.opcode;
-
-    this._chunks.push(frame.payload);
-    this.length += frame.length;
-  }
-};
-
-for (var key in instance)
-  Message.prototype[key] = instance[key];
-
-module.exports = Message;
@@ -0,0 +1,138 @@
+var Stream = require('stream').Stream,
+    Concat = require('./concat'),
+    util   = require('util');
+
+var defer = (typeof setImmediate === 'function')
+          ? setImmediate
+          : process.nextTick;
+
+var StreamReader = function(options, parent) {
+  this.readable   = !!parent;
+  this.writable   = !parent;
+  this._streams   = [];
+  this._context   = options.context;
+  this._parent    = parent;
+  this._queue     = [];
+  this._queueSize = 0;
+  this._cursor    = 0;
+};
+util.inherits(StreamReader, Stream);
+
+StreamReader.prototype.write = function(buffer) {
+  if (!this.writable) return false;
+  if (!buffer || buffer.length === 0) return !this._paused;
+
+  if (!buffer.copy) buffer = new Buffer(buffer);
+
+  this._queue.push(buffer);
+  this._queueSize += buffer.length;
+  this._flush();
+
+  return !this._paused;
+};
+
+StreamReader.prototype.end = function(buffer) {
+  if (buffer) this.write(buffer);
+  this.writable = false;
+
+  for (var i = 0, n = this._streams.length; i < n; i++) {
+    this._streams[i].emit('end');
+    this._streams[i].readable = false;
+  }
+
+  this._context = this._streams = this._queue = [];
+};
+
+StreamReader.prototype.pause = function() {
+  this._paused = true;
+  if (this._parent) this._parent.pause();
+};
+
+StreamReader.prototype.resume = function() {
+  this._paused = false;
+  this.emit('drain');
+  if (this._parent) this._parent.resume();
+};
+
+StreamReader.prototype.fork = function(length) {
+  if (!this.writable) return null;
+
+  var stream = new StreamReader({context: this._context}, this),
+      self   = this;
+
+  stream._remaining = length;
+  this._streams.push(stream);
+  defer(function() { self._flush() });
+
+  return stream;
+};
+
+StreamReader.prototype.read = function(length, callback) {
+  if (!this.writable) return;
+
+  if (this._queueSize >= length)
+    return callback.call(this._context, this._readBytes(length));
+
+  this.fork(length).pipe(new Concat(callback, this._context));
+};
+
+StreamReader.prototype._flush = function() {
+  var streams = this._streams, stream, size, buffer;
+
+  while (streams.length > 0) {
+    stream = streams[0];
+    size   = Math.min(stream._remaining, this._queueSize);
+    buffer = this._readBytes(size);
+
+    if (size > 0) stream.emit('data', buffer);
+    stream._remaining -= size;
+
+    if (stream._remaining > 0) break;
+
+    stream.readable = false;
+    stream.emit('end');
+    streams.shift();
+  }
+};
+
+StreamReader.prototype._readBytes = function(length) {
+  var queue  = this._queue,
+      remain = length,
+      n      = queue.length,
+      first  = queue[0],
+      i      = 0,
+      buffer, chunk, size;
+
+  if (length === 0) return new Buffer(0);
+
+  if (remain <= first.length - this._cursor) {
+    buffer = first.slice(this._cursor, this._cursor + remain);
+
+    this._queueSize -= remain;
+    this._cursor     = (this._cursor + remain) % first.length;
+    if (this._cursor === 0) this._queue.shift();
+
+    return buffer;
+  }
+
+  buffer = new Buffer(length);
+
+  while (remain > 0 && i < n) {
+    chunk = queue[i];
+    size  = Math.min(remain, chunk.length - this._cursor);
+
+    chunk.copy(buffer, length - remain, this._cursor, this._cursor + size);
+
+    remain          -= size;
+    this._queueSize -= size;
+    this._cursor     = (this._cursor + size) % chunk.length;
+
+    i += 1;
+  }
+
+  queue.splice(0, this._cursor === 0 ? i : i - 1);
+
+  return buffer;
+};
+
+module.exports = StreamReader;
@@ -1,99 +0,0 @@
-'use strict';
-
-var Buffer     = require('safe-buffer').Buffer,
-    Stream     = require('stream').Stream,
-    url        = require('url'),
-    util       = require('util'),
-    Base       = require('./base'),
-    Headers    = require('./headers'),
-    HttpParser = require('../http_parser');
-
-var PORTS = { 'ws:': 80, 'wss:': 443 };
-
-var Proxy = function(client, origin, options) {
-  this._client  = client;
-  this._http    = new HttpParser('response');
-  this._origin  = (typeof client.url === 'object') ? client.url : url.parse(client.url);
-  this._url     = (typeof origin === 'object') ? origin : url.parse(origin);
-  this._options = options || {};
-  this._state   = 0;
-
-  this.readable = this.writable = true;
-  this._paused  = false;
-
-  this._headers = new Headers();
-  this._headers.set('Host', this._origin.host);
-  this._headers.set('Connection', 'keep-alive');
-  this._headers.set('Proxy-Connection', 'keep-alive');
-
-  var auth = this._url.auth && Buffer.from(this._url.auth, 'utf8').toString('base64');
-  if (auth) this._headers.set('Proxy-Authorization', 'Basic ' + auth);
-};
-util.inherits(Proxy, Stream);
-
-var instance = {
-  setHeader: function(name, value) {
-    if (this._state !== 0) return false;
-    this._headers.set(name, value);
-    return true;
-  },
-
-  start: function() {
-    if (this._state !== 0) return false;
-    this._state = 1;
-
-    var origin = this._origin,
-        port   = origin.port || PORTS[origin.protocol],
-        start  = 'CONNECT ' + origin.hostname + ':' + port + ' HTTP/1.1';
-
-    var headers = [start, this._headers.toString(), ''];
-
-    this.emit('data', Buffer.from(headers.join('\r\n'), 'utf8'));
-    return true;
-  },
-
-  pause: function() {
-    this._paused = true;
-  },
-
-  resume: function() {
-    this._paused = false;
-    this.emit('drain');
-  },
-
-  write: function(chunk) {
-    if (!this.writable) return false;
-
-    this._http.parse(chunk);
-    if (!this._http.isComplete()) return !this._paused;
-
-    this.statusCode = this._http.statusCode;
-    this.headers    = this._http.headers;
-
-    if (this.statusCode === 200) {
-      this.emit('connect', new Base.ConnectEvent());
-    } else {
-      var message = "Can't establish a connection to the server at " + this._origin.href;
-      this.emit('error', new Error(message));
-    }
-    this.end();
-    return !this._paused;
-  },
-
-  end: function(chunk) {
-    if (!this.writable) return;
-    if (chunk !== undefined) this.write(chunk);
-    this.readable = this.writable = false;
-    this.emit('close');
-    this.emit('end');
-  },
-
-  destroy: function() {
-    this.end();
-  }
-};
-
-for (var key in instance)
-  Proxy.prototype[key] = instance[key];
-
-module.exports = Proxy;
@@ -1,7 +1,5 @@
-'use strict';
-
 var util       = require('util'),
-    HttpParser = require('../http_parser'),
+    HttpParser = require('./http_parser'),
    Base       = require('./base'),
    Draft75    = require('./draft75'),
    Draft76    = require('./draft76'),
@@ -14,17 +12,17 @@ var Server = function(options) {
 util.inherits(Server, Base);

 var instance = {
-  EVENTS: ['open', 'message', 'error', 'close', 'ping', 'pong'],
+  EVENTS: ['open', 'message', 'error', 'close'],

  _bindEventListeners: function() {
    this.messages.on('error', function() {});
    this.on('error', function() {});
  },

-  parse: function(chunk) {
-    if (this._delegate) return this._delegate.parse(chunk);
+  parse: function(data) {
+    if (this._delegate) return this._delegate.parse(data);

-    this._http.parse(chunk);
+    this._http.parse(data);
    if (!this._http.isComplete()) return;

    this.method  = this._http.method;
@@ -36,15 +34,13 @@ var instance = {
    this._delegate = Server.http(this, this._options);
    this._delegate.messages = this.messages;
    this._delegate.io = this.io;
-    this._open();
+    this._delegate._extensions = this._extensions;

+    this._delegate.on('open', function() { self._open() });
    this.EVENTS.forEach(function(event) {
      this._delegate.on(event, function(e) { self.emit(event, e) });
    }, this);

-    this.protocol = this._delegate.protocol;
-    this.version  = this._delegate.version;
-
    this.parse(this._http.body);
    this.emit('connect', new Base.ConnectEvent());
  },
@@ -57,7 +53,7 @@ var instance = {
  }
 };

-['addExtension', 'setHeader', 'start', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
+['setHeader', 'start', 'state', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
  instance[method] = function() {
    if (this._delegate) {
      return this._delegate[method].apply(this._delegate, arguments);
@@ -95,18 +91,15 @@ Server.http = function(request, options) {
  if (options.requireMasking === undefined) options.requireMasking = true;

  var headers = request.headers,
-      version = headers['sec-websocket-version'],
-      key     = headers['sec-websocket-key'],
-      key1    = headers['sec-websocket-key1'],
-      key2    = headers['sec-websocket-key2'],
      url     = this.determineUrl(request);

-  if (version || key)
+  if (headers['sec-websocket-version'])
    return new Hybi(request, url, options);
-  else if (key1 || key2)
+  else if (headers['sec-websocket-key1'])
    return new Draft76(request, url, options);
  else
    return new Draft75(request, url, options);
 };

 module.exports = Server;
+
@@ -1,69 +0,0 @@
-'use strict';
-
-var Buffer = require('safe-buffer').Buffer;
-
-var StreamReader = function() {
-  this._queue     = [];
-  this._queueSize = 0;
-  this._offset    = 0;
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!Buffer.isBuffer(buffer)) buffer = Buffer.from(buffer);
-  this._queue.push(buffer);
-  this._queueSize += buffer.length;
-};
-
-StreamReader.prototype.read = function(length) {
-  if (length > this._queueSize) return null;
-  if (length === 0) return Buffer.alloc(0);
-
-  this._queueSize -= length;
-
-  var queue  = this._queue,
-      remain = length,
-      first  = queue[0],
-      buffers, buffer;
-
-  if (first.length >= length) {
-    if (first.length === length) {
-      return queue.shift();
-    } else {
-      buffer = first.slice(0, length);
-      queue[0] = first.slice(length);
-      return buffer;
-    }
-  }
-
-  for (var i = 0, n = queue.length; i < n; i++) {
-    if (remain < queue[i].length) break;
-    remain -= queue[i].length;
-  }
-  buffers = queue.splice(0, i);
-
-  if (remain > 0 && queue.length > 0) {
-    buffers.push(queue[0].slice(0, remain));
-    queue[0] = queue[0].slice(remain);
-  }
-  return Buffer.concat(buffers, length);
-};
-
-StreamReader.prototype.eachByte = function(callback, context) {
-  var buffer, n, index;
-
-  while (this._queue.length > 0) {
-    buffer = this._queue[0];
-    n = buffer.length;
-
-    while (this._offset < n) {
-      index = this._offset;
-      this._offset += 1;
-      callback.call(context, buffer[index]);
-    }
-    this._offset = 0;
-    this._queue.shift();
-  }
-};
-
-module.exports = StreamReader;
@@ -0,0 +1,22 @@
+var PerMessageDeflate = function() {
+  this.name = 'permessage-deflate';
+};
+
+PerMessageDeflate.create = function() {
+  return new this();
+};
+
+PerMessageDeflate.prototype.createSession = function(params) {
+  return new Session(this, params);
+};
+
+var Session = function(extension, params) {
+  this._ext    = extension;
+  this._params = params;
+};
+
+Session.prototype.responseHeader = function() {
+  return this._ext.name;
+};
+
+module.exports = PerMessageDeflate;
@@ -1,135 +0,0 @@
-'use strict';
-
-var NodeHTTPParser = require('http-parser-js').HTTPParser,
-    Buffer         = require('safe-buffer').Buffer;
-
-var TYPES = {
-  request:  NodeHTTPParser.REQUEST  || 'request',
-  response: NodeHTTPParser.RESPONSE || 'response'
-};
-
-var HttpParser = function(type) {
-  this._type     = type;
-  this._parser   = new NodeHTTPParser(TYPES[type]);
-  this._complete = false;
-  this.headers   = {};
-
-  var current = null,
-      self    = this;
-
-  this._parser.onHeaderField = function(b, start, length) {
-    current = b.toString('utf8', start, start + length).toLowerCase();
-  };
-
-  this._parser.onHeaderValue = function(b, start, length) {
-    var value = b.toString('utf8', start, start + length);
-
-    if (self.headers.hasOwnProperty(current))
-      self.headers[current] += ', ' + value;
-    else
-      self.headers[current] = value;
-  };
-
-  this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] =
-  function(majorVersion, minorVersion, headers, method, pathname, statusCode) {
-    var info = arguments[0];
-
-    if (typeof info === 'object') {
-      method     = info.method;
-      pathname   = info.url;
-      statusCode = info.statusCode;
-      headers    = info.headers;
-    }
-
-    self.method     = (typeof method === 'number') ? HttpParser.METHODS[method] : method;
-    self.statusCode = statusCode;
-    self.url        = pathname;
-
-    if (!headers) return;
-
-    for (var i = 0, n = headers.length, key, value; i < n; i += 2) {
-      key   = headers[i].toLowerCase();
-      value = headers[i+1];
-      if (self.headers.hasOwnProperty(key))
-        self.headers[key] += ', ' + value;
-      else
-        self.headers[key] = value;
-    }
-
-    self._complete = true;
-  };
-};
-
-HttpParser.METHODS = {
-  0:  'DELETE',
-  1:  'GET',
-  2:  'HEAD',
-  3:  'POST',
-  4:  'PUT',
-  5:  'CONNECT',
-  6:  'OPTIONS',
-  7:  'TRACE',
-  8:  'COPY',
-  9:  'LOCK',
-  10: 'MKCOL',
-  11: 'MOVE',
-  12: 'PROPFIND',
-  13: 'PROPPATCH',
-  14: 'SEARCH',
-  15: 'UNLOCK',
-  16: 'BIND',
-  17: 'REBIND',
-  18: 'UNBIND',
-  19: 'ACL',
-  20: 'REPORT',
-  21: 'MKACTIVITY',
-  22: 'CHECKOUT',
-  23: 'MERGE',
-  24: 'M-SEARCH',
-  25: 'NOTIFY',
-  26: 'SUBSCRIBE',
-  27: 'UNSUBSCRIBE',
-  28: 'PATCH',
-  29: 'PURGE',
-  30: 'MKCALENDAR',
-  31: 'LINK',
-  32: 'UNLINK'
-};
-
-var VERSION = process.version
-  ? process.version.match(/[0-9]+/g).map(function(n) { return parseInt(n, 10) })
-  : [];
-
-if (VERSION[0] === 0 && VERSION[1] === 12) {
-  HttpParser.METHODS[16] = 'REPORT';
-  HttpParser.METHODS[17] = 'MKACTIVITY';
-  HttpParser.METHODS[18] = 'CHECKOUT';
-  HttpParser.METHODS[19] = 'MERGE';
-  HttpParser.METHODS[20] = 'M-SEARCH';
-  HttpParser.METHODS[21] = 'NOTIFY';
-  HttpParser.METHODS[22] = 'SUBSCRIBE';
-  HttpParser.METHODS[23] = 'UNSUBSCRIBE';
-  HttpParser.METHODS[24] = 'PATCH';
-  HttpParser.METHODS[25] = 'PURGE';
-}
-
-HttpParser.prototype.isComplete = function() {
-  return this._complete;
-};
-
-HttpParser.prototype.parse = function(chunk) {
-  var consumed = this._parser.execute(chunk, 0, chunk.length);
-
-  if (typeof consumed !== 'number') {
-    this.error     = consumed;
-    this._complete = true;
-    return;
-  }
-
-  if (this._complete)
-    this.body = (consumed < chunk.length)
-              ? chunk.slice(consumed)
-              : Buffer.alloc(0);
-};
-
-module.exports = HttpParser;
@@ -1,5 +1,3 @@
-'use strict';
-
 /**

 Streams in a WebSocket connection
@@ -126,8 +124,7 @@ Messages.prototype.resume = function() {
 // the source whether to back off.
 Messages.prototype.write = function(message) {
  if (!this.writable) return false;
-  if (typeof message === 'string') this._driver.text(message);
-  else this._driver.binary(message);
+  this._driver.frame(message);
  return !this._paused;
 };

@@ -144,3 +141,4 @@ Messages.prototype.destroy = function() {};

 exports.IO = IO;
 exports.Messages = Messages;
+
@@ -1,35 +1,21 @@
-{
-          "name": "websocket-driver",
-          "description": "WebSocket protocol handler with pluggable I/O",
-          "homepage": "https://github.com/faye/websocket-driver-node",
-          "author": "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)",
-          "keywords": [
-                    "websocket"
-          ],
-          "license": "Apache-2.0",
-          "version": "0.7.4",
-          "engines": {
-                    "node": ">=0.8.0"
-          },
-          "files": [
-                    "lib"
-          ],
-          "main": "./lib/websocket/driver",
-          "dependencies": {
-                    "http-parser-js": ">=0.5.1",
-                    "safe-buffer": ">=5.1.0",
-                    "websocket-extensions": ">=0.1.1"
-          },
-          "devDependencies": {
-                    "jstest": "*",
-                    "permessage-deflate": "*"
-          },
-          "scripts": {
-                    "test": "jstest spec/runner.js"
-          },
-          "repository": {
-                    "type": "git",
-                    "url": "git://github.com/faye/websocket-driver-node.git"
-          },
-          "bugs": "https://github.com/faye/websocket-driver-node/issues"
+{ "name"            : "websocket-driver"
+, "description"     : "WebSocket protocol handler with pluggable I/O"
+, "homepage"        : "http://github.com/faye/websocket-driver-node"
+, "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
+, "keywords"        : ["websocket"]
+, "license"         : "MIT"
+
+, "version"         : "0.3.4"
+, "engines"         : {"node": ">=0.4.0"}
+, "main"            : "./lib/websocket/driver"
+, "devDependencies" : {"jstest": ""}
+
+, "scripts"         : {"test": "jstest spec/runner.js"}
+
+, "repository"      : { "type"  : "git"
+                      , "url"   : "git://github.com/faye/websocket-driver-node.git"
+                      }
+
+, "bugs"            : "http://github.com/faye/websocket-driver-node/issues"
 }
+
@@ -1,10 +1,11 @@
-var Buffer = require('safe-buffer').Buffer,
-    test   = require('jstest').Test,
+var test   = require('jstest').Test,
    Stream = require('stream').Stream,
    util   = require('util')

 var BufferMatcher = function(data) {
-  this._data = Buffer.from(data)
+  this._data = (typeof data === 'string')
+             ? new Buffer(data, 'utf8')
+             : new Buffer(data)
 }
 BufferMatcher.prototype.equals = function(other) {
  if (this._data.length !== other.length) return false;
@@ -41,3 +42,4 @@ require('./websocket/driver/draft75_spec')
 require('./websocket/driver/draft76_spec')
 require('./websocket/driver/hybi_spec')
 require('./websocket/driver/client_spec')
+
@@ -1,10 +1,9 @@
 var Client = require("../../../lib/websocket/driver/client"),
-    Buffer = require('safe-buffer').Buffer,
    test   = require('jstest').Test

 test.describe("Client", function() { with(this) {
    define("options", function() {
-    return this._options = this._options || { protocols: this.protocols() }
+    return this._options = this._options || {protocols: this.protocols()}
  })

  define("protocols", function() {
@@ -51,14 +50,6 @@ test.describe("Client", function() { with(this) {
      assertEqual( null, driver().getState() )
    }})

-    describe("close", function() { with(this) {
-      it("changes the state to closed", function() { with(this) {
-        driver().close()
-        assertEqual( "closed", driver().getState() )
-        assertEqual( [1000, ''], close )
-      }})
-    }})
-
    describe("start", function() { with(this) {
      it("writes the handshake request to the socket", function() { with(this) {
        expect(driver().io, "emit").given("data", buffer(
@@ -110,16 +101,6 @@ test.describe("Client", function() { with(this) {
        }})
      }})

-      describe("with an invalid URL", function() { with(this) {
-        define("url", function() { return "stream.wikimedia.org/rc" })
-
-        it("throws an error", function() { with(this) {
-          var message
-          try { driver() } catch (e) { message = e.message }
-          assertEqual( "stream.wikimedia.org/rc is not a valid WebSocket URL", message )
-        }})
-      }})
-
      describe("with custom headers", function() { with(this) {
        before(function() { with(this) {
          driver().setHeader("User-Agent", "Chrome")
@@ -146,75 +127,14 @@ test.describe("Client", function() { with(this) {
    }})
  }})

-  describe("using a proxy", function() { with(this) {
-    it("sends a CONNECT request", function() { with(this) {
-      var proxy = driver().proxy("http://proxy.example.com")
-      expect(proxy, "emit").given("data", buffer(
-          "CONNECT www.example.com:80 HTTP/1.1\r\n" +
-          "Host: www.example.com\r\n" +
-          "Connection: keep-alive\r\n" +
-          "Proxy-Connection: keep-alive\r\n" +
-          "\r\n"))
-      proxy.start()
-    }})
-
-    it("sends an authenticated CONNECT request", function() { with(this) {
-      var proxy = driver().proxy("http://user:pass@proxy.example.com")
-      expect(proxy, "emit").given("data", buffer(
-          "CONNECT www.example.com:80 HTTP/1.1\r\n" +
-          "Host: www.example.com\r\n" +
-          "Connection: keep-alive\r\n" +
-          "Proxy-Connection: keep-alive\r\n" +
-          "Proxy-Authorization: Basic dXNlcjpwYXNz\r\n" +
-          "\r\n"))
-      proxy.start()
-    }})
-
-    it("sends a CONNECT request with custom headers", function() { with(this) {
-      var proxy = driver().proxy("http://user:pass@proxy.example.com")
-      proxy.setHeader("User-Agent", "Chrome")
-      expect(proxy, "emit").given("data", buffer(
-          "CONNECT www.example.com:80 HTTP/1.1\r\n" +
-          "Host: www.example.com\r\n" +
-          "Connection: keep-alive\r\n" +
-          "Proxy-Connection: keep-alive\r\n" +
-          "Proxy-Authorization: Basic dXNlcjpwYXNz\r\n" +
-          "User-Agent: Chrome\r\n" +
-          "\r\n"))
-      proxy.start()
-    }})
-
-    describe("receiving a response", function() { with(this) {
-      before(function() { with(this) {
-        this.proxy = driver().proxy("http://proxy.example.com")
-      }})
-
-      it("returns true when the response is written", function() { with(this) {
-        // this prevents downstream connections suddenly closing for no reason
-        assertEqual( true, proxy.write(Buffer.from("HTTP/1.1 200 OK\r\n\r\n")) )
-      }})
-
-      it("emits a 'connect' event when the proxy connects", function() { with(this) {
-        expect(proxy, "emit").given("connect", anything())
-        expect(proxy, "emit").given("close")
-        expect(proxy, "emit").given("end")
-        proxy.write(Buffer.from("HTTP/1.1 200 OK\r\n\r\n"))
-      }})
-
-      it("emits an 'error' event if the proxy does not connect", function() { with(this) {
-        expect(proxy, "emit").given("error", objectIncluding({ message: "Can't establish a connection to the server at ws://www.example.com/socket" }))
-        expect(proxy, "emit").given("close")
-        expect(proxy, "emit").given("end")
-        proxy.write(Buffer.from("HTTP/1.1 403 Forbidden\r\n\r\n"))
-      }})
-    }})
-  }})
-
  describe("in the connecting state", function() { with(this) {
    before(function() { this.driver().start() })

    describe("with a valid response", function() { with(this) {
-      before(function() { this.driver().parse(Buffer.from(this.response())) })
+      before(function(resume) { with(this) {
+        driver().parse(new Buffer(response()))
+        setTimeout(resume, 10)
+      }})

      it("changes the state to open", function() { with(this) {
        assertEqual( true, open )
@@ -232,11 +152,12 @@ test.describe("Client", function() { with(this) {
    }})

    describe("with a valid response followed by a frame", function() { with(this) {
-      before(function() { with(this) {
-        var resp = Buffer.alloc(response().length + 4)
-        Buffer.from(response()).copy(resp)
-        Buffer.from([0x81, 0x02, 72, 105]).copy(resp, resp.length - 4)
+      before(function(resume) { with(this) {
+        var resp = new Buffer(response().length + 4)
+        new Buffer(response()).copy(resp)
+        new Buffer([0x81, 0x02, 72, 105]).copy(resp, resp.length - 4)
        driver().parse(resp)
+        setTimeout(resume, 10)
      }})

      it("changes the state to open", function() { with(this) {
@@ -251,24 +172,26 @@ test.describe("Client", function() { with(this) {
    }})

    describe("with a bad status line", function() { with(this) {
-      before(function() {
-        var resp = this.response().replace(/101/g, "4")
-        this.driver().parse(Buffer.from(resp))
-      })
+      before(function(resume) { with(this) {
+        var resp = response().replace(/101/g, "4")
+        driver().parse(new Buffer(resp))
+        setTimeout(resume, 10)
+      }})

      it("changes the state to closed", function() { with(this) {
        assertEqual( false, open )
-        assertEqual( "Error during WebSocket handshake: Parse Error", error.message )
-        assertEqual( [1002, "Error during WebSocket handshake: Parse Error"], close )
+        assertEqual( "Error during WebSocket handshake: Unexpected response code: 4", error.message )
+        assertEqual( [1002, "Error during WebSocket handshake: Unexpected response code: 4"], close )
        assertEqual( "closed", driver().getState() )
      }})
    }})

    describe("with a bad Upgrade header", function() { with(this) {
-      before(function() {
-        var resp = this.response().replace(/websocket/g, "wrong")
-        this.driver().parse(Buffer.from(resp))
-      })
+      before(function(resume) { with(this) {
+        var resp = response().replace(/websocket/g, "wrong")
+        driver().parse(new Buffer(resp))
+        setTimeout(resume, 10)
+      }})

      it("changes the state to closed", function() { with(this) {
        assertEqual( false, open )
@@ -279,10 +202,11 @@ test.describe("Client", function() { with(this) {
    }})

    describe("with a bad Accept header", function() { with(this) {
-      before(function() {
-        var resp = this.response().replace(/QV3/g, "wrong")
-        this.driver().parse(Buffer.from(resp))
-      })
+      before(function(resume) { with(this) {
+        var resp = response().replace(/QV3/g, "wrong")
+        driver().parse(new Buffer(resp))
+        setTimeout(resume, 10)
+      }})

      it("changes the state to closed", function() { with(this) {
        assertEqual( false, open )
@@ -295,10 +219,11 @@ test.describe("Client", function() { with(this) {
    describe("with valid subprotocols", function() { with(this) {
      define("protocols", function() { return ["foo", "xmpp"] })

-      before(function() {
-        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: xmpp\r\n\r\n")
-        this.driver().parse(Buffer.from(resp))
-      })
+      before(function(resume) { with(this) {
+        var resp = response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: xmpp\r\n\r\n")
+        driver().parse(new Buffer(resp))
+        setTimeout(resume, 10)
+      }})

      it("changs the state to open", function() { with(this) {
        assertEqual( true, open )
@@ -314,10 +239,11 @@ test.describe("Client", function() { with(this) {
    describe("with invalid subprotocols", function() { with(this) {
      define("protocols", function() { return ["foo", "xmpp"] })

-      before(function() {
-        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: irc\r\n\r\n")
-        this.driver().parse(Buffer.from(resp))
-      })
+      before(function(resume) { with(this) {
+        var resp = response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: irc\r\n\r\n")
+        driver().parse(new Buffer(resp))
+        setTimeout(resume, 10)
+      }})

      it("changs the state to closed", function() { with(this) {
        assertEqual( false, open )
@@ -332,3 +258,4 @@ test.describe("Client", function() { with(this) {
    }})
  }})
 }})
+
@@ -42,28 +42,6 @@ test.describe("draft-75", function() { with(this) {
          driver().parse([0x6c, 0x6f, 0xff])
          assertEqual( "Hello", message )
        }})
-
-        describe("when a message listener throws an error", function() { with(this) {
-          before(function() { with(this) {
-            this.messages = []
-
-            driver().on("message", function(msg) {
-              messages.push(msg.data)
-              throw new Error("an error")
-            })
-          }})
-
-          it("is not trapped by the parser", function() { with(this) {
-            var buffer = [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
-            assertThrows(Error, function() { driver().parse(buffer) })
-          }})
-
-          it("parses text frames without dropping input", function() { with(this) {
-            try { driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x57]) } catch (e) {}
-            try { driver().parse([0x6f, 0x72, 0x6c, 0x64, 0xff]) } catch (e) {}
-            assertEqual( ["Hello", "World"], messages )
-          }})
-        }})
      }})

      describe("frame", function() { with(this) {
@@ -77,11 +55,6 @@ test.describe("draft-75", function() { with(this) {
          assertEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], collector().bytes )
        }})

-        it("converts numbers to strings", function() { with(this) {
-          driver().frame(50)
-          assertEqual( [0x00, 0x35, 0x30, 0xff], collector().bytes )
-        }})
-
        it("returns true", function() { with(this) {
          assertEqual( true, driver().frame("lol") )
        }})
@@ -139,3 +112,4 @@ test.describe("draft-75", function() { with(this) {
    }})
  }})
 }})
+
@@ -4,7 +4,6 @@ var Draft75 = require("../../../lib/websocket/driver/draft75"),
 test.describe("Draft75", function() { with(this) {
  define("request", function() {
    return this._request = this._request || {
-      method: "GET",
      headers: {
        "connection": "Upgrade",
        "upgrade":    "WebSocket",
@@ -14,7 +13,7 @@ test.describe("Draft75", function() { with(this) {
  })

  define("options", function() {
-    return this._options = this._options || { masking: false }
+    return this._options = this._options || {masking: false}
  })

  define("driver", function() {
@@ -98,3 +97,4 @@ test.describe("Draft75", function() { with(this) {

  itShouldBehaveLike("draft-75 protocol")
 }})
+
@@ -1,9 +1,8 @@
 var Draft76 = require("../../../lib/websocket/driver/draft76"),
-    Buffer  = require('safe-buffer').Buffer,
    test    = require('jstest').Test

 test.describe("Draft76", function() { with(this) {
-  BODY = Buffer.from([0x91, 0x25, 0x3e, 0xd3, 0xa9, 0xe7, 0x6a, 0x88])
+  BODY = new Buffer([0x91, 0x25, 0x3e, 0xd3, 0xa9, 0xe7, 0x6a, 0x88])

  define("body", function() {
    return BODY
@@ -15,7 +14,6 @@ test.describe("Draft76", function() { with(this) {

  define("request", function() {
    return this._request = this._request || {
-      method: "GET",
      headers: {
        "connection":         "Upgrade",
        "upgrade":            "WebSocket",
@@ -27,7 +25,7 @@ test.describe("Draft76", function() { with(this) {
  })

  define("options", function() {
-    return this._options = this._options || { masking: false }
+    return this._options = this._options || {masking: false}
  })

  define("driver", function() {
@@ -36,7 +34,6 @@ test.describe("Draft76", function() { with(this) {
    var self = this
    this._driver.on('open',    function(e) { self.open = true })
    this._driver.on('message', function(e) { self.message += e.data })
-    this._driver.on('error',   function(e) { self.error = e })
    this._driver.on('close',   function(e) { self.close = true })
    this._driver.io.pipe(this.collector())
    this._driver.io.write(this.body())
@@ -84,42 +81,6 @@ test.describe("Draft76", function() { with(this) {
        driver().start()
        assertEqual( "hixie-76", driver().version )
      }})
-
-      describe("with an invalid key header", function() { with(this) {
-        before(function() { with(this) {
-          request().headers["sec-websocket-key1"] = "2 L785 8o% s9Sy9@V. 4<1P5"
-        }})
-
-        it("writes a handshake error response", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "HTTP/1.1 400 Bad Request\r\n" +
-              "Content-Type: text/plain\r\n" +
-              "Content-Length: 45\r\n" +
-              "\r\n" +
-              "Client sent invalid Sec-WebSocket-Key headers"))
-          driver().start()
-        }})
-
-        it("does not trigger the onopen event", function() { with(this) {
-          driver().start()
-          assertEqual( false, open )
-        }})
-
-        it("triggers the onerror event", function() { with(this) {
-          driver().start()
-          assertEqual( "Client sent invalid Sec-WebSocket-Key headers", error.message )
-        }})
-
-        it("triggers the onclose event", function() { with(this) {
-          driver().start()
-          assertEqual( true, close )
-        }})
-
-        it("changes the state to closed", function() { with(this) {
-          driver().start()
-          assertEqual( "closed", driver().getState()  )
-        }})
-      }})
    }})

    describe("frame", function() { with(this) {
@@ -150,7 +111,7 @@ test.describe("Draft76", function() { with(this) {

    describe("with no request body", function() { with(this) {
      define("body", function() {
-        return Buffer.alloc(0)
+        return new Buffer([])
      })

      it("writes the handshake response with no body", function() { with(this) {
@@ -223,3 +184,4 @@ test.describe("Draft76", function() { with(this) {
    }})
  }})
 }})
+
@@ -4,7 +4,6 @@ var Hybi = require("../../../lib/websocket/driver/hybi"),
 test.describe("Hybi", function() { with(this) {
  define("request", function() {
    return this._request = this._request || {
-      method: "GET",
      headers: {
        "connection":             "Upgrade",
        "upgrade":                "websocket",
@@ -17,7 +16,7 @@ test.describe("Hybi", function() { with(this) {
  })

  define("options", function() {
-    return this._options = this._options || { masking: false }
+    return this._options = this._options || {masking: false}
  })

  define("driver", function() {
@@ -80,54 +79,18 @@ test.describe("Hybi", function() { with(this) {
        }})
      }})

-      describe("with invalid extensions", function() { with(this) {
-        before(function() { with(this) {
-          request().headers["sec-websocket-extensions"] = "x-webkit- -frame"
-        }})
-
-        it("writes a handshake error response", function() { with(this) {
-          expect(driver().io, "emit").given("data", buffer(
-              "HTTP/1.1 400 Bad Request\r\n" +
-              "Content-Type: text/plain\r\n" +
-              "Content-Length: 57\r\n" +
-              "\r\n" +
-              "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame"))
-          driver().start()
-        }})
-
-        it("does not trigger the onopen event", function() { with(this) {
-          driver().start()
-          assertEqual( false, open )
-        }})
-
-        it("triggers the onerror event", function() { with(this) {
-          driver().start()
-          assertEqual( "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame", error.message )
-        }})
-
-        it("triggers the onclose event", function() { with(this) {
-          driver().start()
-          assertEqual( [1002, "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame"], close )
-        }})
-
-        it("changes the state to closed", function() { with(this) {
-          driver().start()
-          assertEqual( "closed", driver().getState() )
-        }})
-      }})
-
      describe("with custom headers", function() { with(this) {
        before(function() { with(this) {
          driver().setHeader("Authorization", "Bearer WAT")
        }})

-        it("writes the handshake with the custom headers", function() { with(this) {
+        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
          expect(driver().io, "emit").given("data", buffer(
              "HTTP/1.1 101 Switching Protocols\r\n" +
-              "Authorization: Bearer WAT\r\n" +
              "Upgrade: websocket\r\n" +
              "Connection: Upgrade\r\n" +
              "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+              "Authorization: Bearer WAT\r\n" +
              "\r\n"))
          driver().start()
        }})
@@ -197,30 +160,6 @@ test.describe("Hybi", function() { with(this) {
      }})
    }})

-    describe("pong", function() { with(this) {
-        it("does not write to the socket", function() { with(this) {
-            expect(driver().io, "emit").exactly(0)
-            driver().pong()
-        }})
-
-        it("returns true", function() { with(this) {
-            assertEqual( true, driver().pong() )
-        }})
-
-        it("queues the pong until the handshake has been sent", function() { with(this) {
-            expect(driver().io, "emit").given("data", buffer(
-                "HTTP/1.1 101 Switching Protocols\r\n" +
-                "Upgrade: websocket\r\n" +
-                "Connection: Upgrade\r\n" +
-                "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
-                "\r\n"))
-            expect(driver().io, "emit").given("data", buffer([0x8a, 0]))
-
-            driver().pong()
-            driver().start()
-        }})
-    }})
-
    describe("close", function() { with(this) {
      it("does not write anything to the socket", function() { with(this) {
        expect(driver().io, "emit").exactly(0)
@@ -260,42 +199,54 @@ test.describe("Hybi", function() { with(this) {
        return output
      })

-      it("parses unmasked text frames", function() { with(this) {
+      it("parses unmasked text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        assertEqual( "Hello", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Hello", message ) })
+        }, 10)
      }})

-      it("parses multiple frames from the same packet", function() { with(this) {
+      it("parses multiple frames from the same packet", function(resume) { with(this) {
        driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        assertEqual( "HelloHello", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "HelloHello", message ) })
+        }, 10)
      }})

-      it("parses empty text frames", function() { with(this) {
+      it("parses empty text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x00])
-        assertEqual( "", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "", message ) })
+        }, 10)
      }})

-      it("parses fragmented text frames", function() { with(this) {
+      it("parses fragmented text frames", function(resume) { with(this) {
        driver().parse([0x01, 0x03, 0x48, 0x65, 0x6c])
        driver().parse([0x80, 0x02, 0x6c, 0x6f])
-        assertEqual( "Hello", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Hello", message ) })
+        }, 10)
      }})

-      it("parses masked text frames", function() { with(this) {
+      it("parses masked text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x85])
        driver().parse(mask())
        driver().parse(maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
-        assertEqual( "Hello", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Hello", message ) })
+        }, 10)
      }})

-      it("parses masked empty text frames", function() { with(this) {
+      it("parses masked empty text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x80])
        driver().parse(mask())
        driver().parse(maskMessage([]))
-        assertEqual( "", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "", message ) })
+        }, 10)
      }})

-      it("parses masked fragmented text frames", function() { with(this) {
+      it("parses masked fragmented text frames", function(resume) { with(this) {
        driver().parse([0x01, 0x81])
        driver().parse(mask())
        driver().parse(maskMessage([0x48]))
@@ -304,49 +255,67 @@ test.describe("Hybi", function() { with(this) {
        driver().parse(mask())
        driver().parse(maskMessage([0x65, 0x6c, 0x6c, 0x6f]))

-        assertEqual( "Hello", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Hello", message ) })
+        }, 10)
      }})

-      it("closes the socket if the frame has an unrecognized opcode", function() { with(this) {
+      it("closes the socket if the frame has an unrecognized opcode", function(resume) { with(this) {
        driver().parse([0x83, 0x00])
-        assertEqual( [0x88, 0x1e, 0x03, 0xea], collector().bytes.slice(0,4) )
-        assertEqual( "Unrecognized frame opcode: 3", error.message )
-        assertEqual( [1002, "Unrecognized frame opcode: 3"], close )
-        assertEqual( "closed", driver().getState() )
+        setTimeout(function() {
+          resume(function() {
+            assertEqual( [0x88, 0x1e, 0x03, 0xea], collector().bytes.slice(0,4) )
+            assertEqual( "Unrecognized frame opcode: 3", error.message )
+            assertEqual( [1002, "Unrecognized frame opcode: 3"], close )
+            assertEqual( "closed", driver().getState() )
+          })
+        }, 10)
      }})

-      it("closes the socket if a close frame is received", function() { with(this) {
+      it("closes the socket if a close frame is received", function(resume) { with(this) {
        driver().parse([0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        assertEqual( [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
-        assertEqual( [1000, "Hello"], close )
-        assertEqual( "closed", driver().getState() )
+        setTimeout(function() {
+          resume(function() {
+            assertEqual( [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
+            assertEqual( [1000, "Hello"], close )
+            assertEqual( "closed", driver().getState() )
+          })
+        }, 10)
      }})

-      it("parses unmasked multibyte text frames", function() { with(this) {
+      it("parses unmasked multibyte text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-        assertEqual( "Apple = ", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Apple = ", message ) })
+        }, 10)
      }})

-      it("parses frames received in several packets", function() { with(this) {
+      it("parses frames received in several packets", function(resume) { with(this) {
        driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c])
        driver().parse([0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-        assertEqual( "Apple = ", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Apple = ", message ) })
+        }, 10)
      }})

-      it("parses fragmented multibyte text frames", function() { with(this) {
+      it("parses fragmented multibyte text frames", function(resume) { with(this) {
        driver().parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])
        driver().parse([0x80, 0x01, 0xbf])
-        assertEqual( "Apple = ", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Apple = ", message ) })
+        }, 10)
      }})

-      it("parse masked multibyte text frames", function() { with(this) {
+      it("parse masked multibyte text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x8b])
        driver().parse(mask())
        driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]))
-        assertEqual( "Apple = ", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Apple = ", message ) })
+        }, 10)
      }})

-      it("parses masked fragmented multibyte text frames", function() { with(this) {
+      it("parses masked fragmented multibyte text frames", function(resume) { with(this) {
        driver().parse([0x01, 0x8a])
        driver().parse(mask())
        driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]))
@@ -355,27 +324,35 @@ test.describe("Hybi", function() { with(this) {
        driver().parse(mask())
        driver().parse(maskMessage([0xbf]))

-        assertEqual( "Apple = ", message )
+        setTimeout(function() {
+          resume(function() { assertEqual( "Apple = ", message ) })
+        }, 10)
      }})

-      it("parses unmasked medium-length text frames", function() { with(this) {
+      it("parses unmasked medium-length text frames", function(resume) { with(this) {
        driver().parse([0x81, 0x7e, 0x00, 0xc8])
        var i = 40, result = ""
        while (i--) {
          driver().parse([0x48, 0x65, 0x6c, 0x6c, 0x6f])
          result += "Hello"
        }
-        assertEqual( result, message )
+        setTimeout(function() {
+          resume(function() { assertEqual( result, message ) })
+        }, 10)
      }})

-      it("returns an error for too-large frames", function() { with(this) {
+      it("returns an error for too-large frames", function(resume) { with(this) {
        driver().parse([0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00])
-        assertEqual( "WebSocket frame length too large", error.message )
-        assertEqual( [1009, "WebSocket frame length too large"], close )
-        assertEqual( "closed", driver().getState() )
+        setTimeout(function() {
+          resume(function() {
+            assertEqual( "WebSocket frame length too large", error.message )
+            assertEqual( [1009, "WebSocket frame length too large"], close )
+            assertEqual( "closed", driver().getState() )
+          })
+        }, 10)
      }})

-      it("parses masked medium-length text frames", function() { with(this) {
+      it("parses masked medium-length text frames", function(resume) { with(this) {
        driver().parse([0x81, 0xfe, 0x00, 0xc8])
        driver().parse(mask())
        var i = 40, result = "", packet = []
@@ -384,45 +361,18 @@ test.describe("Hybi", function() { with(this) {
          result += "Hello"
        }
        driver().parse(maskMessage(packet))
-        assertEqual( result, message )
+        setTimeout(function() {
+          resume(function() { assertEqual( result, message ) })
+        }, 10)
      }})

-      it("replies to pings with a pong", function() { with(this) {
+      it("replies to pings with a pong", function(resume) { with(this) {
        driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
-        assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes )
-      }})
-
-      it("triggers the onping event when a ping arrives", function() { with(this) {
-        var ping, pong
-        driver().on("ping", function(event) { ping = event })
-        driver().on("pong", function(event) { pong = event })
-
-        driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
-
-        assertEqual( "OHAI", ping.data )
-        assertEqual( undefined, pong )
-      }})
-
-      describe("when a message listener throws an error", function() { with(this) {
-        before(function() { with(this) {
-          this.messages = []
-
-          driver().on("message", function(msg) {
-            messages.push(msg.data)
-            throw new Error("an error")
+        setTimeout(function() {
+          resume(function() {
+            assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes )
          })
-        }})
-
-        it("is not trapped by the parser", function() { with(this) {
-          var buffer = [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
-          assertThrows(Error, function() { driver().parse(buffer) })
-        }})
-
-        it("parses unmasked text frames without dropping input", function() { with(this) {
-          try { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05]) } catch (e) {}
-          try { driver().parse([0x57, 0x6f, 0x72, 0x6c, 0x64]) } catch (e) {}
-          assertEqual( ["Hello", "World"], messages )
-        }})
+        }, 10)
      }})
    }})

@@ -437,11 +387,6 @@ test.describe("Hybi", function() { with(this) {
        assertEqual( [0x82, 0x03, 0x48, 0x65, 0x6c], collector().bytes )
      }})

-      it("converts numbers to strings", function() { with(this) {
-        driver().frame(50)
-        assertEqual( [0x81, 0x02, 0x35, 0x30], collector().bytes )
-      }})
-
      it("encodes multibyte characters correctly", function() { with(this) {
        driver().frame("Apple = ")
        assertEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], collector().bytes )
@@ -474,49 +419,26 @@ test.describe("Hybi", function() { with(this) {
        assertEqual( [0x89, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes )
      }})

-      it("converts numbers to strings", function() { with(this) {
-        driver().ping(50)
-        assertEqual( [0x89, 0x02, 0x35, 0x30], collector().bytes )
-      }})
-
      it("returns true", function() { with(this) {
        assertEqual( true, driver().ping() )
      }})

-      it("runs the given callback on mathing pong", function() { with(this) {
+      it("runs the given callback on mathing pong", function(resume) { with(this) {
        var reply = null
        driver().ping("Hi", function() { reply = true })
        driver().parse([0x8a, 0x02, 72, 105])
-        assert( reply )
+        setTimeout(function() {
+          resume(function() { assert( reply ) })
+        }, 10)
      }})

-      it("triggers the onpong event when a pong arrives", function() { with(this) {
-        var ping, pong
-        driver().on("ping", function(event) { ping = event })
-        driver().on("pong", function(event) { pong = event })
-
-        driver().parse([0x8a, 0x02, 72, 105])
-
-        assertEqual( undefined, ping )
-        assertEqual( "Hi", pong.data )
-      }})
-
-      it("does not run the callback on non-matching pong", function() { with(this) {
+      it("does not run the callback on non-matching pong", function(resume) { with(this) {
        var reply = null
        driver().ping("Hi", function() { reply = true })
        driver().parse([0x8a, 0x03, 119, 97, 116])
-        assert( !reply )
-      }})
-    }})
-
-    describe("pong", function() { with(this) {
-      it("writes a pong frame to the socket", function() { with(this) {
-        driver().pong("mic check")
-        assertEqual([0x8a, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes)
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual(true, driver().pong())
+        setTimeout(function() {
+          resume(function() { assert( !reply ) })
+        }, 10)
      }})
    }})

@@ -553,15 +475,21 @@ test.describe("Hybi", function() { with(this) {
      this.driver().start()
    })

-    it("does not emit a message", function() { with(this) {
+    it("does not emit a message", function(resume) { with(this) {
      driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      assertEqual( "", message )
+      setTimeout(function() {
+        resume(function() { assertEqual( "", message ) })
+      }, 10)
    }})

-    it("returns an error", function() { with(this) {
+    it("returns an error", function(resume) { with(this) {
      driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      assertEqual( "Received unmasked frame but masking is required", error.message )
-      assertEqual( [1003, "Received unmasked frame but masking is required"], close )
+      setTimeout(function() {
+        resume(function() {
+          assertEqual( "Received unmasked frame but masking is required", error.message )
+          assertEqual( [1003, "Received unmasked frame but masking is required"], close )
+        })
+      }, 10)
    }})
  }})

@@ -571,105 +499,6 @@ test.describe("Hybi", function() { with(this) {
      this.driver().close()
    })

-    describe("frame", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().frame("dropped")
-      }})
-
-      it("returns true", function() { with(this) {
-        assertEqual( true, driver().frame("wut") )
-      }})
-    }})
-
-    describe("ping", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().ping()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().ping() )
-      }})
-    }})
-
-    describe("pong", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().pong()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().pong() )
-      }})
-    }})
-
-    describe("close", function() { with(this) {
-      it("does not write to the socket", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        driver().close()
-      }})
-
-      it("returns false", function() { with(this) {
-        assertEqual( false, driver().close() )
-      }})
-    }})
-
-    describe("receiving a close frame", function() { with(this) {
-      before(function() {
-        this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
-      })
-
-      it("triggers the onclose event", function() { with(this) {
-        assertEqual( [1001, "OK"], close )
-      }})
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( "closed", driver().getState() )
-      }})
-
-      it("does not write another close frame", function() { with(this) {
-        expect(driver().io, "emit").exactly(0)
-        this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
-      }})
-    }})
-
-    describe("receiving a close frame with a too-short payload", function() { with(this) {
-      before(function() {
-        this.driver().parse([0x88, 0x01, 0x03])
-      })
-
-      it("triggers the onclose event with a protocol error", function() { with(this) {
-        assertEqual( [1002, ""], close )
-      }})
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-
-    describe("receiving a close frame with no code", function() { with(this) {
-      before(function() { with(this) {
-        this.driver().parse([0x88, 0x00])
-      }})
-
-      it("triggers the onclose event with code 1000", function() { with(this) {
-        assertEqual( [1000, ""], close )
-      }})
-
-      it("changes the state to closed", function() { with(this) {
-        assertEqual( "closed", driver().getState() )
-      }})
-    }})
-  }})
-
-  describe("in the closed state", function() { with(this) {
-    before(function() {
-      this.driver().start()
-      this.driver().close()
-      this.driver().parse([0x88, 0x02, 0x03, 0xea])
-    })
-
    describe("frame", function() { with(this) {
      it("does not write to the socket", function() { with(this) {
        expect(driver().io, "emit").exactly(0)
@@ -692,14 +521,60 @@ test.describe("Hybi", function() { with(this) {
      }})
    }})

-    describe("pong", function() { with(this) {
+    describe("close", function() { with(this) {
      it("does not write to the socket", function() { with(this) {
        expect(driver().io, "emit").exactly(0)
-        driver().pong()
+        driver().close()
      }})

      it("returns false", function() { with(this) {
-        assertEqual( false, driver().pong() )
+        assertEqual( false, driver().close() )
+      }})
+    }})
+
+    describe("receiving a close frame", function() { with(this) {
+      before(function(resume) {
+        this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
+        setTimeout(resume, 10)
+      })
+
+      it("triggers the onclose event", function() { with(this) {
+        assertEqual( [1001, "OK"], close )
+      }})
+
+      it("changes the state to closed", function() { with(this) {
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+  }})
+
+  describe("in the closed state", function() { with(this) {
+    before(function(resume) {
+      this.driver().start()
+      this.driver().close()
+      this.driver().parse([0x88, 0x02, 0x03, 0xea])
+      setTimeout(resume, 10)
+    })
+
+    describe("frame", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().frame("dropped")
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().frame("wut") )
+      }})
+    }})
+
+    describe("ping", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().ping()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().ping() )
      }})
    }})

@@ -720,3 +595,4 @@ test.describe("Hybi", function() { with(this) {
    }})
  }})
 }})
+
Author	SHA1	Message	Date
James Coglan	e6dea40c8c	[WIP] Begin implementing permessage-deflate.	2014-05-11 22:32:15 +01:00
James Coglan	7953bc39ff	Implement masking as a transform stream.	2014-05-11 22:07:34 +01:00
James Coglan	bf39b7b44b	Optimise some special cases in StreamReader; return a new Buffer from read() immediately if there's enough buffered data, and if the read can be fulfilled entirely from the first queued buffer than take a slice rather than copying into a new buffer.	2014-05-11 13:33:51 +01:00
James Coglan	85ba40ac32	Convert StreamReader so that it emits streams rather than waiting for an entire payload.	2014-05-09 15:35:40 +01:00
James Coglan	e6edb23681	Rather than a sync read() method in a loop, use an async read() method with a callback.	2014-05-08 16:35:21 +01:00