Update the 0.4.0 release date.

This results in a more simple design, in the sense of fewer concerns
being mixed together. It makes the API more verbose, but it's not
difficult to use correctly.

It also means that we make the I/O implementation deal with TLS, so it
can use tls.connect({socket: io}) or the upcoming TLSSocket class,
rather than this module needing a huge amount of boilerplate and
internal indirection to use tls.createSecurePair() and make Proxy wrap
pair.encrypted.

Using tls.connect({socket: io}) would be awkward on this end, because it
expects a stream that emits *incoming* data from the TCP connection. All
the streams in this module emit *outgoing* data that should be written
to TCP, so their polarity is flipped compared to what tls.connect()
wants, and resolving that involves even more stream boilerplate.

.travis.yml

@@ -8,4 +8,3 @@ node_js:
 
 before_install:
   - '[ "${TRAVIS_NODE_VERSION}" = "0.6" ] && npm conf set strict-ssl false || true'
-

CHANGELOG.md

@@ -1,3 +1,16 @@
+### 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
@@ -39,4 +52,3 @@
 ### 0.1.0 / 2013-05-04
 
 * First stable release
-

README.md

@@ -1,4 +1,4 @@
-# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.png)](https://travis-ci.org/faye/websocket-driver-node)
+# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.svg)](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
@@ -134,17 +134,17 @@ var net = require('net'),
     websocket = require('websocket-driver');
 
 var driver = websocket.client('ws://www.example.com/socket'),
-    tcp = net.createConnection(80, 'www.example.com');
+    tcp = net.connect(80, 'www.example.com');
 
 tcp.pipe(driver.io).pipe(tcp);
 
-driver.messages.on('data', function(message) {
-  console.log('Got a message', message);
-});
-
 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
@@ -154,6 +154,65 @@ was sent back by the server:
 * `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.
+
+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 API
 
 Drivers are created using one of the following methods:
@@ -304,4 +363,3 @@ 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.
-

examples/tcp_server.js

@@ -18,4 +18,3 @@ var server = net.createServer(function(connection) {
 });
 
 server.listen(process.argv[2]);
-

lib/websocket/driver.js

@@ -41,4 +41,3 @@ var Driver = {
 };
 
 module.exports = Driver;
-

lib/websocket/driver/base.js

@@ -9,7 +9,7 @@ var Base = function(request, url, options) {
   this._request   = request;
   this._options   = options || {};
   this._maxLength = this._options.maxLength || this.MAX_LENGTH;
-  this.__headers  = new Headers();
+  this._headers   = new Headers();
   this.__queue    = [];
   this.readyState = 0;
   this.url        = url;
@@ -57,7 +57,7 @@ var instance = {
 
   setHeader: function(name, value) {
     if (this.readyState > 0) return false;
-    this.__headers.set(name, value);
+    this._headers.set(name, value);
     return true;
   },
 
@@ -123,4 +123,3 @@ Base.MessageEvent = function(data) {
 };
 
 module.exports = Base;
-

lib/websocket/driver/client.js

@@ -1,27 +1,49 @@
 var url        = require('url'),
     util       = require('util'),
-    HttpParser = require('./http_parser'),
+    HttpParser = require('../http_parser'),
     Base       = require('./base'),
-    Hybi       = require('./hybi');
+    Hybi       = require('./hybi'),
+    Proxy      = require('./proxy');
 
-var Client = function(url, options) {
+var Client = function(_url, options) {
   this.version = 'hybi-13';
-  Hybi.call(this, null, url, options);
+  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 && new Buffer(uri.auth, 'utf8').toString('base64');
+
+  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', '13');
+
+  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() {
   var buffer = new Buffer(16), i = buffer.length;
-  while (i--) buffer[i] = ~~(Math.random() * 256);
+  while (i--) buffer[i] = Math.floor(Math.random() * 256);
   return buffer.toString('base64');
 };
 
 var instance = {
+  proxy: function(origin, options) {
+    return new Proxy(this, origin, options);
+  },
+
   start: function() {
     if (this.readyState !== -1) return false;
     this._write(this._handshakeRequest());
@@ -34,29 +56,16 @@ var instance = {
 
     this._http.parse(data);
     if (!this._http.isComplete()) return;
-    
+
     this._validateHandshake();
     this.parse(this._http.body);
   },
 
   _handshakeRequest: function() {
-    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'
-                  ];
-
-    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');
+    return new Buffer(headers.join('\r\n'), 'utf8');
   },
 
   _failHandshake: function(message) {
@@ -109,4 +118,3 @@ for (var key in instance)
   Client.prototype[key] = instance[key];
 
 module.exports = Client;
-

lib/websocket/driver/draft75.js

@@ -5,6 +5,11 @@ var Draft75 = function(request, url, options) {
   Base.apply(this, arguments);
   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);
 
@@ -88,14 +93,10 @@ var instance = {
   },
 
   _handshakeResponse: function() {
-    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');
+    var start   = 'HTTP/1.1 101 Web Socket Protocol Handshake',
+        headers = [start, this._headers.toString(), ''];
+
+    return new Buffer(headers.join('\r\n'), 'utf8');
   },
 
   _parseLeadingByte: function(data) {
@@ -115,4 +116,3 @@ for (var key in instance)
   Draft75.prototype[key] = instance[key];
 
 module.exports = Draft75;
-

lib/websocket/driver/draft76.js

@@ -26,6 +26,13 @@ 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);
 
@@ -48,14 +55,10 @@ var instance = {
   },
 
   _handshakeResponse: function() {
-    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');
+    var start   = 'HTTP/1.1 101 WebSocket Protocol Handshake',
+        headers = [start, this._headers.toString(), ''];
+
+    return new Buffer(headers.join('\r\n'), 'binary');
   },
 
   _handshakeSignature: function() {
@@ -106,4 +109,3 @@ for (var key in instance)
   Draft76.prototype[key] = instance[key];
 
 module.exports = Draft76;
-

lib/websocket/driver/headers.js

@@ -1,10 +1,14 @@
 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.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate']
-
 Headers.prototype.set = function(name, value) {
   if (value === undefined) return;
 
@@ -12,7 +16,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');
   }
@@ -27,4 +31,3 @@ Headers.prototype._strip = function(string) {
 };
 
 module.exports = Headers;
-

lib/websocket/driver/hybi.js

@@ -1,33 +1,53 @@
-var crypto = require('crypto'),
-    util   = require('util'),
-    Base   = require('./base'),
-    Concat = require('./hybi/concat'),
-    Mask   = require('./hybi/mask'),
-    Reader = require('./hybi/stream_reader');
+var crypto   = require('crypto'),
+    util     = require('util'),
+    Base     = require('./base'),
+    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 || [];
+  this._reader         = new Reader();
+  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(/\s*,\s*/);
 
-  this._requireMasking = this._options.requireMasking;
-  this._pingCallbacks  = {};
+  if (!this._request) return;
 
-  if (!this.version) {
-    var version = this._request.headers['sec-websocket-version'];
-    this.version = 'hybi-' + version;
+  var secKey    = this._request.headers['sec-websocket-key'],
+      protos    = this._request.headers['sec-websocket-protocol'],
+      version   = this._request.headers['sec-websocket-version'],
+      supported = this._protocols;
+
+  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*/);
+    this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
+    if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
   }
 
-  this._reader.read(1, this._parseOpcode);
+  this.version = 'hybi-' + version;
 };
 util.inherits(Hybi, Base);
 
+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);
@@ -81,7 +101,45 @@ var instance = {
   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})*$/,
 
   parse: function(data) {
-    this._reader.write(data);
+    this._reader.put(data);
+    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._lengthSize);
+          if (buffer) this._parseExtendedLength(buffer);
+          break;
+
+        case 3:
+          buffer = this._reader.read(4);
+          if (buffer) {
+            this._mask  = buffer;
+            this._stage = 4;
+          }
+          break;
+
+        case 4:
+          buffer = this._reader.read(this._length);
+          if (buffer) {
+            this._emitFrame(buffer);
+            this._stage = 0;
+          }
+          break;
+
+        default:
+          buffer = null;
+      }
+    }
   },
 
   frame: function(data, type, code) {
@@ -108,31 +166,31 @@ var instance = {
       frame[1] = masked | length;
     } else if (length <= 65535) {
       frame[1] = masked | 126;
-      frame[2] = ~~(length / 256);
+      frame[2] = Math.floor(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[2] = Math.floor(length / Math.pow(2,56)) & BYTE;
+      frame[3] = Math.floor(length / Math.pow(2,48)) & BYTE;
+      frame[4] = Math.floor(length / Math.pow(2,40)) & BYTE;
+      frame[5] = Math.floor(length / Math.pow(2,32)) & BYTE;
+      frame[6] = Math.floor(length / Math.pow(2,24)) & BYTE;
+      frame[7] = Math.floor(length / Math.pow(2,16)) & BYTE;
+      frame[8] = Math.floor(length / Math.pow(2,8))  & BYTE;
       frame[9] = length & BYTE;
     }
 
     if (code) {
-      frame[offset]     = ~~(code / 256) & BYTE;
-      frame[offset + 1] = code & BYTE;
+      frame[offset]   = Math.floor(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)];
+      mask = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256),
+              Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
       new Buffer(mask).copy(frame, header);
-      Mask.mask(frame, mask, offset);
+      Hybi.mask(frame, mask, offset);
     }
 
     this._write(frame);
@@ -157,7 +215,7 @@ var instance = {
     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;
@@ -171,37 +229,16 @@ var instance = {
   },
 
   _handshakeResponse: function() {
-    var secKey = this._request.headers['sec-websocket-key'];
-    if (!secKey) return '';
+    var start   = 'HTTP/1.1 101 Switching Protocols',
+        headers = [start, this._headers.toString(), ''];
 
-    var accept    = Hybi.generateAccept(secKey),
-        protos    = this._request.headers['sec-websocket-protocol'],
-        supported = this._protocols,
-        proto,
-
-        headers = [
-          'HTTP/1.1 101 Switching Protocols',
-          'Upgrade: websocket',
-          'Connection: Upgrade',
-          'Sec-WebSocket-Accept: ' + accept
-        ];
-
-    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);
-      }
-    }
-
-    return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
+    return new Buffer(headers.join('\r\n'), 'utf8');
   },
 
   _shutdown: function(code, reason) {
     this.frame(reason, 'close', code);
     this.readyState = 3;
-    this._reader.end();
+    this._stage = 5;
     this.emit('close', new Base.CloseEvent(code, reason));
   },
 
@@ -210,9 +247,7 @@ var instance = {
     this._shutdown(this.ERRORS[type], message);
   },
 
-  _parseOpcode: function(buffer) {
-    var data = buffer[0];
-
+  _parseOpcode: function(data) {
     var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
       return (data & rsv) === rsv;
     });
@@ -223,9 +258,8 @@ var instance = {
           ', reserved2 = ' + (rsvs[1] ? 1 : 0) +
           ', reserved3 = ' + (rsvs[2] ? 1 : 0));
 
-    this._final  = (data & this.FIN) === this.FIN;
-    this._opcode = (data & this.OPCODE);
-    this._mask   = null;
+    this._final   = (data & this.FIN) === this.FIN;
+    this._opcode  = (data & this.OPCODE);
 
     if (this.OPCODE_CODES.indexOf(this._opcode) < 0)
       return this._fail('protocol_error', 'Unrecognized frame opcode: ' + this._opcode);
@@ -236,12 +270,10 @@ var instance = {
     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);
+    this._stage = 1;
   },
 
-  _parseLength: function(buffer) {
-    var data = buffer[0];
-
+  _parseLength: function(data) {
     this._masked = (data & this.MASK) === this.MASK;
     if (this._requireMasking && !this._masked)
       return this._fail('unacceptable', 'Received unmasked frame but masking is required');
@@ -250,10 +282,10 @@ var instance = {
 
     if (this._length >= 0 && this._length <= 125) {
       if (!this._checkFrameLength()) return;
-      this._readMask();
+      this._stage = this._masked ? 3 : 4;
     } else {
-      var lengthSize = (this._length === 126 ? 2 : 8);
-      this._reader.read(lengthSize, this._parseExtendedLength);
+      this._lengthSize = (this._length === 126 ? 2 : 8);
+      this._stage      = 2;
     }
   },
 
@@ -265,7 +297,7 @@ var instance = {
 
     if (!this._checkFrameLength()) return;
 
-    this._readMask();
+    this._stage  = this._masked ? 3 : 4;
   },
 
   _checkFrameLength: function() {
@@ -277,33 +309,18 @@ var instance = {
     }
   },
 
-  _readMask: function() {
-    if (this._masked)
-      this._reader.read(4, function(buffer) {
-        this._mask = new Mask(buffer);
-        this._readPayload();
-      });
-    else
-      this._readPayload();
-  },
+  _emitFrame: function(buffer) {
+    var payload = Hybi.mask(buffer, this._mask),
+        isFinal = this._final,
+        opcode  = this._opcode;
 
-  _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;
+    this._final = this._opcode = this._length = this._lengthSize = this._masked = this._mask = null;
 
     if (opcode === this.OPCODES.continuation) {
       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 (isFinal) {
+        var message = this._concatBuffer();
         if (this._mode === 'text') message = this._encode(message);
         this._reset();
         if (message === null)
@@ -313,7 +330,7 @@ var instance = {
       }
     }
     else if (opcode === this.OPCODES.text) {
-      if (this._final) {
+      if (isFinal) {
         var message = this._encode(payload);
         if (message === null)
           this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
@@ -325,7 +342,7 @@ var instance = {
       }
     }
     else if (opcode === this.OPCODES.binary) {
-      if (this._final) {
+      if (isFinal) {
         this.emit('message', new Base.MessageEvent(payload));
       } else {
         this._mode = 'binary';
@@ -357,8 +374,6 @@ var instance = {
       delete callbacks[message];
       if (callback) callback()
     }
-
-    this._reader.read(1, this._parseOpcode);
   },
 
   _buffer: function(fragment) {
@@ -366,6 +381,17 @@ var instance = {
     this.__blength += fragment.length;
   },
 
+  _concatBuffer: function() {
+    var buffer = new Buffer(this.__blength),
+        offset = 0;
+
+    for (var i = 0, n = this.__buffer.length; i < n; i++) {
+      this.__buffer[i].copy(buffer, offset);
+      offset += this.__buffer[i].length;
+    }
+    return buffer;
+  },
+
   _reset: function() {
     this._mode     = null;
     this.__buffer  = [];
@@ -392,4 +418,3 @@ for (var key in instance)
   Hybi.prototype[key] = instance[key];
 
 module.exports = Hybi;
-

lib/websocket/driver/hybi/concat.js

@@ -1,45 +0,0 @@
-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;

lib/websocket/driver/hybi/mask.js

@@ -1,43 +0,0 @@
-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;
-

lib/websocket/driver/hybi/stream_reader.js

@@ -1,121 +1,25 @@
-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;
+var StreamReader = function() {
   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;
 
+StreamReader.prototype.put = function(buffer) {
+  if (!buffer || buffer.length === 0) return;
   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;
+StreamReader.prototype.read = function(length) {
+  if (length > this._queueSize) return null;
 
-  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,
+  var buffer = new Buffer(length),
+      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);
+      chunk, size;
 
   while (remain > 0 && i < n) {
     chunk = queue[i];

lib/websocket/driver/proxy.js

@@ -0,0 +1,95 @@
+var Stream     = require('stream').Stream,
+    url        = require('url'),
+    util       = require('util'),
+    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 && new Buffer(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', new Buffer(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');
+    } 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;

lib/websocket/driver/server.js

@@ -1,5 +1,5 @@
 var util       = require('util'),
-    HttpParser = require('./http_parser'),
+    HttpParser = require('../http_parser'),
     Base       = require('./base'),
     Draft75    = require('./draft75'),
     Draft76    = require('./draft76'),
@@ -40,6 +40,9 @@ var instance = {
       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());
   },
@@ -101,4 +104,3 @@ Server.http = function(request, options) {
 };
 
 module.exports = Server;
-

lib/websocket/http_parser.js

@@ -26,15 +26,13 @@ var HttpParser = function(type) {
     self.method     = (typeof info.method === 'number') ? HttpParser.METHODS[info.method] : info.method;
     self.statusCode = info.statusCode;
     self.url        = info.url;
-    
+
     var headers = info.headers;
     if (!headers) return;
 
     for (var i = 0, n = headers.length; i < n; i += 2)
       self.headers[headers[i].toLowerCase()] = headers[i+1];
-  };
 
-  this._parser.onMessageComplete = this._parser[HTTPParser.kOnMessageComplete] = function() {
     self._complete = true;
   };
 };
@@ -78,4 +76,3 @@ HttpParser.prototype.parse = function(data) {
 };
 
 module.exports = HttpParser;
-

lib/websocket/streams.js

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

package.json

@@ -5,7 +5,7 @@
 , "keywords"        : ["websocket"]
 , "license"         : "MIT"
 
-, "version"         : "0.3.4"
+, "version"         : "0.4.0"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/websocket/driver"
 , "devDependencies" : {"jstest": ""}
@@ -18,4 +18,3 @@
 
 , "bugs"            : "http://github.com/faye/websocket-driver-node/issues"
 }
-

spec/runner.js

@@ -42,4 +42,3 @@ require('./websocket/driver/draft75_spec')
 require('./websocket/driver/draft76_spec')
 require('./websocket/driver/hybi_spec')
 require('./websocket/driver/client_spec')
-

spec/websocket/driver/client_spec.js

@@ -50,6 +50,14 @@ 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(
@@ -127,14 +135,75 @@ 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(new Buffer("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")
+        expect(proxy, "emit").given("close")
+        expect(proxy, "emit").given("end")
+        proxy.write(new Buffer("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(new Buffer("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(resume) { with(this) {
-        driver().parse(new Buffer(response()))
-        setTimeout(resume, 10)
-      }})
+      before(function() { this.driver().parse(new Buffer(this.response())) })
 
       it("changes the state to open", function() { with(this) {
         assertEqual( true, open )
@@ -152,12 +221,11 @@ test.describe("Client", function() { with(this) {
     }})
 
     describe("with a valid response followed by a frame", function() { with(this) {
-      before(function(resume) { with(this) {
+      before(function() { 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) {
@@ -172,11 +240,10 @@ test.describe("Client", function() { with(this) {
     }})
 
     describe("with a bad status line", function() { with(this) {
-      before(function(resume) { with(this) {
-        var resp = response().replace(/101/g, "4")
-        driver().parse(new Buffer(resp))
-        setTimeout(resume, 10)
-      }})
+      before(function() {
+        var resp = this.response().replace(/101/g, "4")
+        this.driver().parse(new Buffer(resp))
+      })
 
       it("changes the state to closed", function() { with(this) {
         assertEqual( false, open )
@@ -187,11 +254,10 @@ test.describe("Client", function() { with(this) {
     }})
 
     describe("with a bad Upgrade header", function() { with(this) {
-      before(function(resume) { with(this) {
-        var resp = response().replace(/websocket/g, "wrong")
-        driver().parse(new Buffer(resp))
-        setTimeout(resume, 10)
-      }})
+      before(function() {
+        var resp = this.response().replace(/websocket/g, "wrong")
+        this.driver().parse(new Buffer(resp))
+      })
 
       it("changes the state to closed", function() { with(this) {
         assertEqual( false, open )
@@ -202,11 +268,10 @@ test.describe("Client", function() { with(this) {
     }})
 
     describe("with a bad Accept header", function() { with(this) {
-      before(function(resume) { with(this) {
-        var resp = response().replace(/QV3/g, "wrong")
-        driver().parse(new Buffer(resp))
-        setTimeout(resume, 10)
-      }})
+      before(function() {
+        var resp = this.response().replace(/QV3/g, "wrong")
+        this.driver().parse(new Buffer(resp))
+      })
 
       it("changes the state to closed", function() { with(this) {
         assertEqual( false, open )
@@ -219,11 +284,10 @@ test.describe("Client", function() { with(this) {
     describe("with valid subprotocols", function() { with(this) {
       define("protocols", function() { return ["foo", "xmpp"] })
 
-      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)
-      }})
+      before(function() {
+        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: xmpp\r\n\r\n")
+        this.driver().parse(new Buffer(resp))
+      })
 
       it("changs the state to open", function() { with(this) {
         assertEqual( true, open )
@@ -239,11 +303,10 @@ test.describe("Client", function() { with(this) {
     describe("with invalid subprotocols", function() { with(this) {
       define("protocols", function() { return ["foo", "xmpp"] })
 
-      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)
-      }})
+      before(function() {
+        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: irc\r\n\r\n")
+        this.driver().parse(new Buffer(resp))
+      })
 
       it("changs the state to closed", function() { with(this) {
         assertEqual( false, open )
@@ -258,4 +321,3 @@ test.describe("Client", function() { with(this) {
     }})
   }})
 }})
-

spec/websocket/driver/draft75_examples.js

@@ -112,4 +112,3 @@ test.describe("draft-75", function() { with(this) {
     }})
   }})
 }})
-

spec/websocket/driver/draft75_spec.js

@@ -97,4 +97,3 @@ test.describe("Draft75", function() { with(this) {
 
   itShouldBehaveLike("draft-75 protocol")
 }})
-

spec/websocket/driver/draft76_spec.js

@@ -184,4 +184,3 @@ test.describe("Draft76", function() { with(this) {
     }})
   }})
 }})
-

spec/websocket/driver/hybi_spec.js

@@ -199,54 +199,42 @@ test.describe("Hybi", function() { with(this) {
         return output
       })
 
-      it("parses unmasked text frames", function(resume) { with(this) {
+      it("parses unmasked text frames", function() { with(this) {
         driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        setTimeout(function() {
-          resume(function() { assertEqual( "Hello", message ) })
-        }, 10)
+        assertEqual( "Hello", message )
       }})
 
-      it("parses multiple frames from the same packet", function(resume) { with(this) {
+      it("parses multiple frames from the same packet", function() { with(this) {
         driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        setTimeout(function() {
-          resume(function() { assertEqual( "HelloHello", message ) })
-        }, 10)
+        assertEqual( "HelloHello", message )
       }})
 
-      it("parses empty text frames", function(resume) { with(this) {
+      it("parses empty text frames", function() { with(this) {
         driver().parse([0x81, 0x00])
-        setTimeout(function() {
-          resume(function() { assertEqual( "", message ) })
-        }, 10)
+        assertEqual( "", message )
       }})
 
-      it("parses fragmented text frames", function(resume) { with(this) {
+      it("parses fragmented text frames", function() { with(this) {
         driver().parse([0x01, 0x03, 0x48, 0x65, 0x6c])
         driver().parse([0x80, 0x02, 0x6c, 0x6f])
-        setTimeout(function() {
-          resume(function() { assertEqual( "Hello", message ) })
-        }, 10)
+        assertEqual( "Hello", message )
       }})
 
-      it("parses masked text frames", function(resume) { with(this) {
+      it("parses masked text frames", function() { with(this) {
         driver().parse([0x81, 0x85])
         driver().parse(mask())
         driver().parse(maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
-        setTimeout(function() {
-          resume(function() { assertEqual( "Hello", message ) })
-        }, 10)
+        assertEqual( "Hello", message )
       }})
 
-      it("parses masked empty text frames", function(resume) { with(this) {
+      it("parses masked empty text frames", function() { with(this) {
         driver().parse([0x81, 0x80])
         driver().parse(mask())
         driver().parse(maskMessage([]))
-        setTimeout(function() {
-          resume(function() { assertEqual( "", message ) })
-        }, 10)
+        assertEqual( "", message )
       }})
 
-      it("parses masked fragmented text frames", function(resume) { with(this) {
+      it("parses masked fragmented text frames", function() { with(this) {
         driver().parse([0x01, 0x81])
         driver().parse(mask())
         driver().parse(maskMessage([0x48]))
@@ -255,67 +243,49 @@ test.describe("Hybi", function() { with(this) {
         driver().parse(mask())
         driver().parse(maskMessage([0x65, 0x6c, 0x6c, 0x6f]))
 
-        setTimeout(function() {
-          resume(function() { assertEqual( "Hello", message ) })
-        }, 10)
+        assertEqual( "Hello", message )
       }})
 
-      it("closes the socket if the frame has an unrecognized opcode", function(resume) { with(this) {
+      it("closes the socket if the frame has an unrecognized opcode", function() { with(this) {
         driver().parse([0x83, 0x00])
-        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)
+        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() )
       }})
 
-      it("closes the socket if a close frame is received", function(resume) { with(this) {
+      it("closes the socket if a close frame is received", function() { with(this) {
         driver().parse([0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-        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)
+        assertEqual( [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
+        assertEqual( [1000, "Hello"], close )
+        assertEqual( "closed", driver().getState() )
       }})
 
-      it("parses unmasked multibyte text frames", function(resume) { with(this) {
+      it("parses unmasked multibyte text frames", function() { with(this) {
         driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-        setTimeout(function() {
-          resume(function() { assertEqual( "Apple = ", message ) })
-        }, 10)
+        assertEqual( "Apple = ", message )
       }})
 
-      it("parses frames received in several packets", function(resume) { with(this) {
+      it("parses frames received in several packets", function() { with(this) {
         driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c])
         driver().parse([0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-        setTimeout(function() {
-          resume(function() { assertEqual( "Apple = ", message ) })
-        }, 10)
+        assertEqual( "Apple = ", message )
       }})
 
-      it("parses fragmented multibyte text frames", function(resume) { with(this) {
+      it("parses fragmented multibyte text frames", function() { with(this) {
         driver().parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])
         driver().parse([0x80, 0x01, 0xbf])
-        setTimeout(function() {
-          resume(function() { assertEqual( "Apple = ", message ) })
-        }, 10)
+        assertEqual( "Apple = ", message )
       }})
 
-      it("parse masked multibyte text frames", function(resume) { with(this) {
+      it("parse masked multibyte text frames", function() { with(this) {
         driver().parse([0x81, 0x8b])
         driver().parse(mask())
         driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]))
-        setTimeout(function() {
-          resume(function() { assertEqual( "Apple = ", message ) })
-        }, 10)
+        assertEqual( "Apple = ", message )
       }})
 
-      it("parses masked fragmented multibyte text frames", function(resume) { with(this) {
+      it("parses masked fragmented multibyte text frames", function() { with(this) {
         driver().parse([0x01, 0x8a])
         driver().parse(mask())
         driver().parse(maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]))
@@ -324,35 +294,27 @@ test.describe("Hybi", function() { with(this) {
         driver().parse(mask())
         driver().parse(maskMessage([0xbf]))
 
-        setTimeout(function() {
-          resume(function() { assertEqual( "Apple = ", message ) })
-        }, 10)
+        assertEqual( "Apple = ", message )
       }})
 
-      it("parses unmasked medium-length text frames", function(resume) { with(this) {
+      it("parses unmasked medium-length text frames", function() { with(this) {
         driver().parse([0x81, 0x7e, 0x00, 0xc8])
         var i = 40, result = ""
         while (i--) {
           driver().parse([0x48, 0x65, 0x6c, 0x6c, 0x6f])
           result += "Hello"
         }
-        setTimeout(function() {
-          resume(function() { assertEqual( result, message ) })
-        }, 10)
+        assertEqual( result, message )
       }})
 
-      it("returns an error for too-large frames", function(resume) { with(this) {
+      it("returns an error for too-large frames", function() { with(this) {
         driver().parse([0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00])
-        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)
+        assertEqual( "WebSocket frame length too large", error.message )
+        assertEqual( [1009, "WebSocket frame length too large"], close )
+        assertEqual( "closed", driver().getState() )
       }})
 
-      it("parses masked medium-length text frames", function(resume) { with(this) {
+      it("parses masked medium-length text frames", function() { with(this) {
         driver().parse([0x81, 0xfe, 0x00, 0xc8])
         driver().parse(mask())
         var i = 40, result = "", packet = []
@@ -361,18 +323,12 @@ test.describe("Hybi", function() { with(this) {
           result += "Hello"
         }
         driver().parse(maskMessage(packet))
-        setTimeout(function() {
-          resume(function() { assertEqual( result, message ) })
-        }, 10)
+        assertEqual( result, message )
       }})
 
-      it("replies to pings with a pong", function(resume) { with(this) {
+      it("replies to pings with a pong", function() { with(this) {
         driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
-        setTimeout(function() {
-          resume(function() {
-            assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes )
-          })
-        }, 10)
+        assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes )
       }})
     }})
 
@@ -423,22 +379,18 @@ test.describe("Hybi", function() { with(this) {
         assertEqual( true, driver().ping() )
       }})
 
-      it("runs the given callback on mathing pong", function(resume) { with(this) {
+      it("runs the given callback on mathing pong", function() { with(this) {
         var reply = null
         driver().ping("Hi", function() { reply = true })
         driver().parse([0x8a, 0x02, 72, 105])
-        setTimeout(function() {
-          resume(function() { assert( reply ) })
-        }, 10)
+        assert( reply )
       }})
 
-      it("does not run the callback on non-matching pong", function(resume) { with(this) {
+      it("does not run the callback on non-matching pong", function() { with(this) {
         var reply = null
         driver().ping("Hi", function() { reply = true })
         driver().parse([0x8a, 0x03, 119, 97, 116])
-        setTimeout(function() {
-          resume(function() { assert( !reply ) })
-        }, 10)
+        assert( !reply )
       }})
     }})
 
@@ -475,21 +427,15 @@ test.describe("Hybi", function() { with(this) {
       this.driver().start()
     })
 
-    it("does not emit a message", function(resume) { with(this) {
+    it("does not emit a message", function() { with(this) {
       driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      setTimeout(function() {
-        resume(function() { assertEqual( "", message ) })
-      }, 10)
+      assertEqual( "", message )
     }})
 
-    it("returns an error", function(resume) { with(this) {
+    it("returns an error", function() { with(this) {
       driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      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)
+      assertEqual( "Received unmasked frame but masking is required", error.message )
+      assertEqual( [1003, "Received unmasked frame but masking is required"], close )
     }})
   }})
 
@@ -533,9 +479,8 @@ test.describe("Hybi", function() { with(this) {
     }})
 
     describe("receiving a close frame", function() { with(this) {
-      before(function(resume) {
+      before(function() {
         this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
-        setTimeout(resume, 10)
       })
 
       it("triggers the onclose event", function() { with(this) {
@@ -549,11 +494,10 @@ test.describe("Hybi", function() { with(this) {
   }})
 
   describe("in the closed state", function() { with(this) {
-    before(function(resume) {
+    before(function() {
       this.driver().start()
       this.driver().close()
       this.driver().parse([0x88, 0x02, 0x03, 0xea])
-      setTimeout(resume, 10)
     })
 
     describe("frame", function() { with(this) {
@@ -595,4 +539,3 @@ test.describe("Hybi", function() { with(this) {
     }})
   }})
 }})
-