Bump version to 0.5.0 and document how to add extensions.

This makes the structure of all the state in the parser easier to see,
it makes it easier to free memory by deleting a single struct rather
than many related fields, and it produces some data structures that will
be useful for adding extensions.

.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,24 @@
+### 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
+
 ### 0.3.3 / 2014-04-24
 
 * Correct the draft-76 status line reason phrase
@@ -35,4 +56,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
@@ -14,6 +14,9 @@ hook this module up to some I/O object, it will do all of this for you:
 * 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
@@ -134,17 +137,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 +157,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:
@@ -219,6 +281,13 @@ describing the error.
 Sets the callback to execute when the socket becomes closed. The `event` object
 has `code` and `reason` attributes.
 
+#### `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
@@ -304,4 +373,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

@@ -1,8 +1,10 @@
 var net       = require('net'),
-    websocket = require('../lib/websocket/driver');
+    websocket = require('../lib/websocket/driver'),
+    deflate   = require('permessage-deflate');
 
 var server = net.createServer(function(connection) {
   var driver = websocket.server();
+  driver.addExtension(deflate);
 
   driver.on('connect', function() {
     if (websocket.isWebSocket(driver)) driver.start();
@@ -18,4 +20,3 @@ var server = net.createServer(function(connection) {
 });
 
 server.listen(process.argv[2]);
-

lib/websocket/driver.js

@@ -1,3 +1,5 @@
+'use strict';
+
 // Protocol references:
 // 
 // * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
@@ -35,10 +37,9 @@ var Driver = {
         upgrade    = request.headers.upgrade || '';
 
     return request.method === 'GET' &&
-           connection.toLowerCase().split(/\s*,\s*/).indexOf('upgrade') >= 0 &&
+           connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
            upgrade.toLowerCase() === 'websocket';
   }
 };
 
 module.exports = Driver;
-

lib/websocket/driver/base.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var Emitter = require('events').EventEmitter,
     util    = require('util'),
     streams = require('../streams'),
@@ -9,7 +11,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;
@@ -55,9 +57,13 @@ var instance = {
     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;
   },
 
@@ -123,4 +129,3 @@ Base.MessageEvent = function(data) {
 };
 
 module.exports = Base;
-

lib/websocket/driver/client.js

@@ -1,27 +1,50 @@
-var url        = require('url'),
-    util       = require('util'),
-    HttpParser = require('./http_parser'),
-    Base       = require('./base'),
-    Hybi       = require('./hybi');
+'use strict';
 
-var Client = function(url, options) {
+var crypto     = require('crypto'),
+    url        = require('url'),
+    util       = require('util'),
+    HttpParser = require('../http_parser'),
+    Base       = require('./base'),
+    Hybi       = require('./hybi'),
+    Proxy      = require('./proxy');
+
+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.floor(Math.random() * 256);
-  return buffer.toString('base64');
+  return crypto.randomBytes(16).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 +57,23 @@ var instance = {
 
     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 uri = url.parse(this.url);
+    var extensions = this._extensions.generateOffer();
+    if (extensions)
+      this._headers.set('Sec-WebSocket-Extensions', extensions);
 
-    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'
-                  ];
+    var start   = 'GET ' + this._pathname + ' HTTP/1.1',
+        headers = [start, this._headers.toString(), ''];
 
-    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) {
@@ -101,7 +118,11 @@ var instance = {
         this.protocol = protocol;
     }
 
-    this._open();
+    try {
+      this._extensions.activate(this.headers['sec-websocket-extensions']);
+    } catch (e) {
+      return this._failHandshake(e.message);
+    }
   }
 };
 
@@ -109,4 +130,3 @@ for (var key in instance)
   Client.prototype[key] = instance[key];
 
 module.exports = Client;
-

lib/websocket/driver/draft75.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var Base = require('./base'),
     util = require('util');
 
@@ -5,6 +7,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 +95,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 +118,3 @@ for (var key in instance)
   Draft75.prototype[key] = instance[key];
 
 module.exports = Draft75;
-

lib/websocket/driver/draft76.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var Base    = require('./base'),
     Draft75 = require('./draft75'),
     crypto  = require('crypto'),
@@ -26,6 +28,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 +57,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() {
@@ -63,13 +68,10 @@ var instance = {
     var body = new Buffer(this._body.slice(0, this.BODY_SIZE));
 
     var headers = this._request.headers,
-
         key1    = headers['sec-websocket-key1'],
         value1  = numberFromKey(key1) / spacesInKey(key1),
-
         key2    = headers['sec-websocket-key2'],
         value2  = numberFromKey(key2) / spacesInKey(key2),
-
         md5     = crypto.createHash('md5');
 
     md5.update(bigEndian(value1));
@@ -106,4 +108,3 @@ for (var key in instance)
   Draft76.prototype[key] = instance[key];
 
 module.exports = Draft76;
-

lib/websocket/driver/headers.js

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

lib/websocket/driver/hybi.js

@@ -1,32 +1,50 @@
-var crypto   = require('crypto'),
-    util     = require('util'),
-    Base     = require('./base'),
-    Reader   = require('./hybi/stream_reader');
+'use strict';
+
+var crypto     = require('crypto'),
+    util       = require('util'),
+    Extensions = require('websocket-extensions'),
+    Base       = require('./base'),
+    Frame      = require('./hybi/frame'),
+    Message    = require('./hybi/message'),
+    Reader     = require('./hybi/stream_reader');
 
 var Hybi = function(request, url, options) {
   Base.apply(this, arguments);
-  this._reset();
-
-  this._reader    = new Reader();
-  this._stage     = 0;
-  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._reader         = new Reader();
+  this._stage          = 0;
+  this._masking        = this._options.masking;
+  this._protocols      = this._options.protocols || [];
   this._requireMasking = this._options.requireMasking;
   this._pingCallbacks  = {};
 
-  if (!this.version) {
-    var version = this._request.headers['sec-websocket-version'];
-    this.version = 'hybi-' + version;
+  if (typeof this._protocols === 'string')
+    this._protocols = this._protocols.split(/ *, */);
+
+  if (!this._request) return;
+
+  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(/ *, */);
+    this.protocol = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
+    if (this.protocol) this._headers.set('Sec-WebSocket-Protocol', this.protocol);
   }
+
+  this.version = 'hybi-' + version;
 };
 util.inherits(Hybi, Base);
 
 Hybi.mask = function(payload, mask, offset) {
-  if (mask.length === 0) return payload;
+  if (!mask || mask.length === 0) return payload;
   offset = offset || 0;
 
   for (var i = 0, n = payload.length - offset; i < n; i++) {
@@ -62,9 +80,9 @@ var instance = {
     pong:         10
   },
 
-  OPCODE_CODES:       [0, 1, 2, 8, 9, 10],
-  FRAGMENTED_OPCODES: [0, 1, 2],
-  OPENING_OPCODES:    [1, 2],
+  OPCODE_CODES:    [0, 1, 2, 8, 9, 10],
+  MESSAGE_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) }),
 
@@ -87,6 +105,11 @@ var instance = {
   // 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);
+    return true;
+  },
+
   parse: function(data) {
     this._reader.put(data);
     var buffer = true;
@@ -103,23 +126,22 @@ var instance = {
           break;
 
         case 2:
-          buffer = this._reader.read(this._lengthSize);
+          buffer = this._reader.read(this._frame.lengthBytes);
           if (buffer) this._parseExtendedLength(buffer);
           break;
 
         case 3:
           buffer = this._reader.read(4);
           if (buffer) {
-            this._mask  = buffer;
+            this._frame.maskingKey = buffer;
             this._stage = 4;
           }
           break;
 
         case 4:
-          buffer = this._reader.read(this._length);
+          buffer = this._reader.read(this._frame.length);
           if (buffer) {
-            this._payload = buffer;
-            this._emitFrame();
+            this._emitFrame(buffer);
             this._stage = 0;
           }
           break;
@@ -130,61 +152,6 @@ var instance = {
     }
   },
 
-  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] = Math.floor(length / 256);
-      frame[3] = length & BYTE;
-    } else {
-      frame[1] = masked | 127;
-      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]   = Math.floor(code / 256) & BYTE;
-      frame[offset+1] = code & BYTE;
-    }
-    buffer.copy(frame, offset + insert);
-
-    if (this._masking) {
-      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);
-      Hybi.mask(frame, mask, offset);
-    }
-
-    this._write(frame);
-    return true;
-  },
-
   text: function(message) {
     return this.frame(message, 'text');
   },
@@ -203,7 +170,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;
@@ -216,39 +183,118 @@ var instance = {
     }
   },
 
-  _handshakeResponse: function() {
-    var secKey = this._request.headers['sec-websocket-key'];
-    if (!secKey) return '';
+  frame: function(data, type, code) {
+    if (this.readyState <= 0) return this._queue([data, type, code]);
+    if (this.readyState !== 1) return false;
 
-    var accept    = Hybi.generateAccept(secKey),
-        protos    = this._request.headers['sec-websocket-protocol'],
-        supported = this._protocols,
-        proto,
+    if (data instanceof Array) data = new Buffer(data);
 
-        headers = [
-          'HTTP/1.1 101 Switching Protocols',
-          'Upgrade: websocket',
-          'Connection: Upgrade',
-          'Sec-WebSocket-Accept: ' + accept
-        ];
+    var message = new Message(),
+        isText  = (typeof data === 'string'),
+        payload, buffer;
 
-    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);
-      }
+    message.rsv1   = message.rsv2 = message.rsv3 = false;
+    message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
+
+    payload = isText ? new Buffer(data, 'utf8') : data;
+
+    if (code) {
+      buffer = payload;
+      payload = new Buffer(2 + buffer.length);
+      payload[0] = ~~(code / 256) & this.BYTE;
+      payload[1] = code & this.BYTE;
+      buffer.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 = new Buffer(offset + length),
+        BYTE   = this.BYTE,
+        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[2] = ~~(length / 256);
+      buffer[3] = length & BYTE;
+    } else {
+      buffer[1] = masked | 127;
+      buffer[2] = ~~(length / Math.pow(2, 56)) & BYTE;
+      buffer[3] = ~~(length / Math.pow(2, 48)) & BYTE;
+      buffer[4] = ~~(length / Math.pow(2, 40)) & BYTE;
+      buffer[5] = ~~(length / Math.pow(2, 32)) & BYTE;
+      buffer[6] = ~~(length / Math.pow(2, 24)) & BYTE;
+      buffer[7] = ~~(length / Math.pow(2, 16)) & BYTE;
+      buffer[8] = ~~(length / Math.pow(2, 8))  & BYTE;
+      buffer[9] = length & BYTE;
     }
 
-    return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
+    if (frame.masked) {
+      frame.maskingKey.copy(buffer, header);
+      Hybi.mask(frame.payload, frame.maskingKey).copy(buffer, offset);
+    } else {
+      frame.payload.copy(buffer, offset);
+    }
+
+    this._write(buffer);
+  },
+
+  _handshakeResponse: function() {
+    var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
+    if (extensions) this._headers.set('Sec-WebSocket-Extensions', extensions);
+
+    var start   = 'HTTP/1.1 101 Switching Protocols',
+        headers = [start, this._headers.toString(), ''];
+
+    return new Buffer(headers.join('\r\n'), 'utf8');
   },
 
   _shutdown: function(code, reason) {
     this.frame(reason, 'close', code);
+    delete this._frame;
+    delete this._message;
     this.readyState = 3;
     this._stage = 5;
     this.emit('close', new Base.CloseEvent(code, reason));
+    this._extensions.close();
   },
 
   _fail: function(type, message) {
@@ -261,58 +307,66 @@ var instance = {
       return (data & rsv) === rsv;
     });
 
-    if (rsvs.filter(function(rsv) { return rsv }).length > 0)
+    var frame = this._frame = new Frame();
+
+    frame.final  = (data & this.FIN) === this.FIN;
+    frame.rsv1   = rsvs[0];
+    frame.rsv2   = rsvs[1];
+    frame.rsv3   = rsvs[2];
+    frame.opcode = (data & this.OPCODE);
+
+    if (!this._extensions.validFrameRsv(frame))
       return this._fail('protocol_error',
-          'One or more reserved bits are on: reserved1 = ' + (rsvs[0] ? 1 : 0) +
-          ', reserved2 = ' + (rsvs[1] ? 1 : 0) +
-          ', reserved3 = ' + (rsvs[2] ? 1 : 0));
+          'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) +
+          ', reserved2 = ' + (frame.rsv2 ? 1 : 0) +
+          ', reserved3 = ' + (frame.rsv3 ? 1 : 0));
 
-    this._final   = (data & this.FIN) === this.FIN;
-    this._opcode  = (data & this.OPCODE);
-    this._mask    = [];
-    this._payload = [];
+    if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
+      return this._fail('protocol_error', 'Unrecognized 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_OPCODES.indexOf(frame.opcode) < 0 && !frame.final)
+      return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + frame.opcode);
 
-    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)
+    if (this._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
       return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
 
     this._stage = 1;
   },
 
   _parseLength: function(data) {
-    this._masked = (data & this.MASK) === this.MASK;
-    if (this._requireMasking && !this._masked)
+    var frame = this._frame;
+
+    frame.masked = (data & this.MASK) === this.MASK;
+    if (this._requireMasking && !frame.masked)
       return this._fail('unacceptable', 'Received unmasked frame but masking is required');
 
-    this._length = (data & this.LENGTH);
+    frame.length = (data & this.LENGTH);
 
-    if (this._length >= 0 && this._length <= 125) {
+    if (frame.length >= 0 && frame.length <= 125) {
       if (!this._checkFrameLength()) return;
-      this._stage = this._masked ? 3 : 4;
+      this._stage = frame.masked ? 3 : 4;
     } else {
-      this._lengthSize = (this._length === 126 ? 2 : 8);
-      this._stage      = 2;
+      frame.lengthBytes = (frame.length === 126 ? 2 : 8);
+      this._stage = 2;
     }
   },
 
   _parseExtendedLength: function(buffer) {
-    this._length = this._getInteger(buffer);
+    var frame = this._frame;
+    frame.length = this._getInteger(buffer);
 
-    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.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._checkFrameLength()) return;
 
-    this._stage  = this._masked ? 3 : 4;
+    this._stage  = frame.masked ? 3 : 4;
   },
 
   _checkFrameLength: function() {
-    if (this.__blength + this._length > this._maxLength) {
+    var length = this._message ? this._message.length : 0;
+
+    if (length + this._frame.length > this._maxLength) {
       this._fail('too_large', 'WebSocket frame length too large');
       return false;
     } else {
@@ -320,46 +374,32 @@ var instance = {
     }
   },
 
-  _emitFrame: function() {
-    var payload = Hybi.mask(this._payload, this._mask),
-        opcode  = this._opcode;
+  _emitFrame: function(buffer) {
+    var frame   = this._frame,
+        payload = frame.payload = Hybi.mask(buffer, frame.maskingKey),
+        opcode  = frame.opcode,
+        message,
+        code, reason,
+        callbacks, callback;
+
+    delete this._frame;
 
     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 = this._concatBuffer();
-        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 (!this._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
+      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 (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
+      this._message = new Message();
+      this._message.pushFrame(frame);
     }
-    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 (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
+      return this._emitMessage(this._message);
+
+    if (opcode === this.OPCODES.close) {
+      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) &&
@@ -371,39 +411,38 @@ var instance = {
 
       this._shutdown(code, reason || '');
     }
-    else if (opcode === this.OPCODES.ping) {
+
+    if (opcode === this.OPCODES.ping) {
       this.frame(payload, 'pong');
     }
-    else if (opcode === this.OPCODES.pong) {
-      var callbacks = this._pingCallbacks,
-          message   = this._encode(payload),
-          callback  = callbacks[message];
+
+    if (opcode === this.OPCODES.pong) {
+      callbacks = this._pingCallbacks;
+      message   = this._encode(payload);
+      callback  = callbacks[message];
 
       delete callbacks[message];
       if (callback) callback()
     }
   },
 
-  _buffer: function(fragment) {
-    this.__buffer.push(fragment);
-    this.__blength += fragment.length;
-  },
+  _emitMessage: function(message) {
+    var message = this._message;
+    message.read();
 
-  _concatBuffer: function() {
-    var buffer = new Buffer(this.__blength),
-        offset = 0;
+    delete this._message;
 
-    for (var i = 0, n = this.__buffer.length; i < n; i++) {
-      this.__buffer[i].copy(buffer, offset);
-      offset += this.__buffer[i].length;
-    }
-    return buffer;
-  },
+    this._extensions.processIncomingMessage(message, function(error, message) {
+      if (error) return this._fail('extension_error', error.message);
 
-  _reset: function() {
-    this._mode     = null;
-    this.__buffer  = [];
-    this.__blength = 0;
+      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);
   },
 
   _encode: function(buffer) {
@@ -426,4 +465,3 @@ for (var key in instance)
   Hybi.prototype[key] = instance[key];
 
 module.exports = Hybi;
-

lib/websocket/driver/hybi/frame.js

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

lib/websocket/driver/hybi/message.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var Message = function() {
+  this.rsv1    = false;
+  this.rsv2    = false;
+  this.rsv3    = false;
+  this.opcode  = null
+  this.length  = 0;
+  this._chunks = [];
+};
+
+var instance = {
+  read: function() {
+    if (this.data) return this.data;
+
+    this.data  = new Buffer(this.length);
+    var offset = 0;
+
+    for (var i = 0, n = this._chunks.length; i < n; i++) {
+      this._chunks[i].copy(this.data, offset);
+      offset += this._chunks[i].length;
+    }
+    return this.data;
+  },
+
+  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;

lib/websocket/driver/hybi/stream_reader.js

@@ -1,13 +1,11 @@
+'use strict';
+
 var StreamReader = function() {
   this._queue     = [];
   this._queueSize = 0;
   this._cursor    = 0;
 };
 
-StreamReader.prototype.read = function(bytes) {
-  return this._readBuffer(bytes);
-};
-
 StreamReader.prototype.put = function(buffer) {
   if (!buffer || buffer.length === 0) return;
   if (!buffer.copy) buffer = new Buffer(buffer);
@@ -15,7 +13,7 @@ StreamReader.prototype.put = function(buffer) {
   this._queueSize += buffer.length;
 };
 
-StreamReader.prototype._readBuffer = function(length) {
+StreamReader.prototype.read = function(length) {
   if (length > this._queueSize) return null;
 
   var buffer = new Buffer(length),
@@ -23,22 +21,22 @@ StreamReader.prototype._readBuffer = function(length) {
       remain = length,
       n      = queue.length,
       i      = 0,
-      chunk, offset, size;
-
-  if (remain === 0) return buffer;
+      chunk, size;
 
   while (remain > 0 && i < n) {
     chunk = queue[i];
-    offset = (i === 0) ? this._cursor : 0;
-    size = Math.min(remain, chunk.length - offset);
-    chunk.copy(buffer, length - remain, offset, offset + size);
-    remain -= size;
+    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, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
+  queue.splice(0, this._cursor === 0 ? i : i - 1);
 
   return buffer;
 };

lib/websocket/driver/proxy.js

@@ -0,0 +1,97 @@
+'use strict';
+
+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,7 @@
+'use strict';
+
 var util       = require('util'),
-    HttpParser = require('./http_parser'),
+    HttpParser = require('../http_parser'),
     Base       = require('./base'),
     Draft75    = require('./draft75'),
     Draft76    = require('./draft76'),
@@ -34,12 +36,15 @@ var instance = {
     this._delegate = Server.http(this, this._options);
     this._delegate.messages = this.messages;
     this._delegate.io = this.io;
+    this._open();
 
-    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());
   },
@@ -52,7 +57,7 @@ var instance = {
   }
 };
 
-['setHeader', 'start', 'state', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
+['addExtension', 'setHeader', 'start', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
   instance[method] = function() {
     if (this._delegate) {
       return this._delegate[method].apply(this._delegate, arguments);
@@ -101,4 +106,3 @@ Server.http = function(request, options) {
 };
 
 module.exports = Server;
-

lib/websocket/http_parser.js

@@ -1,3 +1,5 @@
+'use strict';
+
 var HTTPParser = process.binding('http_parser').HTTPParser,
     version    = HTTPParser.RESPONSE ? 6 : 4;
 
@@ -19,22 +21,31 @@ var HttpParser = function(type) {
   };
 
   this._parser.onHeaderValue = function(b, start, length) {
-    self.headers[current] = b.toString('utf8', start, 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[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;
+
+    var headers = info.headers, key, value;
     if (!headers) return;
 
-    for (var i = 0, n = headers.length; i < n; i += 2)
-      self.headers[headers[i].toLowerCase()] = headers[i+1];
-  };
+    for (var i = 0, n = headers.length; 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;
+    }
 
-  this._parser.onMessageComplete = this._parser[HTTPParser.kOnMessageComplete] = function() {
     self._complete = true;
   };
 };
@@ -78,4 +89,3 @@ HttpParser.prototype.parse = function(data) {
 };
 
 module.exports = HttpParser;
-

lib/websocket/streams.js

@@ -1,3 +1,5 @@
+'use strict';
+
 /**
 
 Streams in a WebSocket connection
@@ -141,4 +143,3 @@ Messages.prototype.destroy = function() {};
 
 exports.IO = IO;
 exports.Messages = Messages;
-

package.json

@@ -5,10 +5,11 @@
 , "keywords"        : ["websocket"]
 , "license"         : "MIT"
 
-, "version"         : "0.3.3"
-, "engines"         : {"node": ">=0.4.0"}
+, "version"         : "0.5.0"
+, "engines"         : {"node": ">=0.6.0"}
 , "main"            : "./lib/websocket/driver"
-, "devDependencies" : {"jstest": ""}
+, "dependencies"    : {"websocket-extensions": ">=0.1.0"}
+, "devDependencies" : {"jstest": "", "permessage-deflate": ""}
 
 , "scripts"         : {"test": "jstest spec/runner.js"}
 
@@ -18,4 +19,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,6 +135,70 @@ 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() })
 
@@ -249,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

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