Bump version to 0.6.3.

viz.: https://github.com/faye/websocket-extensions-node/commit/1b77290e8279f654089eac963942309fb19b9312

.travis.yml

@@ -1,11 +1,16 @@
+sudo: false
 language: node_js
 
 node_js:
   - "0.6"
   - "0.8"
   - "0.10"
-  - "0.11"
+  - "0.12"
+  - "iojs-1"
+  - "iojs-2"
+  - "iojs-3"
+  - "4"
+  - "5"
 
 before_install:
   - '[ "${TRAVIS_NODE_VERSION}" = "0.6" ] && npm conf set strict-ssl false || true'
-

CHANGELOG.md

@@ -1,95 +1,102 @@
-### 0.7.2 / 2013-12-29
+### 0.6.3 / 2015-11-06
 
-* Make sure the `close` event is emitted by clients on Node v0.10
+* Reject draft-76 handshakes if their Sec-WebSocket-Key headers are invalid
+* Throw a more helpful error if a client is created with an invalid URL
 
+### 0.6.2 / 2015-07-18
 
-### 0.7.1 / 2013-12-03
+* When the peer sends a close frame with no error code, emit 1000
 
-* Support the `maxLength` websocket-driver option
-* Make the client emit `error` events on network errors
+### 0.6.1 / 2015-07-13
 
+* Use the `buffer.{read,write}UInt{16,32}BE` methods for reading/writing numbers
+  to buffers rather than including duplicate logic for this
 
-### 0.7.0 / 2013-09-09
+### 0.6.0 / 2015-07-08
 
-* Allow the server to send custom headers with EventSource responses
+* Allow the parser to recover cleanly if event listeners raise an error
+* Add a `pong` method for sending unsolicited pong frames
 
+### 0.5.4 / 2015-03-29
 
-### 0.6.1 / 2013-07-05
+* Don't emit extra close frames if we receive a close frame after we already
+  sent one
+* Fail the connection when the driver receives an invalid
+  `Sec-WebSocket-Extensions` header
 
-* Add `ca` option to the client for specifying certificate authorities
-* Start the server driver asynchronously so that `onopen` handlers can be added
+### 0.5.3 / 2015-02-22
 
+* Don't treat incoming data as WebSocket frames if a client driver is closed
+  before receiving the server handshake
 
-### 0.6.0 / 2013-05-12
+### 0.5.2 / 2015-02-19
 
-* Add support for custom headers
+* Fix compatibility with the HTTP parser on io.js
+* Use `websocket-extensions` to make sure messages and close frames are kept in
+  order
+* Don't emit multiple `error` events
 
+### 0.5.1 / 2014-12-18
 
-### 0.5.0 / 2013-05-05
+* Don't allow drivers to be created with unrecognized options
 
-* Extract the protocol handlers into the `websocket-driver` library
-* Support the Node streaming API
+### 0.5.0 / 2014-12-13
 
+* Support protocol extensions via the websocket-extensions module
 
-### 0.4.4 / 2013-02-14
+### 0.4.0 / 2014-11-08
 
-* Emit the `close` event if TCP is closed before CLOSE frame is acked
+* Support connection via HTTP proxies using `CONNECT`
 
+### 0.3.6 / 2014-10-04
 
-### 0.4.3 / 2012-07-09
+* It is now possible to call `close()` before `start()` and close the driver
 
-* Add `Connection: close` to EventSource response
-* Handle situations where `request.socket` is undefined
+### 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.4.2 / 2012-04-06
+### 0.3.4 / 2014-05-08
 
-* Add WebSocket error code `1011`.
-* Handle URLs with no path correctly by sending `GET /`
+* Don't hold memory-leaking references to I/O buffers after they have been
+  parsed
 
+### 0.3.3 / 2014-04-24
 
-### 0.4.1 / 2012-02-26
+* Correct the draft-76 status line reason phrase
 
-* Treat anything other than a `Buffer` as a string when calling `send()`
+### 0.3.2 / 2013-12-29
 
+* Expand `maxLength` to cover sequences of continuation frames and
+  `draft-{75,76}`
+* Decrease default maximum frame buffer size to 64MB
+* Stop parsing when the protocol enters a failure mode, to save CPU cycles
 
-### 0.4.0 / 2012-02-13
+### 0.3.1 / 2013-12-03
 
-* Add `ping()` method to server-side `WebSocket` and `EventSource`
-* Buffer `send()` calls until the draft-76 handshake is complete
-* Fix HTTPS problems on Node 0.7
+* Add a `maxLength` option to limit allowed frame size
+* Don't pre-allocate a message buffer until the whole frame has arrived
+* Fix compatibility with Node v0.11 `HTTPParser`
 
+### 0.3.0 / 2013-09-09
 
-### 0.3.1 / 2012-01-16
+* Support client URLs with Basic Auth credentials
 
-* Call `setNoDelay(true)` on `net.Socket` objects to reduce latency
+### 0.2.2 / 2013-07-05
 
+* No functional changes, just updates to package.json
 
-### 0.3.0 / 2012-01-13
+### 0.2.1 / 2013-05-17
 
-* Add support for `EventSource` connections
+* Export the isSecureRequest() method since faye-websocket relies on it
+* Queue sent messages in the client's initial state
 
+### 0.2.0 / 2013-05-12
 
-### 0.2.0 / 2011-12-21
+* Add API for setting and reading headers
+* Add Driver.server() method for getting a driver for TCP servers
 
-* Add support for `Sec-WebSocket-Protocol` negotiation
-* Support `hixie-76` close frames and 75/76 ignored segments
-* Improve performance of HyBi parsing/framing functions
-* Decouple parsers from TCP and reduce write volume
-
-
-### 0.1.2 / 2011-12-05
-
-* Detect closed sockets on the server side when TCP connection breaks
-* Make `hixie-76` sockets work through HAProxy
-
-
-### 0.1.1 / 2011-11-30
-
-* Fix `addEventListener()` interface methods
-
-
-### 0.1.0 / 2011-11-27
-
-* Initial release, based on WebSocket components from Faye
+### 0.1.0 / 2013-05-04
 
+* First stable release

README.md

@@ -1,295 +1,383 @@
-# faye-websocket
+# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.svg)](https://travis-ci.org/faye/websocket-driver-node)
 
-* Travis CI build: [![Build
-  status](https://secure.travis-ci.org/faye/faye-websocket-node.png)](http://travis-ci.org/faye/faye-websocket-node)
-* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/),
-  [client](http://faye.jcoglan.com/autobahn/clients/)
+This module provides a complete implementation of the WebSocket protocols that
+can be hooked up to any I/O stream. It aims to simplify things by decoupling the
+protocol details from the I/O layer, such that users only need to implement code
+to stream data in and out of it without needing to know anything about how the
+protocol actually works. Think of it as a complete WebSocket system with
+pluggable I/O.
 
-This is a general-purpose WebSocket implementation extracted from the
-[Faye](http://faye.jcoglan.com) project. It provides classes for easily
-building WebSocket servers and clients in Node. It does not provide a server
-itself, but rather makes it easy to handle WebSocket connections within an
-existing [Node](http://nodejs.org/) application. It does not provide any
-abstraction other than the standard [WebSocket
-API](http://dev.w3.org/html5/websockets/).
+Due to this design, you get a lot of things for free. In particular, if you hook
+this module up to some I/O object, it will do all of this for you:
 
-It also provides an abstraction for handling
-[EventSource](http://dev.w3.org/html5/eventsource/) connections, which are
-one-way connections that allow the server to push data to the client. They are
-based on streaming HTTP responses and can be easier to access via proxies than
-WebSockets.
+* Select the correct server-side driver to talk to the client
+* Generate and send both server- and client-side handshakes
+* Recognize when the handshake phase completes and the WS protocol begins
+* Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
+* Negotiate and use extensions via the
+  [websocket-extensions](https://github.com/faye/websocket-extensions-node)
+  module
+* Buffer sent messages until the handshake process is finished
+* Deal with proxies that defer delivery of the draft-76 handshake body
+* Notify you when the socket is open and closed and when messages arrive
+* Recombine fragmented messages
+* Dispatch text, binary, ping, pong and close frames
+* Manage the socket-closing handshake process
+* Automatically reply to ping frames with a matching pong
+* Apply masking to messages sent by the client
+
+This library was originally extracted from the [Faye](http://faye.jcoglan.com)
+project but now aims to provide simple WebSocket support for any Node-based
+project.
 
 
 ## Installation
 
 ```
-$ npm install faye-websocket
+$ npm install websocket-driver
 ```
 
 
-## Handling WebSocket connections in Node
+## Usage
 
-You can handle WebSockets on the server side by listening for HTTP Upgrade
-requests, and creating a new socket for the request. This socket object exposes
-the usual WebSocket methods for receiving and sending messages. For example this
-is how you'd implement an echo server:
+This module provides protocol drivers that have the same interface on the server
+and on the client. A WebSocket driver is an object with two duplex streams
+attached; one for incoming/outgoing messages and one for managing the wire
+protocol over an I/O stream. The full API is described below.
+
+
+### Server-side with HTTP
+
+A Node webserver emits a special event for 'upgrade' requests, and this is where
+you should handle WebSockets. You first check whether the request is a
+WebSocket, and if so you can create a driver and attach the request's I/O stream
+to it.
 
 ```js
-var WebSocket = require('faye-websocket'),
-    http      = require('http');
+var http = require('http'),
+    websocket = require('websocket-driver');
 
 var server = http.createServer();
 
 server.on('upgrade', function(request, socket, body) {
-  if (WebSocket.isWebSocket(request)) {
-    var ws = new WebSocket(request, socket, body);
-    
-    ws.on('message', function(event) {
-      ws.send(event.data);
-    });
-    
-    ws.on('close', function(event) {
-      console.log('close', event.code, event.reason);
-      ws = null;
-    });
-  }
-});
+  if (!websocket.isWebSocket(request)) return;
 
-server.listen(8000);
-```
+  var driver = websocket.http(request);
 
-`WebSocket` objects are also duplex streams, so you could replace the
-`ws.on('message', ...)` line with:
+  driver.io.write(body);
+  socket.pipe(driver.io).pipe(socket);
 
-```js
-    ws.pipe(ws);
-```
+  driver.messages.on('data', function(message) {
+    console.log('Got a message', message);
+  });
 
-Note that under certain circumstances (notably a draft-76 client connecting
-through an HTTP proxy), the WebSocket handshake will not be complete after you
-call `new WebSocket()` because the server will not have received the entire
-handshake from the client yet. In this case, calls to `ws.send()` will buffer
-the message in memory until the handshake is complete, at which point any
-buffered messages will be sent to the client.
-
-If you need to detect when the WebSocket handshake is complete, you can use the
-`onopen` event.
-
-If the connection's protocol version supports it, you can call `ws.ping()` to
-send a ping message and wait for the client's response. This method takes a
-message string, and an optional callback that fires when a matching pong
-message is received. It returns `true` iff a ping message was sent. If the
-client does not support ping/pong, this method sends no data and returns
-`false`.
-
-```js
-ws.ping('Mic check, one, two', function() {
-  // fires when pong is received
+  driver.start();
 });
 ```
 
+Note the line `driver.io.write(body)` - you must pass the `body` buffer to the
+socket driver in order to make certain versions of the protocol work.
 
-## Using the WebSocket client
 
-The client supports both the plain-text `ws` protocol and the encrypted `wss`
-protocol, and has exactly the same interface as a socket you would use in a web
-browser. On the wire it identifies itself as `hybi-13`.
+### Server-side with TCP
+
+You can also handle WebSocket connections in a bare TCP server, if you're not
+using an HTTP server and don't want to implement HTTP parsing yourself.
+
+The driver will emit a `connect` event when a request is received, and at this
+point you can detect whether it's a WebSocket and handle it as such. Here's an
+example using the Node `net` module:
 
 ```js
-var WebSocket = require('faye-websocket'),
-    ws        = new WebSocket.Client('ws://www.example.com/');
+var net = require('net'),
+    websocket = require('websocket-driver');
 
-ws.on('open', function(event) {
-  console.log('open');
-  ws.send('Hello, world!');
+var server = net.createServer(function(connection) {
+  var driver = websocket.server();
+
+  driver.on('connect', function() {
+    if (websocket.isWebSocket(driver)) {
+      driver.start();
+    } else {
+      // handle other HTTP requests
+    }
+  });
+
+  driver.on('close', function() { connection.end() });
+  connection.on('error', function() {});
+
+  connection.pipe(driver.io).pipe(connection);
+
+  driver.messages.pipe(driver.messages);
 });
 
-ws.on('message', function(event) {
-  console.log('message', event.data);
+server.listen(4180);
+```
+
+In the `connect` event, the driver gains several properties to describe the
+request, similar to a Node request object, such as `method`, `url` and
+`headers`. However you should remember it's not a real request object; you
+cannot write data to it, it only tells you what request data we parsed from the
+input.
+
+If the request has a body, it will be in the `driver.body` buffer, but only as
+much of the body as has been piped into the driver when the `connect` event
+fires.
+
+
+### Client-side
+
+Similarly, to implement a WebSocket client you just need to make a driver by
+passing in a URL. After this you use the driver API as described below to
+process incoming data and send outgoing data.
+
+
+```js
+var net = require('net'),
+    websocket = require('websocket-driver');
+
+var driver = websocket.client('ws://www.example.com/socket'),
+    tcp = net.connect(80, 'www.example.com');
+
+tcp.pipe(driver.io).pipe(tcp);
+
+tcp.on('connect', function() {
+  driver.start();
 });
 
-ws.on('close', function(event) {
-  console.log('close', event.code, event.reason);
-  ws = null;
+driver.messages.on('data', function(message) {
+  console.log('Got a message', message);
 });
 ```
 
-The WebSocket client also lets you inspect the status and headers of the
-handshake response via its `statusCode` and `headers` properties.
+Client drivers have two additional properties for reading the HTTP data that was
+sent back by the server:
+
+* `driver.statusCode` - the integer value of the HTTP status code
+* `driver.headers` - an object containing the response headers
 
 
-## Subprotocol negotiation
+### HTTP Proxies
 
-The WebSocket protocol allows peers to select and identify the application
-protocol to use over the connection. On the client side, you can set which
-protocols the client accepts by passing a list of protocol names when you
-construct the socket:
+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 ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
+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);
+});
 ```
 
-On the server side, you can likewise pass in the list of protocols the server
-supports after the other constructor arguments:
+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
-var ws = new WebSocket(request, socket, body, ['irc', 'amqp']);
+proxy.on('error', function(error) {
+  console.error(error.message);
+  console.log(proxy.statusCode);
+  console.log(proxy.headers);
+});
 ```
 
-If the client and server agree on a protocol, both the client- and server-side
-socket objects expose the selected protocol through the `ws.protocol` property.
-
-
-## Initialization options
-
-Both the server- and client-side classes allow an options object to be passed
-in at initialization time, for example:
+Before calling `proxy.start()` you can set custom headers using
+`proxy.setHeader()`:
 
 ```js
-var ws = new WebSocket(request, socket, body, protocols, options);
-var ws = new WebSocket.Client(url, protocols, options);
+proxy.setHeader('User-Agent', 'node');
+proxy.start();
 ```
 
-`protocols` is an array of subprotocols as described above, or `null`.
-`options` is an optional object containing any of these fields:
 
-* `headers` - an object containing key-value pairs representing HTTP headers to
-  be sent during the handshake process
+### Driver API
+
+Drivers are created using one of the following methods:
+
+```js
+driver = websocket.http(request, options)
+driver = websocket.server(options)
+driver = websocket.client(url, options)
+```
+
+The `http` method returns a driver chosen using the headers from a Node HTTP
+request object. The `server` method returns a driver that will parse an HTTP
+request and then decide which driver to use for it using the `http` method. The
+`client` method always returns a driver for the RFC version of the protocol with
+masking enabled on outgoing frames.
+
+The `options` argument is optional, and is an object. It may contain the
+following fields:
+
 * `maxLength` - the maximum allowed size of incoming message frames, in bytes.
   The default value is `2^26 - 1`, or 1 byte short of 64 MiB.
-* `ping` - an integer that sets how often the WebSocket should send ping
-  frames, measured in seconds
+* `protocols` - an array of strings representing acceptable subprotocols for use
+  over the socket. The driver will negotiate one of these to use via the
+  `Sec-WebSocket-Protocol` header if supported by the other peer.
 
+A driver has two duplex streams attached to it:
 
-## WebSocket API
+* <b>`driver.io`</b> - this stream should be attached to an I/O socket like a
+  TCP stream. Pipe incoming TCP chunks to this stream for them to be parsed, and
+  pipe this stream back into TCP to send outgoing frames.
+* <b>`driver.messages`</b> - this stream emits messages received over the
+  WebSocket.  Writing to it sends messages to the other peer by emitting frames
+  via the `driver.io` stream.
 
-Both server- and client-side `WebSocket` objects support the following API.
+All drivers respond to the following API methods, but some of them are no-ops
+depending on whether the client supports the behaviour.
 
-* <b>`on('open', function(event) {})`</b> fires when the socket connection is
-  established. Event has no attributes.
-* <b>`on('message', function(event) {})`</b> fires when the socket receives a
-  message. Event has one attribute, <b>`data`</b>, which is either a `String`
-  (for text frames) or a `Buffer` (for binary frames).
-* <b>`on('error', function(event) {})`</b> fires when there is a protocol error
-  due to bad data sent by the other peer. This event is purely informational,
-  you do not need to implement error recover.
-* <b>`on('close', function(event) {})`</b> fires when either the client or the
-  server closes the connection. Event has two optional attributes,
-  <b>`code`</b> and <b>`reason`</b>, that expose the status code and message
-  sent by the peer that closed the connection.
-* <b>`send(message)`</b> accepts either a `String` or a `Buffer` and sends a
-  text or binary message over the connection to the other peer.
-* <b>`ping(message = '', function() {})`</b> sends a ping frame with an
-  optional message and fires the callback when a matching pong is received.
-* <b>`close(code, reason)`</b> closes the connection, sending the given status
-  code and reason text, both of which are optional.
-* <b>`version`</b> is a string containing the version of the `WebSocket`
-  protocol the connection is using.
-* <b>`protocol`</b> is a string (which may be empty) identifying the
-  subprotocol the socket is using.
+Note that most of these methods are commands: if they produce data that should
+be sent over the socket, they will give this to you by emitting `data` events on
+the `driver.io` stream.
 
+#### `driver.on('open', function(event) {})`
 
-## Handling EventSource connections in Node
+Adds a callback to execute when the socket becomes open.
 
-EventSource connections provide a very similar interface, although because they
-only allow the server to send data to the client, there is no `onmessage` API.
-EventSource allows the server to push text messages to the client, where each
-message has an optional event-type and ID.
+#### `driver.on('message', function(event) {})`
 
-```js
-var WebSocket   = require('faye-websocket'),
-    EventSource = WebSocket.EventSource,
-    http        = require('http');
+Adds a callback to execute when a message is received. `event` will have a
+`data` attribute containing either a string in the case of a text message or a
+`Buffer` in the case of a binary message.
 
-var server = http.createServer();
+You can also listen for messages using the `driver.messages.on('data')` event,
+which emits strings for text messages and buffers for binary messages.
 
-server.on('request', function(request, response) {
-  if (EventSource.isEventSource(request)) {
-    var es = new EventSource(request, response);
-    console.log('open', es.url, es.lastEventId);
-    
-    // Periodically send messages
-    var loop = setInterval(function() { es.send('Hello') }, 1000);
-    
-    es.on('close', function() {
-      clearInterval(loop);
-      es = null;
-    });
-  
-  } else {
-    // Normal HTTP request
-    response.writeHead(200, {'Content-Type': 'text/plain'});
-    response.end('Hello');
-  }
-});
+#### `driver.on('error', function(event) {})`
 
-server.listen(8000);
-```
+Adds a callback to execute when a protocol error occurs due to the other peer
+sending an invalid byte sequence. `event` will have a `message` attribute
+describing the error.
 
-The `send` method takes two optional parameters, `event` and `id`. The default
-event-type is `'message'` with no ID. For example, to send a `notification`
-event with ID `99`:
+#### `driver.on('close', function(event) {})`
 
-```js
-es.send('Breaking News!', {event: 'notification', id: '99'});
-```
+Adds a callback to execute when the socket becomes closed. The `event` object
+has `code` and `reason` attributes.
 
-The `EventSource` object exposes the following properties:
+#### `driver.addExtension(extension)`
 
-* <b>`url`</b> is a string containing the URL the client used to create the
-  EventSource.
-* <b>`lastEventId`</b> is a string containing the last event ID received by the
-  client. You can use this when the client reconnects after a dropped
-  connection to determine which messages need resending.
+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.
 
-When you initialize an EventSource with ` new EventSource()`, you can pass
-configuration options after the `response` parameter. Available options are:
+#### `driver.setHeader(name, value)`
 
-* <b>`headers`</b> is an object containing custom headers to be set on the
-  EventSource response.
-* <b>`retry`</b> is a number that tells the client how long (in seconds) it
-  should wait after a dropped connection before attempting to reconnect.
-* <b>`ping`</b> is a number that tells the server how often (in seconds) to
-  send 'ping' packets to the client to keep the connection open, to defeat
-  timeouts set by proxies. The client will ignore these messages.
+Sets a custom header to be sent as part of the handshake response, either from
+the server or from the client. Must be called before `start()`, since this is
+when the headers are serialized and sent.
 
-For example, this creates a connection that allows access from any origin, pings
-every 15 seconds and is retryable every 10 seconds if the connection is broken:
+#### `driver.start()`
 
-```js
-var es = new EventSource(request, response, {
-  headers: {'Access-Control-Allow-Origin': '*'},
-  ping:    15,
-  retry:   10
-});
-```
+Initiates the protocol by sending the handshake - either the response for a
+server-side driver or the request for a client-side one. This should be the
+first method you invoke.  Returns `true` if and only if a handshake was sent.
 
-You can send a ping message at any time by calling `es.ping()`. Unlike
-WebSocket, the client does not send a response to this; it is merely to send
-some data over the wire to keep the connection alive.
+#### `driver.parse(string)`
+
+Takes a string and parses it, potentially resulting in message events being
+emitted (see `on('message')` above) or in data being sent to `driver.io`.  You
+should send all data you receive via I/O to this method by piping a stream into
+`driver.io`.
+
+#### `driver.text(string)`
+
+Sends a text message over the socket. If the socket handshake is not yet
+complete, the message will be queued until it is. Returns `true` if the message
+was sent or queued, and `false` if the socket can no longer send messages.
+
+This method is equivalent to `driver.messages.write(string)`.
+
+#### `driver.binary(buffer)`
+
+Takes a `Buffer` and sends it as a binary message. Will queue and return `true`
+or `false` the same way as the `text` method. It will also return `false` if the
+driver does not support binary messages.
+
+This method is equivalent to `driver.messages.write(buffer)`.
+
+#### `driver.ping(string = '', function() {})`
+
+Sends a ping frame over the socket, queueing it if necessary. `string` and the
+callback are both optional. If a callback is given, it will be invoked when the
+socket receives a pong frame whose content matches `string`. Returns `false` if
+frames can no longer be sent, or if the driver does not support ping/pong.
+
+#### `driver.pong(string = '')`
+
+Sends a pong frame over the socket, queueing it if necessary. `string` is
+optional. Returns `false` if frames can no longer be sent, or if the driver does
+not support ping/pong.
+
+You don't need to call this when a ping frame is received; pings are replied to
+automatically by the driver. This method is for sending unsolicited pongs.
+
+#### `driver.close()`
+
+Initiates the closing handshake if the socket is still open. For drivers with no
+closing handshake, this will result in the immediate execution of the
+`on('close')` driver. For drivers with a closing handshake, this sends a closing
+frame and `emit('close')` will execute when a response is received or a protocol
+error occurs.
+
+#### `driver.version`
+
+Returns the WebSocket version in use as a string. Will either be `hixie-75`,
+`hixie-76` or `hybi-$version`.
+
+#### `driver.protocol`
+
+Returns a string containing the selected subprotocol, if any was agreed upon
+using the `Sec-WebSocket-Protocol` mechanism. This value becomes available after
+`emit('open')` has fired.
 
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2010-2013 James Coglan
+Copyright (c) 2010-2015 James Coglan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the 'Software'), to deal in
 the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

examples/autobahn_client.js

@@ -1,38 +0,0 @@
-var WebSocket = require('../lib/faye/websocket'),
-    pace      = require('pace');
-
-var host  = 'ws://localhost:9001',
-    agent = 'Node ' + process.version,
-    cases = 0,
-    skip  = [];
-
-var socket = new WebSocket.Client(host + '/getCaseCount'),
-    progress;
-
-socket.onmessage = function(event) {
-  console.log('Total cases to run: ' + event.data);
-  cases = parseInt(event.data);
-  progress = pace(cases);
-};
-
-socket.onclose = function() {
-  var runCase = function(n) {
-    progress.op();
-
-    if (n > cases) {
-      socket = new WebSocket.Client(host + '/updateReports?agent=' + encodeURIComponent(agent));
-      socket.onclose = process.exit;
-
-    } else if (skip.indexOf(n) >= 0) {
-      runCase(n + 1);
-
-    } else {
-      socket = new WebSocket.Client(host + '/runCase?case=' + n + '&agent=' + encodeURIComponent(agent));
-      socket.pipe(socket);
-      socket.on('close', function() { runCase(n + 1) });
-    }
-  };
-
-  runCase(1);
-};
-

examples/client.js

@@ -1,24 +0,0 @@
-var WebSocket = require('../lib/faye/websocket'),
-    port      = process.argv[2] || 7000,
-    secure    = process.argv[3] === 'ssl',
-    scheme    = secure ? 'wss' : 'ws',
-    url       = scheme + '://localhost:' + port + '/',
-    headers   = {Origin: 'http://faye.jcoglan.com'},
-    ws        = new WebSocket.Client(url, null, {headers: headers});
-
-console.log('Connecting to ' + ws.url);
-
-ws.onopen = function(event) {
-  console.log('open');
-  ws.send('Hello, WebSocket!');
-};
-
-ws.onmessage = function(event) {
-  console.log('message', event.data);
-  // ws.close(1002, 'Going away');
-};
-
-ws.onclose = function(event) {
-  console.log('close', event.code, event.reason);
-};
-

examples/haproxy.conf

@@ -1,21 +0,0 @@
-defaults
-   mode http
-   timeout client  5s
-   timeout connect 5s
-   timeout server  5s
-
-frontend all 0.0.0.0:3000
-   mode http
-   timeout client 120s
-
-   option forwardfor
-   option http-server-close
-   option http-pretend-keepalive
-
-   default_backend sockets
-
-backend sockets
-   balance uri depth 2
-   timeout server  120s
-   server socket1 127.0.0.1:7000
-

examples/server.js

@@ -1,68 +0,0 @@
-var WebSocket = require('../lib/faye/websocket'),
-    fs        = require('fs'),
-    http      = require('http'),
-    https     = require('https');
-
-var port   = process.argv[2] || 7000,
-    secure = process.argv[3] === 'ssl';
-
-var upgradeHandler = function(request, socket, head) {
-  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], {ping: 5});
-  console.log('open', ws.url, ws.version, ws.protocol);
-
-  ws.pipe(ws);
-
-  ws.onclose = function(event) {
-    console.log('close', event.code, event.reason);
-    ws = null;
-  };
-};
-
-var requestHandler = function(request, response) {
-  if (!WebSocket.EventSource.isEventSource(request))
-    return staticHandler(request, response);
-
-  var es   = new WebSocket.EventSource(request, response),
-      time = parseInt(es.lastEventId, 10) || 0;
-
-  console.log('open', es.url, es.lastEventId);
-
-  var loop = setInterval(function() {
-    time += 1;
-    es.send('Time: ' + time);
-    setTimeout(function() {
-      if (es) es.send('Update!!', {event: 'update', id: time});
-    }, 1000);
-  }, 2000);
-
-  fs.createReadStream(__dirname + '/haproxy.conf').pipe(es, {end: false});
-
-  es.onclose = function() {
-    clearInterval(loop);
-    console.log('close', es.url);
-    es = null;
-  };
-};
-
-var staticHandler = function(request, response) {
-  var path = request.url;
-
-  fs.readFile(__dirname + path, function(err, content) {
-    var status = err ? 404 : 200;
-    response.writeHead(status, {'Content-Type': 'text/html'});
-    response.write(content || 'Not found');
-    response.end();
-  });
-};
-
-var server = secure
-           ? https.createServer({
-               key:  fs.readFileSync(__dirname + '/../spec/server.key'),
-               cert: fs.readFileSync(__dirname + '/../spec/server.crt')
-             })
-           : http.createServer();
-
-server.on('request', requestHandler);
-server.on('upgrade', upgradeHandler);
-server.listen(port);
-

examples/sse.html

@@ -1,39 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
-    <title>EventSource test</title>
-  </head>
-  <body>
-
-    <h1>EventSource test</h1>
-    <ul></ul>
-
-    <script type="text/javascript">
-      var logger = document.getElementsByTagName('ul')[0],
-          socket = new EventSource('/');
-
-      var log = function(text) {
-        logger.innerHTML += '<li>' + text + '</li>';
-      };
-
-      socket.onopen = function() {
-        log('OPEN');
-      };
-
-      socket.onmessage = function(event) {
-        log('MESSAGE: ' + event.data);
-      };
-
-      socket.addEventListener('update', function(event) {
-        log('UPDATE(' + event.lastEventId + '): ' + event.data);
-      });
-
-      socket.onerror = function(event) {
-        log('ERROR: ' + event.message);
-      };
-    </script>
-
-  </body>
-</html>
-

examples/tcp_server.js

@@ -0,0 +1,22 @@
+var net       = require('net'),
+    websocket = require('..'),
+    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();
+  });
+
+  driver.on('close', function() { connection.end() });
+  connection.on('error', function() {});
+
+  connection.pipe(driver.io);
+  driver.io.pipe(connection);
+
+  driver.messages.pipe(driver.messages);
+});
+
+server.listen(process.argv[2]);

examples/ws.html

@@ -1,44 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
-    <title>WebSocket test</title>
-  </head>
-  <body>
-
-    <h1>WebSocket test</h1>
-    <ul></ul>
-
-    <script type="text/javascript">
-      var logger = document.getElementsByTagName('ul')[0],
-          Socket = window.MozWebSocket || window.WebSocket,
-          protos = ['foo', 'bar', 'xmpp'],
-          socket = new Socket('ws://' + location.hostname + ':' + location.port + '/', protos),
-          index  = 0;
-
-      var log = function(text) {
-        logger.innerHTML += '<li>' + text + '</li>';
-      };
-
-      socket.addEventListener('open', function() {
-        log('OPEN: ' + socket.protocol);
-        socket.send('Hello, world');
-      });
-
-      socket.onerror = function(event) {
-        log('ERROR: ' + event.message);
-      };
-
-      socket.onmessage = function(event) {
-        log('MESSAGE: ' + event.data);
-        setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
-      };
-
-      socket.onclose = function(event) {
-        log('CLOSE: ' + event.code + ', ' + event.reason);
-      };
-    </script>
-
-  </body>
-</html>
-

lib/faye/eventsource.js

@@ -1,132 +0,0 @@
-var Stream      = require('stream').Stream,
-    util        = require('util'),
-    driver      = require('websocket-driver'),
-    Headers     = require('websocket-driver/lib/websocket/driver/headers'),
-    API         = require('./websocket/api'),
-    EventTarget = require('./websocket/api/event_target'),
-    Event       = require('./websocket/api/event');
-
-var EventSource = function(request, response, options) {
-  this.writable = true;
-  options = options || {};
-
-  this._stream = response.socket;
-  this._ping   = options.ping  || this.DEFAULT_PING;
-  this._retry  = options.retry || this.DEFAULT_RETRY;
-
-  var scheme       = driver.isSecureRequest(request) ? 'https:' : 'http:';
-  this.url         = scheme + '//' + request.headers.host + request.url;
-  this.lastEventId = request.headers['last-event-id'] || '';
-  this.readyState  = API.CONNECTING;
-
-  var headers = new Headers(),
-      self    = this;
-
-  if (options.headers) {
-    for (var key in options.headers) headers.set(key, options.headers[key]);
-  }
-
-  if (!this._stream || !this._stream.writable) return;
-  process.nextTick(function() { self._open() });
-
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
-
-  var handshake = 'HTTP/1.1 200 OK\r\n' +
-                  'Content-Type: text/event-stream\r\n' +
-                  'Cache-Control: no-cache, no-store\r\n' +
-                  'Connection: close\r\n' +
-                  headers.toString() +
-                  '\r\n' +
-                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
-
-  this._write(handshake);
-
-  this._stream.on('drain', function() { self.emit('drain') });
-
-  if (this._ping)
-    this._pingTimer = setInterval(function() { self.ping() }, this._ping * 1000);
-
-  ['error', 'end'].forEach(function(event) {
-    self._stream.on(event, function() { self.close() });
-  });
-};
-util.inherits(EventSource, Stream);
-
-EventSource.isEventSource = function(request) {
-  if (request.method !== 'GET') return false;
-  var accept = (request.headers.accept || '').split(/\s*,\s*/);
-  return accept.indexOf('text/event-stream') >= 0;
-};
-
-var instance = {
-  DEFAULT_PING:   10,
-  DEFAULT_RETRY:  5,
-
-  _write: function(chunk) {
-    if (!this.writable) return false;
-    try {
-      return this._stream.write(chunk, 'utf8');
-    } catch (e) {
-      return false;
-    }
-  },
-
-  _open: function() {
-    if (this.readyState !== API.CONNECTING) return;
-
-    this.readyState = API.OPEN;
-
-    var event = new Event('open');
-    event.initEvent('open', false, false);
-    this.dispatchEvent(event);
-  },
-
-  write: function(message) {
-    return this.send(message);
-  },
-
-  end: function(message) {
-    if (message !== undefined) this.write(message);
-    this.close();
-  },
-
-  send: function(message, options) {
-    if (this.readyState > API.OPEN) return false;
-
-    message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
-    options = options || {};
-
-    var frame = '';
-    if (options.event) frame += 'event: ' + options.event + '\r\n';
-    if (options.id)    frame += 'id: '    + options.id    + '\r\n';
-    frame += 'data: ' + message + '\r\n\r\n';
-
-    return this._write(frame);
-  },
-
-  ping: function() {
-    return this._write(':\r\n\r\n');
-  },
-
-  close: function() {
-    if (this.readyState > API.OPEN) return false;
-
-    this.readyState = API.CLOSED;
-    this.writable = false;
-    if (this._pingTimer) clearInterval(this._pingTimer);
-    if (this._stream) this._stream.end();
-
-    var event = new Event('close');
-    event.initEvent('close', false, false);
-    this.dispatchEvent(event);
-
-    return true;
-  }
-};
-
-for (var method in instance) EventSource.prototype[method] = instance[method];
-for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
-
-module.exports = EventSource;
-

lib/faye/websocket.js

@@ -1,41 +0,0 @@
-// API references:
-// 
-// * http://dev.w3.org/html5/websockets/
-// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
-// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
-
-var util   = require('util'),
-    driver = require('websocket-driver'),
-    API    = require('./websocket/api');
-
-var WebSocket = function(request, socket, body, protocols, options) {
-  options = options || {};
-
-  this._stream = socket;
-  this._driver = driver.http(request, {maxLength: options.maxLength, protocols: protocols});
-
-  var self = this;
-  if (!this._stream || !this._stream.writable) return;
-
-  var catchup = function() { self._stream.removeListener('data', catchup) };
-  this._stream.on('data', catchup);
-
-  this._driver.io.write(body);
-  API.call(this, options);
-
-  process.nextTick(function() {
-    self._driver.start();
-  });
-};
-util.inherits(WebSocket, API);
-
-WebSocket.isWebSocket = function(request) {
-  return driver.isWebSocket(request);
-};
-
-WebSocket.WebSocket   = WebSocket;
-WebSocket.Client      = require('./websocket/client');
-WebSocket.EventSource = require('./eventsource');
-
-module.exports        = WebSocket;
-

lib/faye/websocket/api.js

@@ -1,146 +0,0 @@
-var Stream      = require('stream').Stream,
-    util        = require('util'),
-    EventTarget = require('./api/event_target'),
-    Event       = require('./api/event');
-
-var API = function(options) {
-  options = options || {};
-
-  this.readable = this.writable = true;
-
-  var headers = options.headers;
-  if (headers) {
-    for (var name in headers) this._driver.setHeader(name, headers[name]);
-  }
-
-  this._ping          = options.ping;
-  this._pingId        = 0;
-  this.readyState     = API.CONNECTING;
-  this.bufferedAmount = 0;
-  this.protocol       = '';
-  this.url            = this._driver.url;
-  this.version        = this._driver.version;
-
-  var self = this;
-
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
-
-  ['close', 'end'].forEach(function(event) {
-    this._stream.on(event, function() { self._finalize('', 1006) });
-  }, this);
-
-  this._stream.on('error', function(error) {
-    var event = new Event('error', {message: 'Network error: ' + self.url + ': ' + error.message});
-    event.initEvent('error', false, false);
-    self.dispatchEvent(event);
-    self._finalize('', 1006);
-  });
-
-  this._driver.on('open',    function(e) { self._open() });
-  this._driver.on('message', function(e) { self._receiveMessage(e.data) });
-  this._driver.on('close',   function(e) { self._finalize(e.reason, e.code) });
-
-  this._driver.on('error', function(error) {
-    var event = new Event('error', {message: error.message});
-    event.initEvent('error', false, false);
-    self.dispatchEvent(event);
-  });
-  this.on('error', function() {});
-
-  this._driver.messages.on('drain', function() {
-    self.emit('drain');
-  });
-
-  if (this._ping)
-    this._pingTimer = setInterval(function() {
-      self._pingId += 1;
-      self.ping(self._pingId.toString());
-    }, this._ping * 1000);
-
-  this._stream.pipe(this._driver.io);
-  this._driver.io.pipe(this._stream);
-};
-util.inherits(API, Stream);
-
-API.CONNECTING = 0;
-API.OPEN       = 1;
-API.CLOSING    = 2;
-API.CLOSED     = 3;
-
-var instance = {
-  write: function(data) {
-    return this.send(data);
-  },
-
-  end: function(data) {
-    if (data !== undefined) this.send(data);
-    this.close();
-  },
-
-  pause: function() {
-    return this._driver.messages.pause();
-  },
-
-  resume: function() {
-    return this._driver.messages.resume();
-  },
-
-  send: function(data) {
-    if (this.readyState > API.OPEN) return false;
-    if (!(data instanceof Buffer)) data = String(data);
-    return this._driver.messages.write(data);
-  },
-
-  ping: function(message, callback) {
-    if (this.readyState > API.OPEN) return false;
-    return this._driver.ping(message, callback);
-  },
-
-  close: function() {
-    if (this.readyState === API.OPEN) this.readyState = API.CLOSING;
-    this._driver.close();
-  },
-
- _open: function() {
-    if (this.readyState !== API.CONNECTING) return;
-
-    this.readyState = API.OPEN;
-    this.protocol = this._driver.protocol || '';
-
-    var event = new Event('open');
-    event.initEvent('open', false, false);
-    this.dispatchEvent(event);
-  },
-
-  _receiveMessage: function(data) {
-    if (this.readyState > API.OPEN) return false;
-
-    if (this.readable) this.emit('data', data);
-
-    var event = new Event('message', {data: data});
-    event.initEvent('message', false, false);
-    this.dispatchEvent(event);
-  },
-
-  _finalize: function(reason, code) {
-    if (this.readyState === API.CLOSED) return;
-
-    if (this._pingTimer) clearInterval(this._pingTimer);
-    if (this._stream) this._stream.end();
-
-    if (this.readable) this.emit('end');
-    this.readable = this.writable = false;
-
-    this.readyState = API.CLOSED;
-    var event = new Event('close', {code: code || 1000, reason: reason || ''});
-    event.initEvent('close', false, false);
-    this.dispatchEvent(event);
-  }
-};
-
-for (var method in instance) API.prototype[method] = instance[method];
-for (var key in EventTarget) API.prototype[key] = EventTarget[key];
-
-module.exports = API;
-

lib/faye/websocket/api/event.js

@@ -1,21 +0,0 @@
-var Event = function(eventType, options) {
-  this.type = eventType;
-  for (var key in options)
-    this[key] = options[key];
-};
-
-Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
-  this.type       = eventType;
-  this.bubbles    = canBubble;
-  this.cancelable = cancelable;
-};
-
-Event.prototype.stopPropagation = function() {};
-Event.prototype.preventDefault  = function() {};
-
-Event.CAPTURING_PHASE = 1;
-Event.AT_TARGET       = 2;
-Event.BUBBLING_PHASE  = 3;
-
-module.exports = Event;
-

lib/faye/websocket/api/event_target.js

@@ -1,29 +0,0 @@
-var Event = require('./event');
-
-var EventTarget = {
-  onopen:     null,
-  onmessage:  null,
-  onerror:    null,
-  onclose:    null,
-
-  addEventListener: function(eventType, listener, useCapture) {
-    this.on(eventType, listener);
-  },
-
-  removeEventListener: function(eventType, listener, useCapture) {
-    this.removeListener(eventType, listener);
-  },
-
-  dispatchEvent: function(event) {
-    event.target = event.currentTarget = this;
-    event.eventPhase = Event.AT_TARGET;
-
-    if (this['on' + event.type])
-      this['on' + event.type](event);
-
-    this.emit(event.type, event);
-  }
-};
-
-module.exports = EventTarget;
-

lib/faye/websocket/client.js

@@ -1,41 +0,0 @@
-var util   = require('util'),
-    net    = require('net'),
-    tls    = require('tls'),
-    driver = require('websocket-driver'),
-    API    = require('./api'),
-    Event  = require('./api/event');
-
-var Client = function(url, protocols, options) {
-  options = options || {};
-
-  this.url     = url;
-  this._uri    = require('url').parse(url);
-  this._driver = driver.client(url, {maxLength: options.maxLength, protocols: protocols});
-
-  ['open', 'error'].forEach(function(event) {
-    this._driver.on(event, function() {
-      self.headers    = self._driver.headers;
-      self.statusCode = self._driver.statusCode;
-    });
-  }, this);
-
-  var secure     = (this._uri.protocol === 'wss:'),
-      onConnect  = function() { self._driver.start() },
-      tlsOptions = {},
-      self       = this;
-
-  if (options.ca) tlsOptions.ca = options.ca;
-
-  var connection = secure
-                 ? tls.connect(this._uri.port || 443, this._uri.hostname, tlsOptions, onConnect)
-                 : net.createConnection(this._uri.port || 80, this._uri.hostname);
-
-  this._stream = connection;
-  if (!secure) this._stream.on('connect', onConnect);
-
-  API.call(this, options);
-};
-util.inherits(Client, API);
-
-module.exports = Client;
-

lib/websocket/driver.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// Protocol references:
+// 
+// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+// * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+var Base   = require('./driver/base'),
+    Client = require('./driver/client'),
+    Server = require('./driver/server');
+
+var Driver = {
+  client: function(url, options) {
+    options = options || {};
+    if (options.masking === undefined) options.masking = true;
+    return new Client(url, options);
+  },
+
+  server: function(options) {
+    options = options || {};
+    if (options.requireMasking === undefined) options.requireMasking = true;
+    return new Server(options);
+  },
+
+  http: function() {
+    return Server.http.apply(Server, arguments);
+  },
+
+  isSecureRequest: function(request) {
+    return Server.isSecureRequest(request);
+  },
+
+  isWebSocket: function(request) {
+    if (request.method !== 'GET') return false;
+
+    var connection = request.headers.connection || '',
+        upgrade    = request.headers.upgrade || '';
+
+    return request.method === 'GET' &&
+           connection.toLowerCase().split(/ *, */).indexOf('upgrade') >= 0 &&
+           upgrade.toLowerCase() === 'websocket';
+  },
+
+  validateOptions: function(options, validKeys) {
+    Base.validateOptions(options, validKeys);
+  }
+};
+
+module.exports = Driver;

lib/websocket/driver/base.js

@@ -0,0 +1,147 @@
+'use strict';
+
+var Emitter = require('events').EventEmitter,
+    util    = require('util'),
+    streams = require('../streams'),
+    Headers = require('./headers'),
+    Reader  = require('./stream_reader');
+
+var Base = function(request, url, options) {
+  Emitter.call(this);
+  Base.validateOptions(options || {}, ['maxLength', 'masking', 'requireMasking', 'protocols']);
+
+  this._request   = request;
+  this._reader    = new Reader();
+  this._options   = options || {};
+  this._maxLength = this._options.maxLength || this.MAX_LENGTH;
+  this._headers   = new Headers();
+  this.__queue    = [];
+  this.readyState = 0;
+  this.url        = url;
+
+  this.io = new streams.IO(this);
+  this.messages = new streams.Messages(this);
+  this._bindEventListeners();
+};
+util.inherits(Base, Emitter);
+
+Base.validateOptions = function(options, validKeys) {
+  for (var key in options) {
+    if (validKeys.indexOf(key) < 0)
+      throw new Error('Unrecognized option: ' + key);
+  }
+};
+
+var instance = {
+  // This is 64MB, small enough for an average VPS to handle without
+  // crashing from process out of memory
+  MAX_LENGTH: 0x3ffffff,
+
+  STATES: ['connecting', 'open', 'closing', 'closed'],
+
+  _bindEventListeners: function() {
+    var self = this;
+
+    // Protocol errors are informational and do not have to be handled
+    this.messages.on('error', function() {});
+
+    this.on('message', function(event) {
+      var messages = self.messages;
+      if (messages.readable) messages.emit('data', event.data);
+    });
+
+    this.on('error', function(error) {
+      var messages = self.messages;
+      if (messages.readable) messages.emit('error', error);
+    });
+
+    this.on('close', function() {
+      var messages = self.messages;
+      if (!messages.readable) return;
+      messages.readable = messages.writable = false;
+      messages.emit('end');
+    });
+  },
+
+  getState: function() {
+    return this.STATES[this.readyState] || null;
+  },
+
+  addExtension: function(extension) {
+    return false;
+  },
+
+  setHeader: function(name, value) {
+    if (this.readyState > 0) return false;
+    this._headers.set(name, value);
+    return true;
+  },
+
+  start: function() {
+    if (this.readyState !== 0) return false;
+    var response = this._handshakeResponse();
+    if (!response) return false;
+    this._write(response);
+    if (this._stage !== -1) this._open();
+    return true;
+  },
+
+  text: function(message) {
+    return this.frame(message);
+  },
+
+  binary: function(message) {
+    return false;
+  },
+
+  ping: function() {
+    return false;
+  },
+
+  pong: function() {
+      return false;
+  },
+
+  close: function(reason, code) {
+    if (this.readyState !== 1) return false;
+    this.readyState = 3;
+    this.emit('close', new Base.CloseEvent(null, null));
+    return true;
+  },
+
+  _open: function() {
+    this.readyState = 1;
+    this.__queue.forEach(function(args) { this.frame.apply(this, args) }, this);
+    this.__queue = [];
+    this.emit('open', new Base.OpenEvent());
+  },
+
+  _queue: function(message) {
+    this.__queue.push(message);
+    return true;
+  },
+
+  _write: function(chunk) {
+    var io = this.io;
+    if (io.readable) io.emit('data', chunk);
+  }
+};
+
+for (var key in instance)
+  Base.prototype[key] = instance[key];
+
+
+Base.ConnectEvent = function() {};
+
+Base.OpenEvent = function() {};
+
+Base.CloseEvent = function(code, reason) {
+  this.code   = code;
+  this.reason = reason;
+};
+
+Base.MessageEvent = function(data) {
+  this.data = data;
+};
+
+module.exports = Base;

lib/websocket/driver/client.js

@@ -0,0 +1,138 @@
+'use strict';
+
+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);
+
+  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');
+
+  if (this.VALID_PROTOCOLS.indexOf(uri.protocol) < 0)
+    throw new Error(this.url + ' is not a valid WebSocket URL');
+
+  this._pathname = (uri.pathname || '/') + (uri.search || '');
+
+  this._headers.set('Host', uri.host);
+  this._headers.set('Upgrade', 'websocket');
+  this._headers.set('Connection', 'Upgrade');
+  this._headers.set('Sec-WebSocket-Key', this._key);
+  this._headers.set('Sec-WebSocket-Version', '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() {
+  return crypto.randomBytes(16).toString('base64');
+};
+
+var instance = {
+  VALID_PROTOCOLS: ['ws:', 'wss:'],
+
+  proxy: function(origin, options) {
+    return new Proxy(this, origin, options);
+  },
+
+  start: function() {
+    if (this.readyState !== -1) return false;
+    this._write(this._handshakeRequest());
+    this.readyState = 0;
+    return true;
+  },
+
+  parse: function(chunk) {
+    if (this.readyState === 3) return;
+    if (this.readyState > 0) return Hybi.prototype.parse.call(this, chunk);
+
+    this._http.parse(chunk);
+    if (!this._http.isComplete()) return;
+
+    this._validateHandshake();
+    if (this.readyState === 3) return;
+
+    this._open();
+    this.parse(this._http.body);
+  },
+
+  _handshakeRequest: function() {
+    var extensions = this._extensions.generateOffer();
+    if (extensions)
+      this._headers.set('Sec-WebSocket-Extensions', extensions);
+
+    var start   = 'GET ' + this._pathname + ' HTTP/1.1',
+        headers = [start, this._headers.toString(), ''];
+
+    return new Buffer(headers.join('\r\n'), 'utf8');
+  },
+
+  _failHandshake: function(message) {
+    message = 'Error during WebSocket handshake: ' + message;
+    this.readyState = 3;
+    this.emit('error', new Error(message));
+    this.emit('close', new Base.CloseEvent(this.ERRORS.protocol_error, message));
+  },
+
+  _validateHandshake: function() {
+    this.statusCode = this._http.statusCode;
+    this.headers    = this._http.headers;
+
+    if (this._http.statusCode !== 101)
+      return this._failHandshake('Unexpected response code: ' + this._http.statusCode);
+
+    var headers    = this._http.headers,
+        upgrade    = headers['upgrade'] || '',
+        connection = headers['connection'] || '',
+        accept     = headers['sec-websocket-accept'] || '',
+        protocol   = headers['sec-websocket-protocol'] || '';
+
+    if (upgrade === '')
+      return this._failHandshake("'Upgrade' header is missing");
+    if (upgrade.toLowerCase() !== 'websocket')
+      return this._failHandshake("'Upgrade' header value is not 'WebSocket'");
+
+    if (connection === '')
+      return this._failHandshake("'Connection' header is missing");
+    if (connection.toLowerCase() !== 'upgrade')
+      return this._failHandshake("'Connection' header value is not 'Upgrade'");
+
+    if (accept !== this._accept)
+      return this._failHandshake('Sec-WebSocket-Accept mismatch');
+
+    this.protocol = null;
+
+    if (protocol !== '') {
+      if (this._protocols.indexOf(protocol) < 0)
+        return this._failHandshake('Sec-WebSocket-Protocol mismatch');
+      else
+        this.protocol = protocol;
+    }
+
+    try {
+      this._extensions.activate(this.headers['sec-websocket-extensions']);
+    } catch (e) {
+      return this._failHandshake(e.message);
+    }
+  }
+};
+
+for (var key in instance)
+  Client.prototype[key] = instance[key];
+
+module.exports = Client;

lib/websocket/driver/draft75.js

@@ -0,0 +1,120 @@
+'use strict';
+
+var Base = require('./base'),
+    util = require('util');
+
+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);
+
+var instance = {
+  close: function() {
+    if (this.readyState === 3) return false;
+    this.readyState = 3;
+    this.emit('close', new Base.CloseEvent(null, null));
+    return true;
+  },
+
+  parse: function(chunk) {
+    if (this.readyState > 1) return;
+
+    this._reader.put(chunk);
+
+    this._reader.eachByte(function(octet) {
+      var message;
+
+      switch (this._stage) {
+        case -1:
+          this._body.push(octet);
+          this._sendHandshakeBody();
+          break;
+
+        case 0:
+          this._parseLeadingByte(octet);
+          break;
+
+        case 1:
+          this._length = (octet & 0x7F) + 128 * this._length;
+
+          if (this._closing && this._length === 0) {
+            return this.close();
+          }
+          else if ((octet & 0x80) !== 0x80) {
+            if (this._length === 0) {
+              this._stage = 0;
+            }
+            else {
+              this._skipped = 0;
+              this._stage   = 2;
+            }
+          }
+          break;
+
+        case 2:
+          if (octet === 0xFF) {
+            this._stage = 0;
+            message = new Buffer(this._buffer).toString('utf8', 0, this._buffer.length);
+            this.emit('message', new Base.MessageEvent(message));
+          }
+          else {
+            if (this._length) {
+              this._skipped += 1;
+              if (this._skipped === this._length)
+                this._stage = 0;
+            } else {
+              this._buffer.push(octet);
+              if (this._buffer.length > this._maxLength) return this.close();
+            }
+          }
+          break;
+      }
+    }, this);
+  },
+
+  frame: function(buffer) {
+    if (this.readyState === 0) return this._queue([buffer]);
+    if (this.readyState > 1) return false;
+
+    var payload = new Buffer(buffer, 'utf8'),
+        frame   = new Buffer(payload.length + 2);
+
+    frame[0] = 0x00;
+    frame[payload.length + 1] = 0xFF;
+    payload.copy(frame, 1);
+
+    this._write(frame);
+    return true;
+  },
+
+  _handshakeResponse: function() {
+    var start   = 'HTTP/1.1 101 Web Socket Protocol Handshake',
+        headers = [start, this._headers.toString(), ''];
+
+    return new Buffer(headers.join('\r\n'), 'utf8');
+  },
+
+  _parseLeadingByte: function(octet) {
+    if ((octet & 0x80) === 0x80) {
+      this._length = 0;
+      this._stage  = 1;
+    } else {
+      delete this._length;
+      delete this._skipped;
+      this._buffer = [];
+      this._stage  = 2;
+    }
+  }
+};
+
+for (var key in instance)
+  Draft75.prototype[key] = instance[key];
+
+module.exports = Draft75;

lib/websocket/driver/draft76.js

@@ -0,0 +1,116 @@
+'use strict';
+
+var Base    = require('./base'),
+    Draft75 = require('./draft75'),
+    crypto  = require('crypto'),
+    util    = require('util');
+
+
+var numberFromKey = function(key) {
+  return parseInt(key.match(/[0-9]/g).join(''), 10);
+};
+
+var spacesInKey = function(key) {
+  return key.match(/ /g).length;
+};
+
+
+var Draft76 = function(request, url, options) {
+  Draft75.apply(this, arguments);
+  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);
+
+var instance = {
+  BODY_SIZE: 8,
+
+  start: function() {
+    if (!Draft75.prototype.start.call(this)) return false;
+    this._started = true;
+    this._sendHandshakeBody();
+    return true;
+  },
+
+  close: function() {
+    if (this.readyState === 3) return false;
+    this._write(new Buffer([0xFF, 0x00]));
+    this.readyState = 3;
+    this.emit('close', new Base.CloseEvent(null, null));
+    return true;
+  },
+
+  _handshakeResponse: function() {
+    var headers = this._request.headers,
+
+        key1    = headers['sec-websocket-key1'],
+        number1 = numberFromKey(key1),
+        spaces1 = spacesInKey(key1),
+
+        key2    = headers['sec-websocket-key2'],
+        number2 = numberFromKey(key2),
+        spaces2 = spacesInKey(key2);
+
+    if (number1 % spaces1 !== 0 || number2 % spaces2 !== 0) {
+      this.emit('error', new Error('Client sent invalid Sec-WebSocket-Key headers'));
+      this.close();
+      return null;
+    }
+
+    this._keyValues = [number1 / spaces1, number2 / spaces2];
+
+    var start   = 'HTTP/1.1 101 WebSocket Protocol Handshake',
+        headers = [start, this._headers.toString(), ''];
+
+    return new Buffer(headers.join('\r\n'), 'binary');
+  },
+
+  _handshakeSignature: function() {
+    if (this._body.length < this.BODY_SIZE) return null;
+
+    var md5    = crypto.createHash('md5'),
+        buffer = new Buffer(8 + this.BODY_SIZE);
+
+    buffer.writeUInt32BE(this._keyValues[0], 0);
+    buffer.writeUInt32BE(this._keyValues[1], 4);
+    new Buffer(this._body).copy(buffer, 8, 0, this.BODY_SIZE);
+
+    md5.update(buffer);
+    return new Buffer(md5.digest('binary'), 'binary');
+  },
+
+  _sendHandshakeBody: function() {
+    if (!this._started) return;
+    var signature = this._handshakeSignature();
+    if (!signature) return;
+
+    this._write(signature);
+    this._stage = 0;
+    this._open();
+
+    if (this._body.length > this.BODY_SIZE)
+      this.parse(this._body.slice(this.BODY_SIZE));
+  },
+
+  _parseLeadingByte: function(octet) {
+    if (octet !== 0xFF)
+      return Draft75.prototype._parseLeadingByte.call(this, octet);
+
+    this._closing = true;
+    this._length  = 0;
+    this._stage   = 1;
+  }
+};
+
+for (var key in instance)
+  Draft76.prototype[key] = instance[key];
+
+module.exports = Draft76;

lib/websocket/driver/headers.js

@@ -0,0 +1,35 @@
+'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.set = function(name, value) {
+  if (value === undefined) return;
+
+  name = this._strip(name);
+  value = this._strip(value);
+
+  var key = name.toLowerCase();
+  if (!this._sent.hasOwnProperty(key) || this.ALLOWED_DUPLICATES.indexOf(key) >= 0) {
+    this._sent[key] = true;
+    this._lines.push(name + ': ' + value + '\r\n');
+  }
+};
+
+Headers.prototype.toString = function() {
+  return this._lines.join('');
+};
+
+Headers.prototype._strip = function(string) {
+  return string.toString().replace(/^ */, '').replace(/ *$/, '');
+};
+
+module.exports = Headers;

lib/websocket/driver/hybi.js

@@ -0,0 +1,473 @@
+'use strict';
+
+var crypto     = require('crypto'),
+    util       = require('util'),
+    Extensions = require('websocket-extensions'),
+    Base       = require('./base'),
+    Frame      = require('./hybi/frame'),
+    Message    = require('./hybi/message');
+
+var Hybi = function(request, url, options) {
+  Base.apply(this, arguments);
+
+  this._extensions     = new Extensions();
+  this._stage          = 0;
+  this._masking        = this._options.masking;
+  this._protocols      = this._options.protocols || [];
+  this._requireMasking = this._options.requireMasking;
+  this._pingCallbacks  = {};
+
+  if (typeof this._protocols === 'string')
+    this._protocols = this._protocols.split(/ *, */);
+
+  if (!this._request) return;
+
+  var 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 || 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);
+  return sha1.digest('base64');
+};
+
+Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+var instance = {
+  FIN:    0x80,
+  MASK:   0x80,
+  RSV1:   0x40,
+  RSV2:   0x20,
+  RSV3:   0x10,
+  OPCODE: 0x0F,
+  LENGTH: 0x7F,
+
+  OPCODES: {
+    continuation: 0,
+    text:         1,
+    binary:       2,
+    close:        8,
+    ping:         9,
+    pong:         10
+  },
+
+  OPCODE_CODES:    [0, 1, 2, 8, 9, 10],
+  MESSAGE_OPCODES: [0, 1, 2],
+  OPENING_OPCODES: [1, 2],
+
+  ERRORS: {
+    normal_closure:       1000,
+    going_away:           1001,
+    protocol_error:       1002,
+    unacceptable:         1003,
+    encoding_error:       1007,
+    policy_violation:     1008,
+    too_large:            1009,
+    extension_error:      1010,
+    unexpected_condition: 1011
+  },
+
+  ERROR_CODES:        [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011],
+  DEFAULT_ERROR_CODE: 1000,
+  MIN_RESERVED_ERROR: 3000,
+  MAX_RESERVED_ERROR: 4999,
+
+  // http://www.w3.org/International/questions/qa-forms-utf-8.en.php
+  UTF8_MATCH: /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/,
+
+  addExtension: function(extension) {
+    this._extensions.add(extension);
+    return true;
+  },
+
+  parse: function(chunk) {
+    this._reader.put(chunk);
+    var buffer = true;
+    while (buffer) {
+      switch (this._stage) {
+        case 0:
+          buffer = this._reader.read(1);
+          if (buffer) this._parseOpcode(buffer[0]);
+          break;
+
+        case 1:
+          buffer = this._reader.read(1);
+          if (buffer) this._parseLength(buffer[0]);
+          break;
+
+        case 2:
+          buffer = this._reader.read(this._frame.lengthBytes);
+          if (buffer) this._parseExtendedLength(buffer);
+          break;
+
+        case 3:
+          buffer = this._reader.read(4);
+          if (buffer) {
+            this._stage = 4;
+            this._frame.maskingKey = buffer;
+          }
+          break;
+
+        case 4:
+          buffer = this._reader.read(this._frame.length);
+          if (buffer) {
+            this._stage = 0;
+            this._emitFrame(buffer);
+          }
+          break;
+
+        default:
+          buffer = null;
+      }
+    }
+  },
+
+  text: function(message) {
+    if (this.readyState > 1) return false;
+    return this.frame(message, 'text');
+  },
+
+  binary: function(message) {
+    if (this.readyState > 1) return false;
+    return this.frame(message, 'binary');
+  },
+
+  ping: function(message, callback) {
+    if (this.readyState > 1) return false;
+    message = message || '';
+    if (callback) this._pingCallbacks[message] = callback;
+    return this.frame(message, 'ping');
+  },
+
+  pong: function(message) {
+      if (this.readyState > 1) return false;
+      message = message ||'';
+      return this.frame(message, 'pong');
+  },
+
+  close: function(reason, code) {
+    reason = reason || '';
+    code   = code   || this.ERRORS.normal_closure;
+
+    if (this.readyState <= 0) {
+      this.readyState = 3;
+      this.emit('close', new Base.CloseEvent(code, reason));
+      return true;
+    } else if (this.readyState === 1) {
+      this.readyState = 2;
+      this._extensions.close(function() { this.frame(reason, 'close', code) }, this);
+      return true;
+    } else {
+      return false;
+    }
+  },
+
+  frame: function(buffer, type, code) {
+    if (this.readyState <= 0) return this._queue([buffer, type, code]);
+    if (this.readyState > 2) return false;
+
+    if (buffer instanceof Array) buffer = new Buffer(buffer);
+
+    var message = new Message(),
+        isText  = (typeof buffer === 'string'),
+        payload, copy;
+
+    message.rsv1   = message.rsv2 = message.rsv3 = false;
+    message.opcode = this.OPCODES[type || (isText ? 'text' : 'binary')];
+
+    payload = isText ? new Buffer(buffer, 'utf8') : buffer;
+
+    if (code) {
+      copy = payload;
+      payload = new Buffer(2 + copy.length);
+      payload.writeUInt16BE(code, 0);
+      copy.copy(payload, 2);
+    }
+    message.data = payload;
+
+    var onMessageReady = function(message) {
+      var frame = new Frame();
+
+      frame.final   = true;
+      frame.rsv1    = message.rsv1;
+      frame.rsv2    = message.rsv2;
+      frame.rsv3    = message.rsv3;
+      frame.opcode  = message.opcode;
+      frame.masked  = !!this._masking;
+      frame.length  = message.data.length;
+      frame.payload = message.data;
+
+      if (frame.masked) frame.maskingKey = crypto.randomBytes(4);
+
+      this._sendFrame(frame);
+    };
+
+    if (this.MESSAGE_OPCODES.indexOf(message.opcode) >= 0)
+      this._extensions.processOutgoingMessage(message, function(error, message) {
+        if (error) return this._fail('extension_error', error.message);
+        onMessageReady.call(this, message);
+      }, this);
+    else
+      onMessageReady.call(this, message);
+
+    return true;
+  },
+
+  _sendFrame: function(frame) {
+    var length = frame.length,
+        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
+        offset = header + (frame.masked ? 4 : 0),
+        buffer = new Buffer(offset + length),
+        masked = frame.masked ? this.MASK : 0;
+
+    buffer[0] = (frame.final ? this.FIN : 0) |
+                (frame.rsv1 ? this.RSV1 : 0) |
+                (frame.rsv2 ? this.RSV2 : 0) |
+                (frame.rsv3 ? this.RSV3 : 0) |
+                frame.opcode;
+
+    if (length <= 125) {
+      buffer[1] = masked | length;
+    } else if (length <= 65535) {
+      buffer[1] = masked | 126;
+      buffer.writeUInt16BE(length, 2);
+    } else {
+      buffer[1] = masked | 127;
+      buffer.writeUInt32BE(Math.floor(length / 0x100000000), 2);
+      buffer.writeUInt32BE(length % 0x100000000, 6);
+    }
+
+    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() {
+    try {
+      var extensions = this._extensions.generateResponse(this._request.headers['sec-websocket-extensions']);
+    } catch (e) {
+      return this._fail('protocol_error', e.message);
+    }
+
+    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, error) {
+    delete this._frame;
+    delete this._message;
+    this._stage = 5;
+
+    var sendCloseFrame = (this.readyState === 1);
+    this.readyState = 2;
+
+    this._extensions.close(function() {
+      if (sendCloseFrame) this.frame(reason, 'close', code);
+      this.readyState = 3;
+      if (error) this.emit('error', new Error(reason));
+      this.emit('close', new Base.CloseEvent(code, reason));
+    }, this);
+  },
+
+  _fail: function(type, message) {
+    if (this.readyState > 1) return;
+    this._shutdown(this.ERRORS[type], message, true);
+  },
+
+  _parseOpcode: function(octet) {
+    var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
+      return (octet & rsv) === rsv;
+    });
+
+    var frame = this._frame = new Frame();
+
+    frame.final  = (octet & this.FIN) === this.FIN;
+    frame.rsv1   = rsvs[0];
+    frame.rsv2   = rsvs[1];
+    frame.rsv3   = rsvs[2];
+    frame.opcode = (octet & this.OPCODE);
+
+    this._stage = 1;
+
+    if (!this._extensions.validFrameRsv(frame))
+      return this._fail('protocol_error',
+          'One or more reserved bits are on: reserved1 = ' + (frame.rsv1 ? 1 : 0) +
+          ', reserved2 = ' + (frame.rsv2 ? 1 : 0) +
+          ', reserved3 = ' + (frame.rsv3 ? 1 : 0));
+
+    if (this.OPCODE_CODES.indexOf(frame.opcode) < 0)
+      return this._fail('protocol_error', 'Unrecognized frame opcode: ' + frame.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._message && this.OPENING_OPCODES.indexOf(frame.opcode) >= 0)
+      return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
+  },
+
+  _parseLength: function(octet) {
+    var frame = this._frame;
+    frame.masked = (octet & this.MASK) === this.MASK;
+    frame.length = (octet & this.LENGTH);
+
+    if (frame.length >= 0 && frame.length <= 125) {
+      this._stage = frame.masked ? 3 : 4;
+      if (!this._checkFrameLength()) return;
+    } else {
+      this._stage = 2;
+      frame.lengthBytes = (frame.length === 126 ? 2 : 8);
+    }
+
+    if (this._requireMasking && !frame.masked)
+      return this._fail('unacceptable', 'Received unmasked frame but masking is required');
+  },
+
+  _parseExtendedLength: function(buffer) {
+    var frame = this._frame;
+    frame.length = this._readUInt(buffer);
+
+    this._stage = frame.masked ? 3 : 4;
+
+    if (this.MESSAGE_OPCODES.indexOf(frame.opcode) < 0 && frame.length > 125)
+      return this._fail('protocol_error', 'Received control frame having too long payload: ' + frame.length);
+
+    if (!this._checkFrameLength()) return;
+  },
+
+  _checkFrameLength: function() {
+    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 {
+      return true;
+    }
+  },
+
+  _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._message) return this._fail('protocol_error', 'Received unexpected continuation frame');
+      this._message.pushFrame(frame);
+    }
+
+    if (opcode === this.OPCODES.text || opcode === this.OPCODES.binary) {
+      this._message = new Message();
+      this._message.pushFrame(frame);
+    }
+
+    if (frame.final && this.MESSAGE_OPCODES.indexOf(opcode) >= 0)
+      return this._emitMessage(this._message);
+
+    if (opcode === this.OPCODES.close) {
+      code   = (payload.length >= 2) ? payload.readUInt16BE(0) : null;
+      reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
+
+      if (!(payload.length === 0) &&
+          !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
+          this.ERROR_CODES.indexOf(code) < 0)
+        code = this.ERRORS.protocol_error;
+
+      if (payload.length > 125 || (payload.length > 2 && !reason))
+        code = this.ERRORS.protocol_error;
+
+      this._shutdown(code || this.DEFAULT_ERROR_CODE, reason || '');
+    }
+
+    if (opcode === this.OPCODES.ping) {
+      this.frame(payload, 'pong');
+    }
+
+    if (opcode === this.OPCODES.pong) {
+      callbacks = this._pingCallbacks;
+      message   = this._encode(payload);
+      callback  = callbacks[message];
+
+      delete callbacks[message];
+      if (callback) callback()
+    }
+  },
+
+  _emitMessage: function(message) {
+    var message = this._message;
+    message.read();
+
+    delete this._message;
+
+    this._extensions.processIncomingMessage(message, function(error, message) {
+      if (error) return this._fail('extension_error', error.message);
+
+      var payload = message.data;
+      if (message.opcode === this.OPCODES.text) payload = this._encode(payload);
+
+      if (payload === null)
+        return this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
+      else
+        this.emit('message', new Base.MessageEvent(payload));
+    }, this);
+  },
+
+  _encode: function(buffer) {
+    try {
+      var string = buffer.toString('binary', 0, buffer.length);
+      if (!this.UTF8_MATCH.test(string)) return null;
+    } catch (e) {}
+    return buffer.toString('utf8', 0, buffer.length);
+  },
+
+  _readUInt: function(buffer) {
+    if (buffer.length === 2) return buffer.readUInt16BE(0);
+
+    return buffer.readUInt32BE(0) * 0x100000000 +
+           buffer.readUInt32BE(4);
+  }
+};
+
+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/proxy.js

@@ -0,0 +1,98 @@
+'use strict';
+
+var Stream     = require('stream').Stream,
+    url        = require('url'),
+    util       = require('util'),
+    Base       = require('./base'),
+    Headers    = require('./headers'),
+    HttpParser = require('../http_parser');
+
+var PORTS = {'ws:': 80, 'wss:': 443};
+
+var Proxy = function(client, origin, options) {
+  this._client  = client;
+  this._http    = new HttpParser('response');
+  this._origin  = (typeof client.url === 'object') ? client.url : url.parse(client.url);
+  this._url     = (typeof origin === 'object') ? origin : url.parse(origin);
+  this._options = options || {};
+  this._state   = 0;
+
+  this.readable = this.writable = true;
+  this._paused  = false;
+
+  this._headers = new Headers();
+  this._headers.set('Host', this._origin.host);
+  this._headers.set('Connection', 'keep-alive');
+  this._headers.set('Proxy-Connection', 'keep-alive');
+
+  var auth = this._url.auth && 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', new Base.ConnectEvent());
+    } else {
+      var message = "Can't establish a connection to the server at " + this._origin.href;
+      this.emit('error', new Error(message));
+    }
+    this.end();
+    return !this._paused;
+  },
+
+  end: function(chunk) {
+    if (!this.writable) return;
+    if (chunk !== undefined) this.write(chunk);
+    this.readable = this.writable = false;
+    this.emit('close');
+    this.emit('end');
+  },
+
+  destroy: function() {
+    this.end();
+  }
+};
+
+for (var key in instance)
+  Proxy.prototype[key] = instance[key];
+
+module.exports = Proxy;

lib/websocket/driver/server.js

@@ -0,0 +1,108 @@
+'use strict';
+
+var util       = require('util'),
+    HttpParser = require('../http_parser'),
+    Base       = require('./base'),
+    Draft75    = require('./draft75'),
+    Draft76    = require('./draft76'),
+    Hybi       = require('./hybi');
+
+var Server = function(options) {
+  Base.call(this, null, null, options);
+  this._http = new HttpParser('request');
+};
+util.inherits(Server, Base);
+
+var instance = {
+  EVENTS: ['open', 'message', 'error', 'close'],
+
+  _bindEventListeners: function() {
+    this.messages.on('error', function() {});
+    this.on('error', function() {});
+  },
+
+  parse: function(chunk) {
+    if (this._delegate) return this._delegate.parse(chunk);
+
+    this._http.parse(chunk);
+    if (!this._http.isComplete()) return;
+
+    this.method  = this._http.method;
+    this.url     = this._http.url;
+    this.headers = this._http.headers;
+    this.body    = this._http.body;
+
+    var self = this;
+    this._delegate = Server.http(this, this._options);
+    this._delegate.messages = this.messages;
+    this._delegate.io = this.io;
+    this._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());
+  },
+
+  _open: function() {
+    this.__queue.forEach(function(msg) {
+      this._delegate[msg[0]].apply(this._delegate, msg[1]);
+    }, this);
+    this.__queue = [];
+  }
+};
+
+['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);
+    } else {
+      this.__queue.push([method, arguments]);
+      return true;
+    }
+  };
+});
+
+for (var key in instance)
+  Server.prototype[key] = instance[key];
+
+Server.isSecureRequest = function(request) {
+  if (request.connection && request.connection.authorized !== undefined) return true;
+  if (request.socket && request.socket.secure) return true;
+
+  var headers = request.headers;
+  if (!headers) return false;
+  if (headers['https'] === 'on') return true;
+  if (headers['x-forwarded-ssl'] === 'on') return true;
+  if (headers['x-forwarded-scheme'] === 'https') return true;
+  if (headers['x-forwarded-proto'] === 'https') return true;
+
+  return false;
+};
+
+Server.determineUrl = function(request) {
+  var scheme = this.isSecureRequest(request) ? 'wss:' : 'ws:';
+  return scheme + '//' + request.headers.host + request.url;
+};
+
+Server.http = function(request, options) {
+  options = options || {};
+  if (options.requireMasking === undefined) options.requireMasking = true;
+
+  var headers = request.headers,
+      url     = this.determineUrl(request);
+
+  if (headers['sec-websocket-version'])
+    return new Hybi(request, url, options);
+  else if (headers['sec-websocket-key1'])
+    return new Draft76(request, url, options);
+  else
+    return new Draft75(request, url, options);
+};
+
+module.exports = Server;

lib/websocket/driver/stream_reader.js

@@ -0,0 +1,80 @@
+'use strict';
+
+var StreamReader = function() {
+  this._queue     = [];
+  this._queueSize = 0;
+  this._offset    = 0;
+};
+
+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;
+};
+
+StreamReader.prototype.read = function(length) {
+  if (length > this._queueSize) return null;
+  if (length === 0) return new Buffer(0);
+
+  this._queueSize -= length;
+
+  var queue  = this._queue,
+      remain = length,
+      first  = queue[0],
+      buffers, buffer;
+
+  if (first.length >= length) {
+    if (first.length === length) {
+      return queue.shift();
+    } else {
+      buffer = first.slice(0, length);
+      queue[0] = first.slice(length);
+      return buffer;
+    }
+  }
+
+  for (var i = 0, n = queue.length; i < n; i++) {
+    if (remain < queue[i].length) break;
+    remain -= queue[i].length;
+  }
+  buffers = queue.splice(0, i);
+
+  if (remain > 0 && queue.length > 0) {
+    buffers.push(queue[0].slice(0, remain));
+    queue[0] = queue[0].slice(remain);
+  }
+  return this._concat(buffers, length);
+};
+
+StreamReader.prototype.eachByte = function(callback, context) {
+  var buffer, n, index;
+
+  while (this._queue.length > 0) {
+    buffer = this._queue[0];
+    n = buffer.length;
+
+    while (this._offset < n) {
+      index = this._offset;
+      this._offset += 1;
+      callback.call(context, buffer[index]);
+    }
+    this._offset = 0;
+    this._queue.shift();
+  }
+};
+
+StreamReader.prototype._concat = function(buffers, length) {
+  if (Buffer.concat) return Buffer.concat(buffers, length);
+
+  var buffer = new Buffer(length),
+      offset = 0;
+
+  for (var i = 0, n = buffers.length; i < n; i++) {
+    buffers[i].copy(buffer, offset);
+    offset += buffers[i].length;
+  }
+  return buffer;
+};
+
+module.exports = StreamReader;

lib/websocket/http_parser.js

@@ -0,0 +1,100 @@
+'use strict';
+
+var NodeHTTPParser = process.binding('http_parser').HTTPParser,
+    version        = NodeHTTPParser.RESPONSE ? 6 : 4;
+
+var HttpParser = function(type) {
+  if (type === 'request')
+    this._parser = new NodeHTTPParser(NodeHTTPParser.REQUEST || 'request');
+  else
+    this._parser = new NodeHTTPParser(NodeHTTPParser.RESPONSE || 'response');
+
+  this._type     = type;
+  this._complete = false;
+  this.headers   = {};
+
+  var current = null,
+      self    = this;
+
+  this._parser.onHeaderField = function(b, start, length) {
+    current = b.toString('utf8', start, start + length).toLowerCase();
+  };
+
+  this._parser.onHeaderValue = function(b, start, length) {
+    var value = b.toString('utf8', start, start + length);
+
+    if (self.headers.hasOwnProperty(current))
+      self.headers[current] += ', ' + value;
+    else
+      self.headers[current] = value;
+  };
+
+  this._parser.onHeadersComplete = this._parser[NodeHTTPParser.kOnHeadersComplete] =
+  function(majorVersion, minorVersion, headers, method, pathname, statusCode) {
+    var info = arguments[0];
+
+    if (typeof info === 'object') {
+      method     = info.method;
+      pathname   = info.url;
+      statusCode = info.statusCode;
+      headers    = info.headers;
+    }
+
+    self.method     = (typeof method === 'number') ? HttpParser.METHODS[method] : method;
+    self.statusCode = statusCode;
+    self.url        = pathname;
+
+    if (!headers) return;
+
+    for (var i = 0, n = headers.length, key, value; i < n; i += 2) {
+      key   = headers[i].toLowerCase();
+      value = headers[i+1];
+      if (self.headers.hasOwnProperty(key))
+        self.headers[key] += ', ' + value;
+      else
+        self.headers[key] = value;
+    }
+
+    self._complete = true;
+  };
+};
+
+HttpParser.METHODS = {
+  0:  'DELETE',
+  1:  'GET',
+  2:  'HEAD',
+  3:  'POST',
+  4:  'PUT',
+  5:  'CONNECT',
+  6:  'OPTIONS',
+  7:  'TRACE',
+  8:  'COPY',
+  9:  'LOCK',
+  10: 'MKCOL',
+  11: 'MOVE',
+  12: 'PROPFIND',
+  13: 'PROPPATCH',
+  14: 'SEARCH',
+  15: 'UNLOCK',
+  16: 'REPORT',
+  17: 'MKACTIVITY',
+  18: 'CHECKOUT',
+  19: 'MERGE',
+  24: 'PATCH'
+};
+
+HttpParser.prototype.isComplete = function() {
+  return this._complete;
+};
+
+HttpParser.prototype.parse = function(chunk) {
+  var offset   = (version < 6) ? 1 : 0,
+      consumed = this._parser.execute(chunk, 0, chunk.length) + offset;
+
+  if (this._complete)
+    this.body = (consumed < chunk.length)
+              ? chunk.slice(consumed)
+              : new Buffer(0);
+};
+
+module.exports = HttpParser;

lib/websocket/streams.js

@@ -0,0 +1,146 @@
+'use strict';
+
+/**
+
+Streams in a WebSocket connection
+---------------------------------
+
+We model a WebSocket as two duplex streams: one stream is for the wire protocol
+over an I/O socket, and the other is for incoming/outgoing messages.
+
+
+                        +----------+      +---------+      +----------+
+    [1] write(chunk) -->| ~~~~~~~~ +----->| parse() +----->| ~~~~~~~~ +--> emit('data') [2]
+                        |          |      +----+----+      |          |
+                        |          |           |           |          |
+                        |    IO    |           | [5]       | Messages |
+                        |          |           V           |          |
+                        |          |      +---------+      |          |
+    [4] emit('data') <--+ ~~~~~~~~ |<-----+ frame() |<-----+ ~~~~~~~~ |<-- write(chunk) [3]
+                        +----------+      +---------+      +----------+
+
+
+Message transfer in each direction is simple: IO receives a byte stream [1] and
+sends this stream for parsing. The parser will periodically emit a complete
+message text on the Messages stream [2]. Similarly, when messages are written
+to the Messages stream [3], they are framed using the WebSocket wire format and
+emitted via IO [4].
+
+There is a feedback loop via [5] since some input from [1] will be things like
+ping, pong and close frames. In these cases the protocol responds by emitting
+responses directly back to [4] rather than emitting messages via [2].
+
+For the purposes of flow control, we consider the sources of each Readable
+stream to be as follows:
+
+* [2] receives input from [1]
+* [4] receives input from [1] and [3]
+
+The classes below express the relationships described above without prescribing
+anything about how parse() and frame() work, other than assuming they emit
+'data' events to the IO and Messages streams. They will work with any protocol
+driver having these two methods.
+**/
+
+
+var Stream = require('stream').Stream,
+    util   = require('util');
+
+
+var IO = function(driver) {
+  this.readable = this.writable = true;
+  this._paused  = false;
+  this._driver  = driver;
+};
+util.inherits(IO, Stream);
+
+// The IO pause() and resume() methods will be called when the socket we are
+// piping to gets backed up and drains. Since IO output [4] comes from IO input
+// [1] and Messages input [3], we need to tell both of those to return false
+// from write() when this stream is paused.
+
+IO.prototype.pause = function() {
+  this._paused = true;
+  this._driver.messages._paused = true;
+};
+
+IO.prototype.resume = function() {
+  this._paused = false;
+  this.emit('drain');
+
+  var messages = this._driver.messages;
+  messages._paused = false;
+  messages.emit('drain');
+};
+
+// When we receive input from a socket, send it to the parser and tell the
+// source whether to back off.
+IO.prototype.write = function(chunk) {
+  if (!this.writable) return false;
+  this._driver.parse(chunk);
+  return !this._paused;
+};
+
+// The IO end() method will be called when the socket piping into it emits
+// 'close' or 'end', i.e. the socket is closed. In this situation the Messages
+// stream will not emit any more data so we emit 'end'.
+IO.prototype.end = function(chunk) {
+  if (!this.writable) return;
+  if (chunk !== undefined) this.write(chunk);
+  this.writable = false;
+
+  var messages = this._driver.messages;
+  if (messages.readable) {
+    messages.readable = messages.writable = false;
+    messages.emit('end');
+  }
+};
+
+IO.prototype.destroy = function() {
+  this.end();
+};
+
+
+var Messages = function(driver) {
+  this.readable = this.writable = true;
+  this._paused  = false;
+  this._driver  = driver;
+};
+util.inherits(Messages, Stream);
+
+// The Messages pause() and resume() methods will be called when the app that's
+// processing the messages gets backed up and drains. If we're emitting
+// messages too fast we should tell the source to slow down. Message output [2]
+// comes from IO input [1].
+
+Messages.prototype.pause = function() {
+  this._driver.io._paused = true;
+};
+
+Messages.prototype.resume = function() {
+  this._driver.io._paused = false;
+  this._driver.io.emit('drain');
+};
+
+// When we receive messages from the user, send them to the formatter and tell
+// the source whether to back off.
+Messages.prototype.write = function(message) {
+  if (!this.writable) return false;
+  if (typeof message === 'string') this._driver.text(message);
+  else this._driver.binary(message);
+  return !this._paused;
+};
+
+// The Messages end() method will be called when a stream piping into it emits
+// 'end'. Many streams may be piped into the WebSocket and one of them ending
+// does not mean the whole socket is done, so just process the input and move
+// on leaving the socket open.
+Messages.prototype.end = function(message) {
+  if (message !== undefined) this.write(message);
+};
+
+Messages.prototype.destroy = function() {};
+
+
+exports.IO = IO;
+exports.Messages = Messages;

package.json

@@ -1,22 +1,21 @@
-{ "name"            : "faye-websocket"
-, "description"     : "Standards-compliant WebSocket server and client"
-, "homepage"        : "http://github.com/faye/faye-websocket-node"
+{ "name"            : "websocket-driver"
+, "description"     : "WebSocket protocol handler with pluggable I/O"
+, "homepage"        : "http://github.com/faye/websocket-driver-node"
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
-, "keywords"        : ["websocket", "eventsource"]
+, "keywords"        : ["websocket"]
 , "license"         : "MIT"
 
-, "version"         : "0.7.2"
-, "engines"         : {"node": ">=0.4.0"}
-, "main"            : "./lib/faye/websocket"
-, "dependencies"    : {"websocket-driver": ">=0.3.1"}
-, "devDependencies" : {"jstest": "", "pace": ""}
+, "version"         : "0.6.3"
+, "engines"         : {"node": ">=0.6.0"}
+, "main"            : "./lib/websocket/driver"
+, "dependencies"    : {"websocket-extensions": ">=0.1.1"}
+, "devDependencies" : {"jstest": "", "permessage-deflate": ""}
 
 , "scripts"         : {"test": "jstest spec/runner.js"}
 
 , "repository"      : { "type"  : "git"
-                      , "url"   : "git://github.com/faye/faye-websocket-node.git"
+                      , "url"   : "git://github.com/faye/websocket-driver-node.git"
                       }
 
-, "bugs"            : "http://github.com/faye/faye-websocket-node/issues"
+, "bugs"            : "http://github.com/faye/websocket-driver-node/issues"
 }
-

spec/faye/websocket/client_spec.js

@@ -1,181 +0,0 @@
-var Client = require('../../../lib/faye/websocket/client'),
-    test   = require('jstest').Test,
-    fs     = require('fs')
-
-var WebSocketSteps = test.asyncSteps({
-  server: function(port, secure, callback) {
-    this._adapter = new EchoServer()
-    this._adapter.listen(port, secure)
-    this._port = port
-    process.nextTick(callback)
-  },
-
-  stop: function(callback) {
-    this._adapter.stop()
-    process.nextTick(callback)
-  },
-
-  open_socket: function(url, protocols, callback) {
-    var done = false,
-        self = this,
-
-        resume = function(open) {
-                   if (done) return
-                   done = true
-                   self._open = open
-                   callback()
-                 }
-
-    this._ws = new Client(url, protocols, {
-      ca: fs.readFileSync(__dirname + '/../../server.crt')
-    })
-
-    this._ws.onopen  = function() { resume(true)  }
-    this._ws.onclose = function() { resume(false) }
-  },
-
-  close_socket: function(callback) {
-    var self = this
-    this._ws.onclose = function() {
-      self._open = false
-      callback()
-    }
-    this._ws.close()
-  },
-
-  check_open: function(callback) {
-    this.assert( this._open )
-    callback()
-  },
-
-  check_closed: function(callback) {
-    this.assert( !this._open )
-    callback()
-  },
-
-  check_protocol: function(protocol, callback) {
-    this.assertEqual( protocol, this._ws.protocol )
-    callback()
-  },
-
-  listen_for_message: function(callback) {
-    var time = new Date().getTime(), self = this
-    this._ws.addEventListener('message', function(message) { self._message = message.data })
-    var timer = setInterval(function() {
-      if (self._message || new Date().getTime() - time > 3000) {
-        clearInterval(timer)
-        callback()
-      }
-    }, 100)
-  },
-
-  send_message: function(message, callback) {
-    var ws = this._ws
-    setTimeout(function() { ws.send(message) }, 500)
-    process.nextTick(callback)
-  },
-
-  check_response: function(message, callback) {
-    this.assertEqual( message, this._message )
-    callback()
-  },
-
-  check_no_response: function(callback) {
-    this.assert( !this._message )
-    callback()
-  }
-})
-
-
-test.describe("Client", function() { with(this) {
-  include(WebSocketSteps)
-
-  before(function() {
-    this.protocols       = ["foo", "echo"]
-    this.plain_text_url  = "ws://localhost:4180/bayeux"
-    this.secure_url      = "wss://localhost:4180/bayeux"
-    this.port            = 4180
-  })
-
-  sharedBehavior("socket client", function() { with(this) {
-    it("can open a connection", function() { with(this) {
-      open_socket(socket_url, protocols)
-      check_open()
-      check_protocol("echo")
-    }})
-
-    it("can close the connection", function() { with(this) {
-      open_socket(socket_url, protocols)
-      close_socket()
-      check_closed()
-    }})
-
-    describe("in the OPEN state", function() { with(this) {
-      before(function() { with(this) {
-        open_socket(socket_url, protocols)
-      }})
-
-      it("can send and receive messages", function() { with(this) {
-        send_message("I expect this to be echoed")
-        listen_for_message()
-        check_response("I expect this to be echoed")
-      }})
-
-      it("sends numbers as strings", function() { with(this) {
-        send_message(13)
-        listen_for_message()
-        check_response("13")
-      }})
-
-      it("sends booleans as strings", function() { with(this) {
-        send_message(false)
-        listen_for_message()
-        check_response("false")
-      }})
-
-      it("sends arrays as strings", function() { with(this) {
-        send_message([13,14,15])
-        listen_for_message()
-        check_response("13,14,15")
-      }})
-    }})
-
-    describe("in the CLOSED state", function() { with(this) {
-      before(function() { with(this) {
-        open_socket(socket_url, protocols)
-        close_socket()
-      }})
-
-      it("cannot send and receive messages", function() { with(this) {
-        send_message("I expect this to be echoed")
-        listen_for_message()
-        check_no_response()
-      }})
-    }})
-  }})
-
-  describe("with a plain-text server", function() { with(this) {
-    before(function() {
-      this.socket_url  = this.plain_text_url
-      this.blocked_url = this.secure_url
-    })
-
-    before(function() { this.server(4180, false) })
-    after (function() { this.stop() })
-
-    behavesLike("socket client")
-  }})
-
-  describe("with a secure server", function() { with(this) {
-    before(function() {
-      this.socket_url  = this.secure_url
-      this.blocked_url = this.plain_text_url
-    })
-
-    before(function() { this.server(4180, true) })
-    after (function() { this.stop() })
-
-    behavesLike("socket client")
-  }})
-}})
-

spec/runner.js

@@ -1,33 +1,44 @@
-var WebSocket = require('../lib/faye/websocket'),
-    fs        = require('fs'),
-    http      = require('http'),
-    https     = require('https'),
-    test      = require('jstest').Test
+var test   = require('jstest').Test,
+    Stream = require('stream').Stream,
+    util   = require('util')
 
-
-EchoServer = function() {}
-EchoServer.prototype.listen = function(port, ssl) {
-  var server = ssl
-             ? https.createServer({
-                 key:  fs.readFileSync(__dirname + '/server.key'),
-                 cert: fs.readFileSync(__dirname + '/server.crt')
-               })
-             : http.createServer()
-
-  server.on('upgrade', function(request, socket, head) {
-    var ws = new WebSocket(request, socket, head, ["echo"])
-    ws.pipe(ws)
-  })
-  this._httpServer = server
-  server.listen(port)
+var BufferMatcher = function(data) {
+  this._data = (typeof data === 'string')
+             ? new Buffer(data, 'utf8')
+             : new Buffer(data)
 }
-EchoServer.prototype.stop = function(callback, scope) {
-  this._httpServer.on('close', function() {
-    if (callback) callback.call(scope);
-  });
-  this._httpServer.close();
+BufferMatcher.prototype.equals = function(other) {
+  if (this._data.length !== other.length) return false;
+  for (var i = 0, n = other.length; i < n; i++) {
+    if (other[i] !== this._data[i]) return false;
+  }
+  return true;
 }
 
+var Collector = function() {
+  this.bytes = []
+  this.writable = true
+}
+util.inherits(Collector, Stream)
+Collector.prototype.write = function(buffer) {
+  this.bytes = []
+  for (var i = 0, n = buffer.length; i < n; i++) {
+    this.bytes[i] = buffer[i]
+  }
+  return true
+}
 
-require('./faye/websocket/client_spec')
+test.Unit.TestCase.include({
+  buffer: function(data) {
+    return new BufferMatcher(data)
+  },
+  collector: function() {
+    return this._collector = this._collector || new Collector()
+  }
+})
 
+require('./websocket/driver/draft75_examples')
+require('./websocket/driver/draft75_spec')
+require('./websocket/driver/draft76_spec')
+require('./websocket/driver/hybi_spec')
+require('./websocket/driver/client_spec')

spec/server.crt

@@ -1,14 +0,0 @@
------BEGIN CERTIFICATE-----
-MIICKTCCAZICCQDtAJo/efrTvjANBgkqhkiG9w0BAQUFADBZMQswCQYDVQQGEwJV
-SzETMBEGA1UECBMKU29tZS1TdGF0ZTEPMA0GA1UEBxMGTG9uZG9uMRAwDgYDVQQK
-EwdqY29nbGFuMRIwEAYDVQQDEwlsb2NhbGhvc3QwHhcNMTMwNjE5MDcwNzQ1WhcN
-MTQwNjE5MDcwNzQ1WjBZMQswCQYDVQQGEwJVSzETMBEGA1UECBMKU29tZS1TdGF0
-ZTEPMA0GA1UEBxMGTG9uZG9uMRAwDgYDVQQKEwdqY29nbGFuMRIwEAYDVQQDEwls
-b2NhbGhvc3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALhPVRbctfcjCJEC
-DsZfgtTMVYMsvV/miLxc7veumuuApe5y3DFuG8Tlz3/0wrvRm3dCSUOfIBK8ktor
-VoY6QGHwrhYK2MhnJQOUTYC+FCyUp4zAYjRgJWd4uTii+uqRbLCPOF8jEx7VunTT
-Lj9hu82IdRgT3OtqzPUoTmYXCXSZAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAcARo
-TO7LTbII0HIsB7PePspFkwiuYQtvFqYm10I+4yuIdfPBdH0/OBhKvNC1O7tc7dmy
-NPd8e5FXrt6qHDgCVh0kpg37sMJp42jUCn4lguWKN5dZPkzGrRFUfXvcx1qwdF2T
-0CgyULvKWl9wt3Wp5feG8dNn1UZOGlZBZ+0GNyk=
------END CERTIFICATE-----

spec/server.key

@@ -1,15 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQC4T1UW3LX3IwiRAg7GX4LUzFWDLL1f5oi8XO73rprrgKXuctwx
-bhvE5c9/9MK70Zt3QklDnyASvJLaK1aGOkBh8K4WCtjIZyUDlE2AvhQslKeMwGI0
-YCVneLk4ovrqkWywjzhfIxMe1bp00y4/YbvNiHUYE9zrasz1KE5mFwl0mQIDAQAB
-AoGAfcTc6oHnxeHpKZJ+5I0uaOmafK2d+IAG1IqSIv/KBWQ/VoyYhz58woqTYtxx
-udqZvPLFrdg6+a4mg6vJGkVLwp/PFi7r57/vqUR/P8SnuV0iTJZ7BczZHSffdzgT
-9v2XUDFZ3ZSjIi+XkCMirHc7G8BVYImqjCGy80NX3YB5RRECQQDuX+udSSZi2I0C
-gT/LnoVsb8JkanNALZH/U/XQog50I9aNf2GAAboUVsGuETL3I9f12Ku0A+xK5biv
-s4P4g01FAkEAxfALp1Yzud+ooNmbbtSTE6hrUwjFeG1skEW4GvocB5ZiQqXwv59v
-AmWedup7St2kamb5vNtcpewHGd2kUpatRQJARDwg7f0qh9EFTFpDML5H4yp6stPl
-+dERoc0e6IH7MTOxDwAPoNzdr0TGXFWACU6xWyaSwAz/btEjdOgmNtUfIQJAFrWO
-sLksIBQwBZxRv+p1oVi+T31/Imzzeq31DGtLkfdH+LuPHn0NQGomPyBx2soJFggQ
-eQF15LdqrSYHt04APQJBAO2SPMC7MxDKdhryf6PDcaL/lTKSxRttQ72jZmDU9ujp
-dcvFPgrQTa3iNLm4SWvARFXXZrrGEeDgKX7jVJygfI4=
------END RSA PRIVATE KEY-----

spec/websocket/driver/client_spec.js

@@ -0,0 +1,333 @@
+var Client = require("../../../lib/websocket/driver/client"),
+    test   = require('jstest').Test
+
+test.describe("Client", function() { with(this) {
+    define("options", function() {
+    return this._options = this._options || {protocols: this.protocols()}
+  })
+
+  define("protocols", function() {
+    null
+  })
+
+  define("url", function() {
+    return "ws://www.example.com/socket"
+  })
+
+  define("driver", function() {
+    if (this._driver) return this._driver
+    this._driver = new Client(this.url(), this.options())
+    var self = this
+    this._driver.on('open',    function(e) { self.open = true })
+    this._driver.on('message', function(e) { self.message += e.data })
+    this._driver.on('error',   function(e) { self.error = e })
+    this._driver.on('close',   function(e) { self.close = [e.code, e.reason] })
+    var collector = this.collector()
+    this._driver.io.on("data", function(d) { collector.write(d) })
+    return this._driver
+  })
+
+  define("key", function() {
+    return "2vBVWg4Qyk3ZoM/5d3QD9Q=="
+  })
+
+  define("response", function() {
+    return "HTTP/1.1 101 Switching Protocols\r\n" +
+           "Upgrade: websocket\r\n" +
+           "Connection: Upgrade\r\n" +
+           "Sec-WebSocket-Accept: QV3I5XUXU2CdhtjixE7QCkCcMZM=\r\n" +
+           "\r\n"
+  })
+
+  before(function() {
+    this.stub(Client, "generateKey").returns(this.key())
+    this.open = this.error = this.close = false
+    this.message = ""
+  })
+
+  describe("in the beginning state", function() { with(this) {
+    it("starts in no state", 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(
+            "GET /socket HTTP/1.1\r\n" +
+            "Host: www.example.com\r\n" +
+            "Upgrade: websocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
+            "Sec-WebSocket-Version: 13\r\n" +
+            "\r\n"))
+        driver().start()
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().start() )
+      }})
+
+      describe("with subprotocols", function() { with(this) {
+        define("protocols", function() { return ["foo", "bar", "xmpp"] })
+
+        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(
+              "GET /socket HTTP/1.1\r\n" +
+              "Host: www.example.com\r\n" +
+              "Upgrade: websocket\r\n" +
+              "Connection: Upgrade\r\n" +
+              "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
+              "Sec-WebSocket-Version: 13\r\n" +
+              "Sec-WebSocket-Protocol: foo, bar, xmpp\r\n" +
+              "\r\n"))
+          driver().start()
+        }})
+      }})
+
+      describe("with basic auth", function() { with(this) {
+        define("url", function() { return "ws://user:pass@www.example.com/socket" })
+
+        it("writes the handshake with Authorization", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(
+              "GET /socket HTTP/1.1\r\n" +
+              "Host: www.example.com\r\n" +
+              "Upgrade: websocket\r\n" +
+              "Connection: Upgrade\r\n" +
+              "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
+              "Sec-WebSocket-Version: 13\r\n" +
+              "Authorization: Basic dXNlcjpwYXNz\r\n" +
+              "\r\n"))
+          driver().start()
+        }})
+      }})
+
+      describe("with an invalid URL", function() { with(this) {
+        define("url", function() { return "stream.wikimedia.org/rc" })
+
+        it("throws an error", function() { with(this) {
+          var message
+          try { driver() } catch (e) { message = e.message }
+          assertEqual( "stream.wikimedia.org/rc is not a valid WebSocket URL", message )
+        }})
+      }})
+
+      describe("with custom headers", function() { with(this) {
+        before(function() { with(this) {
+          driver().setHeader("User-Agent", "Chrome")
+        }})
+
+        it("writes the handshake with custom headers", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(
+              "GET /socket HTTP/1.1\r\n" +
+              "Host: www.example.com\r\n" +
+              "Upgrade: websocket\r\n" +
+              "Connection: Upgrade\r\n" +
+              "Sec-WebSocket-Key: 2vBVWg4Qyk3ZoM/5d3QD9Q==\r\n" +
+              "Sec-WebSocket-Version: 13\r\n" +
+              "User-Agent: Chrome\r\n" +
+              "\r\n"))
+          driver().start()
+        }})
+      }})
+
+      it("changes the state to connecting", function() { with(this) {
+        driver().start()
+        assertEqual( "connecting", driver().getState() )
+      }})
+    }})
+  }})
+
+  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", anything())
+        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() { this.driver().parse(new Buffer(this.response())) })
+
+      it("changes the state to open", function() { with(this) {
+        assertEqual( true, open )
+        assertEqual( false, close )
+        assertEqual( "open", driver().getState() )
+      }})
+
+      it("makes the response status available", function() { with(this) {
+        assertEqual( 101, driver().statusCode )
+      }})
+
+      it("makes the response headers available", function() { with(this) {
+        assertEqual( "websocket", driver().headers.upgrade )
+      }})
+    }})
+
+    describe("with a valid response followed by a frame", function() { 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)
+      }})
+
+      it("changes the state to open", function() { with(this) {
+        assertEqual( true, open )
+        assertEqual( false, close )
+        assertEqual( "open", driver().getState() )
+      }})
+
+      it("parses the frame", function() { with(this) {
+        assertEqual( "Hi", message )
+      }})
+    }})
+
+    describe("with a bad status line", function() { with(this) {
+      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 )
+        assertEqual( "Error during WebSocket handshake: Unexpected response code: 4", error.message )
+        assertEqual( [1002, "Error during WebSocket handshake: Unexpected response code: 4"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+
+    describe("with a bad Upgrade header", function() { with(this) {
+      before(function() {
+        var resp = this.response().replace(/websocket/g, "wrong")
+        this.driver().parse(new Buffer(resp))
+      })
+
+      it("changes the state to closed", function() { with(this) {
+        assertEqual( false, open )
+        assertEqual( "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'", error.message )
+        assertEqual( [1002, "Error during WebSocket handshake: 'Upgrade' header value is not 'WebSocket'"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+
+    describe("with a bad Accept header", function() { with(this) {
+      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 )
+        assertEqual( "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch", error.message )
+        assertEqual( [1002, "Error during WebSocket handshake: Sec-WebSocket-Accept mismatch"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+
+    describe("with valid subprotocols", function() { with(this) {
+      define("protocols", function() { return ["foo", "xmpp"] })
+
+      before(function() {
+        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: xmpp\r\n\r\n")
+        this.driver().parse(new Buffer(resp))
+      })
+
+      it("changs the state to open", function() { with(this) {
+        assertEqual( true, open )
+        assertEqual( false, close )
+        assertEqual( "open", driver().getState() )
+      }})
+
+      it("selects the subprotocol", function() { with(this) {
+        assertEqual( "xmpp", driver().protocol )
+      }})
+    }})
+
+    describe("with invalid subprotocols", function() { with(this) {
+      define("protocols", function() { return ["foo", "xmpp"] })
+
+      before(function() {
+        var resp = this.response().replace(/\r\n\r\n/, "\r\nSec-WebSocket-Protocol: irc\r\n\r\n")
+        this.driver().parse(new Buffer(resp))
+      })
+
+      it("changs the state to closed", function() { with(this) {
+        assertEqual( false, open )
+        assertEqual( "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch", error.message )
+        assertEqual( [1002, "Error during WebSocket handshake: Sec-WebSocket-Protocol mismatch"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+
+      it("selects no subprotocol", function() { with(this) {
+        assertEqual( null, driver().protocol )
+      }})
+    }})
+  }})
+}})

spec/websocket/driver/draft75_examples.js

@@ -0,0 +1,136 @@
+var test = require('jstest').Test
+
+test.describe("draft-75", function() { with(this) {
+  sharedExamplesFor("draft-75 protocol", function() { with(this) {
+    describe("in the open state", function() { with(this) {
+      before(function() { this.driver().start() })
+
+      describe("parse", function() { with(this) {
+        it("parses text frames", function() { with(this) {
+          driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+          assertEqual( "Hello", message )
+        }})
+
+        it("parses multiple frames from the same packet", function() { with(this) {
+          driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+          assertEqual( "HelloHello", message )
+        }})
+
+        it("parses text frames beginning 0x00-0x7F", function() { with(this) {
+          driver().parse([0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+          assertEqual( "Hello", message )
+        }})
+
+        it("ignores frames with a length header", function() { with(this) {
+          driver().parse([0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+          assertEqual( "Hello", message )
+        }})
+
+        it("parses multibyte text frames", function() { with(this) {
+          driver().parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
+          assertEqual( "Apple = ", message )
+        }})
+
+        it("parses frames received in several packets", function() { with(this) {
+          driver().parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65])
+          driver().parse([0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
+          assertEqual( "Apple = ", message )
+        }})
+
+        it("parses fragmented frames", function() { with(this) {
+          driver().parse([0x00, 0x48, 0x65, 0x6c])
+          driver().parse([0x6c, 0x6f, 0xff])
+          assertEqual( "Hello", message )
+        }})
+
+        describe("when a message listener throws an error", function() { with(this) {
+          before(function() { with(this) {
+            this.messages = []
+
+            driver().on("message", function(msg) {
+              messages.push(msg.data)
+              throw new Error("an error")
+            })
+          }})
+
+          it("is not trapped by the parser", function() { with(this) {
+            var buffer = [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+            assertThrows(Error, function() { driver().parse(buffer) })
+          }})
+
+          it("parses text frames without dropping input", function() { with(this) {
+            try { driver().parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x57]) } catch (e) {}
+            try { driver().parse([0x6f, 0x72, 0x6c, 0x64, 0xff]) } catch (e) {}
+            assertEqual( ["Hello", "World"], messages )
+          }})
+        }})
+      }})
+
+      describe("frame", function() { with(this) {
+        it("formats the given string as a WebSocket frame", function() { with(this) {
+          driver().frame("Hello")
+          assertEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], collector().bytes )
+        }})
+
+        it("encodes multibyte characters correctly", function() { with(this) {
+          driver().frame("Apple = ")
+          assertEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], collector().bytes )
+        }})
+
+        it("returns true", function() { with(this) {
+          assertEqual( true, driver().frame("lol") )
+        }})
+      }})
+
+      describe("ping", function() { with(this) {
+        it("does not write to the socket", function() { with(this) {
+          expect(driver().io, "emit").exactly(0)
+          driver().ping()
+        }})
+
+        it("returns false", function() { with(this) {
+          assertEqual( false, driver().ping() )
+        }})
+      }})
+
+      describe("close", function() { with(this) {
+        it("triggers the onclose event", function() { with(this) {
+          driver().close()
+          assertEqual( true, close )
+        }})
+
+        it("returns true", function() { with(this) {
+          assertEqual( true, driver().close() )
+        }})
+
+        it("changes the state to closed", function() { with(this) {
+          driver().close()
+          assertEqual( "closed", driver().getState() )
+        }})
+      }})
+    }})
+
+    describe("in the closed state", function() { with(this) {
+      before(function() {
+        this.driver().start()
+        this.driver().close()
+      })
+
+      describe("close", function() { with(this) {
+        it("does not write to the socket", function() { with(this) {
+          expect(driver().io, "emit").exactly(0)
+          driver().close()
+        }})
+
+        it("returns false", function() { with(this) {
+          assertEqual( false, driver().close() )
+        }})
+
+        it("leaves the protocol in the closed state", function() { with(this) {
+          driver().close()
+          assertEqual( "closed", driver().getState() )
+        }})
+      }})
+    }})
+  }})
+}})

spec/websocket/driver/draft75_spec.js

@@ -0,0 +1,99 @@
+var Draft75 = require("../../../lib/websocket/driver/draft75"),
+    test    = require('jstest').Test
+
+test.describe("Draft75", function() { with(this) {
+  define("request", function() {
+    return this._request = this._request || {
+      headers: {
+        "connection": "Upgrade",
+        "upgrade":    "WebSocket",
+        "origin":     "http://www.example.com"
+      }
+    }
+  })
+
+  define("options", function() {
+    return this._options = this._options || {masking: false}
+  })
+
+  define("driver", function() {
+    if (this._driver) return this._driver
+    this._driver = new Draft75(this.request(), "ws://www.example.com/socket", this.options())
+    var self = this
+    this._driver.on('open',    function(e) { self.open = true })
+    this._driver.on('message', function(e) { self.message += e.data })
+    this._driver.on('close',   function(e) { self.close = true })
+    this._driver.io.pipe(this.collector())
+    return this._driver
+  })
+
+  before(function() {
+    this.open = this.close = false
+    this.message = ""
+  })
+
+  describe("in the connecting state", function() { with(this) {
+    it("starts in the connecting state", function() { with(this) {
+      assertEqual( "connecting", driver().getState() )
+    }})
+
+    describe("start", function() { with(this) {
+      it("writes the handshake response to the socket", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" +
+            "Upgrade: WebSocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "WebSocket-Origin: http://www.example.com\r\n" +
+            "WebSocket-Location: ws://www.example.com/socket\r\n" +
+            "\r\n"))
+        driver().start()
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().start() )
+      }})
+
+      it("triggers the onopen event", function() { with(this) {
+        driver().start()
+        assertEqual( true, open )
+      }})
+
+      it("changes the state to open", function() { with(this) {
+        driver().start()
+        assertEqual( "open", driver().getState() )
+      }})
+
+      it("sets the protocol version", function() { with(this) {
+        driver().start()
+        assertEqual( "hixie-75", driver().version )
+      }})
+    }})
+
+    describe("frame", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().frame("Hello, world")
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().frame("whatever") )
+      }})
+
+      it("queues the frames until the handshake has been sent", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" +
+            "Upgrade: WebSocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "WebSocket-Origin: http://www.example.com\r\n" +
+            "WebSocket-Location: ws://www.example.com/socket\r\n" +
+            "\r\n"))
+        expect(driver().io, "emit").given("data", buffer([0x00, 0x48, 0x69, 0xff]))
+
+        driver().frame("Hi")
+        driver().start()
+      }})
+    }})
+  }})
+
+  itShouldBehaveLike("draft-75 protocol")
+}})

spec/websocket/driver/draft76_spec.js

@@ -0,0 +1,218 @@
+var Draft76 = require("../../../lib/websocket/driver/draft76"),
+    test    = require('jstest').Test
+
+test.describe("Draft76", function() { with(this) {
+  BODY = new Buffer([0x91, 0x25, 0x3e, 0xd3, 0xa9, 0xe7, 0x6a, 0x88])
+
+  define("body", function() {
+    return BODY
+  })
+
+  define("response", function() {
+    return [0xb4, 0x9c, 0x6e, 0x40, 0x53, 0x04, 0x04, 0x26, 0xe5, 0x1b, 0xbf, 0x6c, 0xb7, 0x9f, 0x1d, 0xf9]
+  })
+
+  define("request", function() {
+    return this._request = this._request || {
+      headers: {
+        "connection":         "Upgrade",
+        "upgrade":            "WebSocket",
+        "origin":             "http://www.example.com",
+        "sec-websocket-key1": "1   38 wZ3f9 23O0 3l 0r",
+        "sec-websocket-key2": "27   0E 6 2  1665:< ;U 1H"
+      }
+    }
+  })
+
+  define("options", function() {
+    return this._options = this._options || {masking: false}
+  })
+
+  define("driver", function() {
+    if (this._driver) return this._driver
+    this._driver = new Draft76(this.request(), "ws://www.example.com/socket", this.options())
+    var self = this
+    this._driver.on('open',    function(e) { self.open = true })
+    this._driver.on('message', function(e) { self.message += e.data })
+    this._driver.on('error',   function(e) { self.error = e })
+    this._driver.on('close',   function(e) { self.close = true })
+    this._driver.io.pipe(this.collector())
+    this._driver.io.write(this.body())
+    return this._driver
+  })
+
+  before(function() {
+    this.open = this.close = false
+    this.message = ""
+  })
+
+  describe("in the connecting state", function() { with(this) {
+    it("starts in the connecting state", function() { with(this) {
+      assertEqual( "connecting", driver().getState() )
+    }})
+
+    describe("start", function() { with(this) {
+      it("writes the handshake response to the socket", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" +
+            "Upgrade: WebSocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Origin: http://www.example.com\r\n" +
+            "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" +
+            "\r\n"))
+        expect(driver().io, "emit").given("data", buffer(response()))
+        driver().start()
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().start() )
+      }})
+
+      it("triggers the onopen event", function() { with(this) {
+        driver().start()
+        assertEqual( true, open )
+      }})
+
+      it("changes the state to open", function() { with(this) {
+        driver().start()
+        assertEqual( "open", driver().getState() )
+      }})
+
+      it("sets the protocol version", function() { with(this) {
+        driver().start()
+        assertEqual( "hixie-76", driver().version )
+      }})
+
+      describe("with an invalid key header", function() { with(this) {
+        before(function() { with(this) {
+          request().headers["sec-websocket-key1"] = "2 L785 8o% s9Sy9@V. 4<1P5"
+        }})
+
+        it("writes a closing frame to the socket", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer([0xff, 0x00]))
+          driver().start()
+        }})
+
+        it("does not trigger the onopen event", function() { with(this) {
+          driver().start()
+          assertEqual( false, open )
+        }})
+
+        it("triggers the onerror event", function() { with(this) {
+          driver().start()
+          assertEqual( "Client sent invalid Sec-WebSocket-Key headers", error.message )
+        }})
+
+        it("triggers the onclose event", function() { with(this) {
+          driver().start()
+          assertEqual( true, close )
+        }})
+
+        it("changes the state to closed", function() { with(this) {
+          driver().start()
+          assertEqual( "closed", driver().getState()  )
+        }})
+      }})
+    }})
+
+    describe("frame", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().frame("Hello, world")
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().frame("whatever") )
+      }})
+
+      it("queues the frames until the handshake has been sent", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" +
+            "Upgrade: WebSocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Origin: http://www.example.com\r\n" +
+            "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" +
+            "\r\n"))
+        expect(driver().io, "emit").given("data", buffer(response()))
+        expect(driver().io, "emit").given("data", buffer([0x00, 72, 105, 0xff]))
+
+        driver().frame("Hi")
+        driver().start()
+      }})
+    }})
+
+    describe("with no request body", function() { with(this) {
+      define("body", function() {
+        return new Buffer([])
+      })
+
+      it("writes the handshake response with no body", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 WebSocket Protocol Handshake\r\n" +
+            "Upgrade: WebSocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Origin: http://www.example.com\r\n" +
+            "Sec-WebSocket-Location: ws://www.example.com/socket\r\n" +
+            "\r\n"))
+        driver().start()
+      }})
+
+      it("does not trigger the onopen event", function() { with(this) {
+        driver().start()
+        assertEqual( false, open )
+      }})
+
+      it("leaves the protocol in the connecting state", function() { with(this) {
+        driver().start()
+        assertEqual( "connecting", driver().getState() )
+      }})
+
+      describe("when the request body is received", function() { with(this) {
+        before(function() { this.driver().start() })
+
+        it("sends the response body", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(response()))
+          driver().parse(BODY)
+        }})
+
+        it("triggers the onopen event", function() { with(this) {
+          driver().parse(BODY)
+          assertEqual( true, open )
+        }})
+
+        it("changes the state to open", function() { with(this) {
+          driver().parse(BODY)
+          assertEqual( "open", driver().getState() )
+        }})
+
+        it("sends any frames queued before the handshake was complete", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(response()))
+          expect(driver().io, "emit").given("data", buffer([0x00, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xff]))
+          driver().frame("hello")
+          driver().parse(BODY)
+        }})
+      }})
+    }})
+  }})
+
+  itShouldBehaveLike("draft-75 protocol")
+
+  describe("in the open state", function() { with(this) {
+    before(function() { this.driver().start() })
+
+    describe("parse", function() { with(this) {
+      it("closes the socket if a close frame is received", function() { with(this) {
+        driver().parse([0xff, 0x00])
+        assertEqual( true, close )
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+
+    describe("close", function() { with(this) {
+      it("writes a close message to the socket", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer([0xff, 0x00]))
+        driver().close()
+      }})
+    }})
+  }})
+}})

spec/websocket/driver/hybi_spec.js

@@ -0,0 +1,684 @@
+var Hybi = require("../../../lib/websocket/driver/hybi"),
+    test = require('jstest').Test
+
+test.describe("Hybi", function() { with(this) {
+  define("request", function() {
+    return this._request = this._request || {
+      headers: {
+        "connection":             "Upgrade",
+        "upgrade":                "websocket",
+        "origin":                 "http://www.example.com",
+//        "sec-websocket-extensions": "x-webkit-deflate-frame",
+        "sec-websocket-key":      "JFBCWHksyIpXV+6Wlq/9pw==",
+        "sec-websocket-version":  "13"
+      }
+    }
+  })
+
+  define("options", function() {
+    return this._options = this._options || {masking: false}
+  })
+
+  define("driver", function() {
+    if (this._driver) return this._driver
+    this._driver = new Hybi(this.request(), "ws://www.example.com/socket", this.options())
+    var self = this
+    this._driver.on('open',    function(e) { self.open = true })
+    this._driver.on('message', function(e) { self.message += e.data })
+    this._driver.on('error',   function(e) { self.error = e })
+    this._driver.on('close',   function(e) { self.close = [e.code, e.reason] })
+    this._driver.io.pipe(this.collector())
+    return this._driver
+  })
+
+  before(function() {
+    this.open = this.error = this.close = false
+    this.message = ""
+  })
+
+  describe("in the connecting state", function() { with(this) {
+    it("starts in the connecting state", function() { with(this) {
+      assertEqual( "connecting", driver().getState() )
+    }})
+
+    describe("start", function() { with(this) {
+      it("writes the handshake response to the socket", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 Switching Protocols\r\n" +
+            "Upgrade: websocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+            "\r\n"))
+        driver().start()
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().start() )
+      }})
+
+      describe("with subprotocols", function() { with(this) {
+        before(function() { with(this) {
+          request().headers["sec-websocket-protocol"] = "foo, bar, xmpp"
+          options().protocols = ["xmpp"]
+        }})
+
+        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(
+              "HTTP/1.1 101 Switching Protocols\r\n" +
+              "Upgrade: websocket\r\n" +
+              "Connection: Upgrade\r\n" +
+              "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+              "Sec-WebSocket-Protocol: xmpp\r\n" +
+              "\r\n"))
+          driver().start()
+        }})
+
+        it("sets the subprotocol", function() { with(this) {
+          driver().start()
+          assertEqual( "xmpp", driver().protocol )
+        }})
+      }})
+
+      describe("with invalid extensions", function() { with(this) {
+        before(function() { with(this) {
+          request().headers["sec-websocket-extensions"] = "x-webkit- -frame"
+        }})
+
+        it("does not write a handshake", function() { with(this) {
+          expect(driver().io, "emit").exactly(0)
+          driver().start()
+        }})
+
+        it("does not trigger the onopen event", function() { with(this) {
+          driver().start()
+          assertEqual( false, open )
+        }})
+
+        it("triggers the onerror event", function() { with(this) {
+          driver().start()
+          assertEqual( "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame", error.message )
+        }})
+
+        it("triggers the onclose event", function() { with(this) {
+          driver().start()
+          assertEqual( [1002, "Invalid Sec-WebSocket-Extensions header: x-webkit- -frame"], close )
+        }})
+
+        it("changes the state to closed", function() { with(this) {
+          driver().start()
+          assertEqual( "closed", driver().getState() )
+        }})
+      }})
+
+      describe("with custom headers", function() { with(this) {
+        before(function() { with(this) {
+          driver().setHeader("Authorization", "Bearer WAT")
+        }})
+
+        it("writes the handshake with Sec-WebSocket-Protocol", function() { with(this) {
+          expect(driver().io, "emit").given("data", buffer(
+              "HTTP/1.1 101 Switching Protocols\r\n" +
+              "Upgrade: websocket\r\n" +
+              "Connection: Upgrade\r\n" +
+              "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+              "Authorization: Bearer WAT\r\n" +
+              "\r\n"))
+          driver().start()
+        }})
+      }})
+
+      it("triggers the onopen event", function() { with(this) {
+        driver().start()
+        assertEqual( true, open )
+      }})
+
+      it("changes the state to open", function() { with(this) {
+        driver().start()
+        assertEqual( "open", driver().getState() )
+      }})
+
+      it("sets the protocol version", function() { with(this) {
+        driver().start()
+        assertEqual( "hybi-13", driver().version )
+      }})
+    }})
+
+    describe("frame", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().frame("Hello, world")
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().frame("whatever") )
+      }})
+
+      it("queues the frames until the handshake has been send", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 Switching Protocols\r\n" +
+            "Upgrade: websocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+            "\r\n"))
+        expect(driver().io, "emit").given("data", buffer([0x81, 0x02, 72, 105]))
+
+        driver().frame("Hi")
+        driver().start()
+      }})
+    }})
+
+    describe("ping", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().ping()
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().ping() )
+      }})
+
+      it("queues the ping until the handshake has been send", function() { with(this) {
+        expect(driver().io, "emit").given("data", buffer(
+            "HTTP/1.1 101 Switching Protocols\r\n" +
+            "Upgrade: websocket\r\n" +
+            "Connection: Upgrade\r\n" +
+            "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+            "\r\n"))
+        expect(driver().io, "emit").given("data", buffer([0x89, 0]))
+
+        driver().ping()
+        driver().start()
+      }})
+    }})
+
+    describe("pong", function() { with(this) {
+        it("does not write to the socket", function() { with(this) {
+            expect(driver().io, "emit").exactly(0)
+            driver().pong()
+        }})
+
+        it("returns true", function() { with(this) {
+            assertEqual( true, driver().pong() )
+        }})
+
+        it("queues the pong until the handshake has been sent", function() { with(this) {
+            expect(driver().io, "emit").given("data", buffer(
+                "HTTP/1.1 101 Switching Protocols\r\n" +
+                "Upgrade: websocket\r\n" +
+                "Connection: Upgrade\r\n" +
+                "Sec-WebSocket-Accept: JdiiuafpBKRqD7eol0y4vJDTsTs=\r\n" +
+                "\r\n"))
+            expect(driver().io, "emit").given("data", buffer([0x8a, 0]))
+
+            driver().pong()
+            driver().start()
+        }})
+    }})
+
+    describe("close", function() { with(this) {
+      it("does not write anything to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().close()
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().close() )
+      }})
+
+      it("triggers the onclose event", function() { with(this) {
+        driver().close()
+        assertEqual( [1000, ""], close )
+      }})
+
+      it("changes the state to closed", function() { with(this) {
+        driver().close()
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+  }})
+
+  describe("in the open state", function() { with(this) {
+    before(function() { this.driver().start() })
+
+    describe("parse", function() { with(this) {
+      define("mask", function() {
+        return this._mask = this._mask ||
+               [1,2,3,4].map(function() { return Math.floor(Math.random() * 256) })
+      })
+
+      define("maskMessage", function(bytes) {
+        var output = []
+        for (var i = 0, n = bytes.length; i < n; i++) {
+          output[i] = bytes[i] ^ this.mask()[i % 4]
+        }
+        return output
+      })
+
+      it("parses unmasked text frames", function() { with(this) {
+        driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+        assertEqual( "Hello", message )
+      }})
+
+      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])
+        assertEqual( "HelloHello", message )
+      }})
+
+      it("parses empty text frames", function() { with(this) {
+        driver().parse([0x81, 0x00])
+        assertEqual( "", message )
+      }})
+
+      it("parses fragmented text frames", function() { with(this) {
+        driver().parse([0x01, 0x03, 0x48, 0x65, 0x6c])
+        driver().parse([0x80, 0x02, 0x6c, 0x6f])
+        assertEqual( "Hello", message )
+      }})
+
+      it("parses masked text frames", function() { with(this) {
+        driver().parse([0x81, 0x85])
+        driver().parse(mask())
+        driver().parse(maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
+        assertEqual( "Hello", message )
+      }})
+
+      it("parses masked empty text frames", function() { with(this) {
+        driver().parse([0x81, 0x80])
+        driver().parse(mask())
+        driver().parse(maskMessage([]))
+        assertEqual( "", message )
+      }})
+
+      it("parses masked fragmented text frames", function() { with(this) {
+        driver().parse([0x01, 0x81])
+        driver().parse(mask())
+        driver().parse(maskMessage([0x48]))
+
+        driver().parse([0x80, 0x84])
+        driver().parse(mask())
+        driver().parse(maskMessage([0x65, 0x6c, 0x6c, 0x6f]))
+
+        assertEqual( "Hello", message )
+      }})
+
+      it("closes the socket if the frame has an unrecognized opcode", function() { with(this) {
+        driver().parse([0x83, 0x00])
+        assertEqual( [0x88, 0x1e, 0x03, 0xea], collector().bytes.slice(0,4) )
+        assertEqual( "Unrecognized frame opcode: 3", error.message )
+        assertEqual( [1002, "Unrecognized frame opcode: 3"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+
+      it("closes the socket if a close frame is received", function() { with(this) {
+        driver().parse([0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+        assertEqual( [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
+        assertEqual( [1000, "Hello"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+
+      it("parses unmasked multibyte text frames", function() { with(this) {
+        driver().parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
+        assertEqual( "Apple = ", message )
+      }})
+
+      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])
+        assertEqual( "Apple = ", message )
+      }})
+
+      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])
+        assertEqual( "Apple = ", message )
+      }})
+
+      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]))
+        assertEqual( "Apple = ", message )
+      }})
+
+      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]))
+
+        driver().parse([0x80, 0x81])
+        driver().parse(mask())
+        driver().parse(maskMessage([0xbf]))
+
+        assertEqual( "Apple = ", message )
+      }})
+
+      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"
+        }
+        assertEqual( result, message )
+      }})
+
+      it("returns an error for too-large frames", function() { with(this) {
+        driver().parse([0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00])
+        assertEqual( "WebSocket frame length too large", error.message )
+        assertEqual( [1009, "WebSocket frame length too large"], close )
+        assertEqual( "closed", driver().getState() )
+      }})
+
+      it("parses masked medium-length text frames", function() { with(this) {
+        driver().parse([0x81, 0xfe, 0x00, 0xc8])
+        driver().parse(mask())
+        var i = 40, result = "", packet = []
+        while (i--) {
+          packet = packet.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
+          result += "Hello"
+        }
+        driver().parse(maskMessage(packet))
+        assertEqual( result, message )
+      }})
+
+      it("replies to pings with a pong", function() { with(this) {
+        driver().parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
+        assertEqual( [0x8a, 0x04, 0x4f, 0x48, 0x41, 0x49], collector().bytes )
+      }})
+
+      describe("when a message listener throws an error", function() { with(this) {
+        before(function() { with(this) {
+          this.messages = []
+
+          driver().on("message", function(msg) {
+            messages.push(msg.data)
+            throw new Error("an error")
+          })
+        }})
+
+        it("is not trapped by the parser", function() { with(this) {
+          var buffer = [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
+          assertThrows(Error, function() { driver().parse(buffer) })
+        }})
+
+        it("parses unmasked text frames without dropping input", function() { with(this) {
+          try { driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05]) } catch (e) {}
+          try { driver().parse([0x57, 0x6f, 0x72, 0x6c, 0x64]) } catch (e) {}
+          assertEqual( ["Hello", "World"], messages )
+        }})
+      }})
+    }})
+
+    describe("frame", function() { with(this) {
+      it("formats the given string as a WebSocket frame", function() { with(this) {
+        driver().frame("Hello")
+        assertEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
+      }})
+
+      it("formats a byte array as a binary WebSocket frame", function() { with(this) {
+        driver().frame([0x48, 0x65, 0x6c])
+        assertEqual( [0x82, 0x03, 0x48, 0x65, 0x6c], collector().bytes )
+      }})
+
+      it("encodes multibyte characters correctly", function() { with(this) {
+        driver().frame("Apple = ")
+        assertEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], collector().bytes )
+      }})
+
+      it("encodes medium-length strings using extra length bytes", function() { with(this) {
+        var i = 40, frame = [0x81, 0x7e, 0x00, 0xc8], string = ""
+        while (i--) {
+          string += "Hello"
+          frame = frame.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
+        }
+        driver().frame(string)
+        assertEqual( frame, collector(). bytes )
+      }})
+
+      it("encodes close frames with an error code", function() { with(this) {
+        driver().frame("Hello", "close", 1002)
+        assertEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], collector().bytes )
+      }})
+
+      it("encodes pong frames", function() { with(this) {
+        driver().frame("", "pong")
+        assertEqual( [0x8a, 0x00], collector().bytes )
+      }})
+    }})
+
+    describe("ping", function() { with(this) {
+      it("writes a ping frame to the socket", function() { with(this) {
+        driver().ping("mic check")
+        assertEqual( [0x89, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes )
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().ping() )
+      }})
+
+      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])
+        assert( reply )
+      }})
+
+      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])
+        assert( !reply )
+      }})
+    }})
+
+    describe("pong", function() { with(this) {
+      it("writes a pong frame to the socket", function() { with(this) {
+        driver().pong("mic check")
+        assertEqual([0x8a, 0x09, 0x6d, 0x69, 0x63, 0x20, 0x63, 0x68, 0x65, 0x63, 0x6b], collector().bytes)
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual(true, driver().pong())
+      }})
+    }})
+
+    describe("close", function() { with(this) {
+      it("writes a close frame to the socket", function() { with(this) {
+        driver().close("<%= reasons %>", 1003)
+        assertEqual( [0x88, 0x10, 0x03, 0xeb, 0x3c, 0x25, 0x3d, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x73, 0x20, 0x25, 0x3e], collector().bytes )
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().close() )
+      }})
+
+      it("does not trigger the close event", function() { with(this) {
+        driver().close()
+        assertEqual( false, close )
+      }})
+
+      it("does not trigger the onerror event", function() { with(this) {
+        driver().close()
+        assertEqual( false, error )
+      }})
+
+      it("changes the state to closing", function() { with(this) {
+        driver().close()
+        assertEqual( "closing", driver().getState() )
+      }})
+    }})
+  }})
+
+  describe("when masking is required", function() { with(this) {
+    before(function() {
+      this.options().requireMasking = true
+      this.driver().start()
+    })
+
+    it("does not emit a message", function() { with(this) {
+      driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+      assertEqual( "", message )
+    }})
+
+    it("returns an error", function() { with(this) {
+      driver().parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+      assertEqual( "Received unmasked frame but masking is required", error.message )
+      assertEqual( [1003, "Received unmasked frame but masking is required"], close )
+    }})
+  }})
+
+  describe("in the closing state", function() { with(this) {
+    before(function() {
+      this.driver().start()
+      this.driver().close()
+    })
+
+    describe("frame", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().frame("dropped")
+      }})
+
+      it("returns true", function() { with(this) {
+        assertEqual( true, driver().frame("wut") )
+      }})
+    }})
+
+    describe("ping", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().ping()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().ping() )
+      }})
+    }})
+
+    describe("pong", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().pong()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().pong() )
+      }})
+    }})
+
+    describe("close", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().close()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().close() )
+      }})
+    }})
+
+    describe("receiving a close frame", function() { with(this) {
+      before(function() {
+        this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
+      })
+
+      it("triggers the onclose event", function() { with(this) {
+        assertEqual( [1001, "OK"], close )
+      }})
+
+      it("changes the state to closed", function() { with(this) {
+        assertEqual( "closed", driver().getState() )
+      }})
+
+      it("does not write another close frame", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        this.driver().parse([0x88, 0x04, 0x03, 0xe9, 0x4f, 0x4b])
+      }})
+    }})
+
+    describe("receiving a close frame with a too-short payload", function() { with(this) {
+      before(function() {
+        this.driver().parse([0x88, 0x01, 0x03])
+      })
+
+      it("triggers the onclose event with a protocol error", function() { with(this) {
+        assertEqual( [1002, ""], close )
+      }})
+
+      it("changes the state to closed", function() { with(this) {
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+
+    describe("receiving a close frame with no code", function() { with(this) {
+      before(function() { with(this) {
+        this.driver().parse([0x88, 0x00])
+      }})
+
+      it("triggers the onclose event with code 1000", function() { with(this) {
+        assertEqual( [1000, ""], close )
+      }})
+
+      it("changes the state to closed", function() { with(this) {
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+  }})
+
+  describe("in the closed state", function() { with(this) {
+    before(function() {
+      this.driver().start()
+      this.driver().close()
+      this.driver().parse([0x88, 0x02, 0x03, 0xea])
+    })
+
+    describe("frame", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().frame("dropped")
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().frame("wut") )
+      }})
+    }})
+
+    describe("ping", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().ping()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().ping() )
+      }})
+    }})
+
+    describe("pong", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().pong()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().pong() )
+      }})
+    }})
+
+    describe("close", function() { with(this) {
+      it("does not write to the socket", function() { with(this) {
+        expect(driver().io, "emit").exactly(0)
+        driver().close()
+      }})
+
+      it("returns false", function() { with(this) {
+        assertEqual( false, driver().close() )
+      }})
+
+      it("leaves the state as closed", function() { with(this) {
+        driver().close()
+        assertEqual( "closed", driver().getState() )
+      }})
+    }})
+  }})
+}})