Bump version to 0.9.2.

Close cleanly if close() is called before the TCP connection is established.
Refactor event emitters to make sure errors are only emitted once before the closing procedure is started.
2014-12-21 22:24:01 +00:00 · 2014-12-21 18:22:03 +00:00 · 2014-12-21 16:46:33 +00:00 · 2014-12-19 08:07:46 +00:00 · 2014-12-18 02:25:03 +00:00 · 2014-12-17 22:50:19 +00:00
40 changed files with 1511 additions and 2859 deletions
@@ -1,11 +1,6 @@
 language: node_js

 node_js:
-  - "0.6"
  - "0.8"
  - "0.10"
  - "0.11"
-
-before_install:
-  - '[ "${TRAVIS_NODE_VERSION}" = "0.6" ] && npm conf set strict-ssl false || true'
-
@@ -1,34 +1,125 @@
-### 0.3.2 / 2013-12-29
+### 0.9.2 / 2014-12-21

-* 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
+* Only emit `error` once, and don't emit it after `close`

-### 0.3.1 / 2013-12-03

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

-### 0.3.0 / 2013-09-09
+* Check that all options to the WebSocket constructor are recognized

-* Support client URLs with Basic Auth credentials

-### 0.2.2 / 2013-07-05
+### 0.9.0 / 2014-12-13

-* No functional changes, just updates to package.json
+* Allow protocol extensions to be passed into websocket-extensions

-### 0.2.1 / 2013-05-17

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

-### 0.2.0 / 2013-05-12
+* Send the correct hostname when upgrading a connection to TLS

-* Add API for setting and reading headers
-* Add Driver.server() method for getting a driver for TCP servers

-### 0.1.0 / 2013-05-04
+### 0.8.0 / 2014-11-08

-* First stable release
+* Support connections via HTTP proxies
+* Close the connection cleanly if we're still waiting for a handshake response

+
+### 0.7.3 / 2014-10-04
+
+* Allow sockets to be closed when they are in any state other than `CLOSED`
+
+
+### 0.7.2 / 2013-12-29
+
+* Make sure the `close` event is emitted by clients on Node v0.10
+
+
+### 0.7.1 / 2013-12-03
+
+* Support the `maxLength` websocket-driver option
+* Make the client emit `error` events on network errors
+
+
+### 0.7.0 / 2013-09-09
+
+* Allow the server to send custom headers with EventSource responses
+
+
+### 0.6.1 / 2013-07-05
+
+* Add `ca` option to the client for specifying certificate authorities
+* Start the server driver asynchronously so that `onopen` handlers can be added
+
+
+### 0.6.0 / 2013-05-12
+
+* Add support for custom headers
+
+
+### 0.5.0 / 2013-05-05
+
+* Extract the protocol handlers into the `websocket-driver` library
+* Support the Node streaming API
+
+
+### 0.4.4 / 2013-02-14
+
+* Emit the `close` event if TCP is closed before CLOSE frame is acked
+
+
+### 0.4.3 / 2012-07-09
+
+* Add `Connection: close` to EventSource response
+* Handle situations where `request.socket` is undefined
+
+
+### 0.4.2 / 2012-04-06
+
+* Add WebSocket error code `1011`.
+* Handle URLs with no path correctly by sending `GET /`
+
+
+### 0.4.1 / 2012-02-26
+
+* Treat anything other than a `Buffer` as a string when calling `send()`
+
+
+### 0.4.0 / 2012-02-13
+
+* 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
+
+
+### 0.3.1 / 2012-01-16
+
+* Call `setNoDelay(true)` on `net.Socket` objects to reduce latency
+
+
+### 0.3.0 / 2012-01-13
+
+* Add support for `EventSource` connections
+
+
+### 0.2.0 / 2011-12-21
+
+* 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
@@ -1,291 +1,323 @@
-# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.png)](https://travis-ci.org/faye/websocket-driver-node)
+# faye-websocket

-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.
+* Travis CI build: [![Build
+  status](https://secure.travis-ci.org/faye/faye-websocket-node.svg)](http://travis-ci.org/faye/faye-websocket-node)
+* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/),
+  [client](http://faye.jcoglan.com/autobahn/clients/)

-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:
+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/).

-* Select the correct server-side driver to talk to the client
-* Generate and send both server- and client-side handshakes
-* Recognize when the handshake phase completes and the WS protocol begins
-* Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
-* Buffer sent messages until the handshake process is finished
-* Deal with proxies that defer delivery of the draft-76 handshake body
-* Notify you when the socket is open and closed and when messages arrive
-* Recombine fragmented messages
-* Dispatch text, binary, ping and close frames
-* Manage the socket-closing handshake process
-* Automatically reply to ping frames with a matching pong
-* Apply masking to messages sent by the client
-
-This library was originally extracted from the [Faye](http://faye.jcoglan.com)
-project but now aims to provide simple WebSocket support for any Node-based
-project.
+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.


 ## Installation

 ```
-$ npm install websocket-driver
+$ npm install faye-websocket
 ```


-## Usage
+## Handling WebSocket connections in Node

-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.
+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:

 ```js
-var http = require('http'),
-    websocket = require('websocket-driver');
+var WebSocket = require('faye-websocket'),
+    http      = require('http');

 var server = http.createServer();

 server.on('upgrade', function(request, socket, body) {
-  if (!websocket.isWebSocket(request)) return;
-
-  var driver = websocket.http(request);
-
-  driver.io.write(body);
-  socket.pipe(driver.io).pipe(socket);
-
-  driver.messages.on('data', function(message) {
-    console.log('Got a message', message);
-  });
-
-  driver.start();
+  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;
+    });
+  }
 });
+
+server.listen(8000);
 ```

-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.
-
-
-### 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:
+`WebSocket` objects are also duplex streams, so you could replace the
+`ws.on('message', ...)` line with:

 ```js
-var net = require('net'),
-    websocket = require('websocket-driver');
-
-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);
-});
-
-server.listen(4180);
+    ws.pipe(ws);
 ```

-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.
+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 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.
+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
-var net = require('net'),
-    websocket = require('websocket-driver');
-
-var driver = websocket.client('ws://www.example.com/socket'),
-    tcp = net.createConnection(80, 'www.example.com');
-
-tcp.pipe(driver.io).pipe(tcp);
-
-driver.messages.on('data', function(message) {
-  console.log('Got a message', message);
-});
-
-tcp.on('connect', function() {
-  driver.start();
+ws.ping('Mic check, one, two', function() {
+  // fires when pong is received
 });
 ```

-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
+## Using the WebSocket client

-
-### Driver API
-
-Drivers are created using one of the following methods:
+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`.

 ```js
-driver = websocket.http(request, options)
-driver = websocket.server(options)
-driver = websocket.client(url, options)
+var WebSocket = require('faye-websocket'),
+    ws        = new WebSocket.Client('ws://www.example.com/');
+
+ws.on('open', function(event) {
+  console.log('open');
+  ws.send('Hello, world!');
+});
+
+ws.on('message', function(event) {
+  console.log('message', event.data);
+});
+
+ws.on('close', function(event) {
+  console.log('close', event.code, event.reason);
+  ws = null;
+});
 ```

-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 WebSocket client also lets you inspect the status and headers of the
+handshake response via its `statusCode` and `headers` properties.

-The `options` argument is optional, and is an object. It may contain the
-following fields:
+To connect via a proxy, set the `proxy` option to the HTTP origin of the proxy,
+including any authorization information, custom headers and TLS config you
+require. Only the `origin` setting is required.

+```js
+var ws = new WebSocket.Client('ws://www.example.com/', null, {
+  proxy: {
+    origin:  'http://username:password@proxy.example.com',
+    headers: {'User-Agent': 'node'},
+    tls:     {cert: fs.readFileSync('client.crt')}
+  }
+});
+```
+
+The `tls` value is a Node 'TLS options' object that will be passed to
+[`tls.connect()`](http://nodejs.org/api/tls.html#tls_tls_connect_options_callback).
+
+
+## Subprotocol negotiation
+
+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:
+
+```js
+var ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
+```
+
+On the server side, you can likewise pass in the list of protocols the server
+supports after the other constructor arguments:
+
+```js
+var ws = new WebSocket(request, socket, body, ['irc', 'amqp']);
+```
+
+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.
+
+
+## Protocol extensions
+
+faye-websocket is based on the
+[websocket-extensions](https://github.com/faye/websocket-extensions-node)
+framework that allows extensions to be negotiated via the
+`Sec-WebSocket-Extensions` header. To add extensions to a connection, pass an
+array of extensions to the `:extensions` option. For example, to add
+[permessage-deflate](https://github.com/faye/permessage-deflate-node):
+
+```js
+var deflate = require('permessage-deflate');
+
+var ws = new WebSocket(request, null, {extensions: [deflate]});
+```
+
+
+## Initialization options
+
+Both the server- and client-side classes allow an options object to be passed
+in at initialization time, for example:
+
+```js
+var ws = new WebSocket(request, socket, body, protocols, options);
+var ws = new WebSocket.Client(url, protocols, options);
+```
+
+`protocols` is an array of subprotocols as described above, or `null`.
+`options` is an optional object containing any of these fields:
+
+* `extensions` - an array of
+  [websocket-extensions](https://github.com/faye/websocket-extensions-node)
+  compatible extensions, as described above
+* `headers` - an object containing key-value pairs representing HTTP headers to
+  be sent during the handshake process
 * `maxLength` - the maximum allowed size of incoming message frames, in bytes.
  The default value is `2^26 - 1`, or 1 byte short of 64 MiB.
-* `protocols` - an array of strings representing acceptable subprotocols for
-  use over the socket. The driver will negotiate one of these to use via the
-  `Sec-WebSocket-Protocol` header if supported by the other peer.
+* `ping` - an integer that sets how often the WebSocket should send ping
+  frames, measured in seconds

-A driver has two duplex streams attached to it:
+The client accepts some additional options:

-* <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.
+* `proxy` - settings for a proxy as described above
+* `tls` - a Node 'TLS options' object containing TLS settings for the origin
+  server, this will be passed to
+  [`tls.connect()`](http://nodejs.org/api/tls.html#tls_tls_connect_options_callback)
+* `ca` - (legacy) a shorthand for passing `{tls: {ca: value}}`

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

-Note that most of these methods are commands: if they produce data that should
-be sent over the socket, they will give this to you by emitting `data` events
-on the `driver.io` stream.
+## WebSocket API

-#### `driver.on('open', function(event) {})`
+Both server- and client-side `WebSocket` objects support the following API.

-Sets the callback to execute when the socket becomes open.
+* <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.

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

-Sets the callback to execute when a message is received. `event` will have a
-`data` attribute containing either a string in the case of a text message or a
-`Buffer` in the case of a binary message.
+## Handling EventSource connections in Node

-You can also listen for messages using the `driver.messages.on('data')` event,
-which emits strings for text messages and buffers for binary messages.
+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('error', function(event) {})`
+```js
+var WebSocket   = require('faye-websocket'),
+    EventSource = WebSocket.EventSource,
+    http        = require('http');

-Sets the callback to execute when a protocol error occurs due to the other peer
-sending an invalid byte sequence. `event` will have a `message` attribute
-describing the error.
+var server = http.createServer();

-#### `driver.on('close', function(event) {})`
+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');
+  }
+});

-Sets the callback to execute when the socket becomes closed. The `event` object
-has `code` and `reason` attributes.
+server.listen(8000);
+```

-#### `driver.setHeader(name, value)`
+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`:

-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.
+```js
+es.send('Breaking News!', {event: 'notification', id: '99'});
+```

-#### `driver.start()`
+The `EventSource` object exposes the following properties:

-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` iff a handshake was sent.
+* <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.

-#### `driver.parse(string)`
+When you initialize an EventSource with ` new EventSource()`, you can pass
+configuration options after the `response` parameter. Available options are:

-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`.
+* <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.

-#### `driver.text(string)`
+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:

-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.
+```js
+var es = new EventSource(request, response, {
+  headers: {'Access-Control-Allow-Origin': '*'},
+  ping:    15,
+  retry:   10
+});
+```

-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.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.
+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.


 ## License

 (The MIT License)

-Copyright (c) 2010-2013 James Coglan
+Copyright (c) 2010-2014 James Coglan

 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the 'Software'), to deal in
@@ -304,4 +336,3 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
-
@@ -0,0 +1,39 @@
+var WebSocket = require('../lib/faye/websocket'),
+    deflate   = require('permessage-deflate'),
+    pace      = require('pace');
+
+var host    = 'ws://localhost:9001',
+    agent   = encodeURIComponent('node-' + process.version),
+    cases   = 0,
+    options = {extensions: [deflate]};
+
+var socket = new WebSocket.Client(host + '/getCaseCount'),
+    url, progress;
+
+socket.onmessage = function(event) {
+  console.log('Total cases to run: ' + event.data);
+  cases = parseInt(event.data);
+  progress = pace(cases);
+};
+
+var runCase = function(n) {
+  if (n > cases) {
+    url = host + '/updateReports?agent=' + agent;
+    socket = new WebSocket.Client(url);
+    socket.onclose = process.exit;
+    return;
+  }
+
+  url = host + '/runCase?case=' + n + '&agent=' + agent;
+  socket = new WebSocket.Client(url, null, options);
+  socket.pipe(socket);
+
+  socket.on('close', function() {
+    progress.op();
+    runCase(n + 1);
+  });
+};
+
+socket.onclose = function() {
+  runCase(1);
+};
@@ -0,0 +1,25 @@
+var WebSocket = require('../lib/faye/websocket'),
+    fs = require('fs');
+
+var url     = process.argv[2],
+    headers = {Origin: 'http://faye.jcoglan.com'},
+    ca      = fs.readFileSync(__dirname + '/../spec/server.crt'),
+    proxy   = {origin: process.argv[3], headers: {'User-Agent': 'Echo'}, tls: {ca: ca}},
+    ws      = new WebSocket.Client(url, null, {headers: headers, proxy: proxy, tls: {ca: ca}});
+
+ws.onopen = function() {
+  console.log('[open]', ws.headers);
+  ws.send('mic check');
+};
+
+ws.onclose = function(close) {
+  console.log('[close]', close.code, close.reason);
+};
+
+ws.onerror = function(error) {
+  console.log('[error]', error.message);
+};
+
+ws.onmessage = function(message) {
+  console.log('[message]', message.data);
+};
@@ -0,0 +1,20 @@
+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
@@ -0,0 +1,7 @@
+var ProxyServer = require('../spec/proxy_server');
+
+var port   = process.argv[2],
+    secure = process.argv[3] === 'tls',
+    proxy  = new ProxyServer({debug: true, tls: secure});
+
+proxy.listen(port);
@@ -0,0 +1,69 @@
+var WebSocket = require('../lib/faye/websocket'),
+    deflate   = require('permessage-deflate'),
+    fs        = require('fs'),
+    http      = require('http'),
+    https     = require('https');
+
+var port    = process.argv[2] || 7000,
+    secure  = process.argv[3] === 'tls',
+    options = {extensions: [deflate], ping: 5};
+
+var upgradeHandler = function(request, socket, head) {
+  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], options);
+  console.log('[open]', ws.url, ws.version, ws.protocol, request.headers);
+
+  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);
@@ -0,0 +1,38 @@
+<!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>
@@ -1,21 +0,0 @@
-var net       = require('net'),
-    websocket = require('../lib/websocket/driver');
-
-var server = net.createServer(function(connection) {
-  var driver = websocket.server();
-
-  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]);
-
@@ -0,0 +1,43 @@
+<!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>
@@ -0,0 +1,131 @@
+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;
@@ -0,0 +1,45 @@
+// 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;
+  if (!this._stream.readable) return this._stream.end();
+
+  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.validateOptions = function(options, validKeys) {
+  driver.validateOptions(options, validKeys);
+};
+
+WebSocket.WebSocket   = WebSocket;
+WebSocket.Client      = require('./websocket/client');
+WebSocket.EventSource = require('./eventsource');
+
+module.exports        = WebSocket;
@@ -0,0 +1,176 @@
+var Stream      = require('stream').Stream,
+    util        = require('util'),
+    driver      = require('websocket-driver'),
+    EventTarget = require('./api/event_target'),
+    Event       = require('./api/event');
+
+var API = function(options) {
+  options = options || {};
+  driver.validateOptions(options, ['headers', 'extensions', 'maxLength', 'ping', 'proxy', 'tls', 'ca']);
+
+  this.readable = this.writable = true;
+
+  var headers = options.headers;
+  if (headers) {
+    for (var name in headers) this._driver.setHeader(name, headers[name]);
+  }
+
+  var extensions = options.extensions;
+  if (extensions) {
+    [].concat(extensions).forEach(this._driver.addExtension, this._driver);
+  }
+
+  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._driver.on('open',    function(e) { self._open() });
+  this._driver.on('message', function(e) { self._receiveMessage(e.data) });
+  this._driver.on('close',   function(e) { self._beginClose(e.reason, e.code) });
+
+  this._driver.on('error', function(error) {
+    self._emitError(error.message);
+  });
+  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._configureStream();
+
+  if (!this._proxy) {
+    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.CLOSED) this.readyState = API.CLOSING;
+    this._driver.close();
+  },
+
+  _configureStream: function() {
+    var self = this;
+
+    this._stream.setTimeout(0);
+    this._stream.setNoDelay(true);
+
+    ['close', 'end'].forEach(function(event) {
+      this._stream.on(event, function() { self._finalizeClose() });
+    }, this);
+
+    this._stream.on('error', function(error) {
+      self._emitError('Network error: ' + self.url + ': ' + error.message);
+      self._finalizeClose();
+    });
+  },
+
+ _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);
+  },
+
+  _emitError: function(message) {
+    if (this.readyState >= API.CLOSING) return;
+
+    var event = new Event('error', {message: message});
+    event.initEvent('error', false, false);
+    this.dispatchEvent(event);
+  },
+
+  _beginClose: function(reason, code) {
+    if (this.readyState === API.CLOSED) return;
+    this.readyState = API.CLOSING;
+
+    if (this._stream) {
+      this._stream.end();
+      if (!this._stream.readable) this._finalizeClose();
+    }
+    this._closeParams = [reason, code];
+  },
+
+  _finalizeClose: function() {
+    if (this.readyState === API.CLOSED) return;
+    this.readyState = API.CLOSED;
+
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    if (this.readable) this.emit('end');
+    this.readable = this.writable = false;
+
+    var reason = this._closeParams ? this._closeParams[0] : '',
+        code   = this._closeParams ? this._closeParams[1] : 1006;
+
+    var event = new Event('close', {code: code, 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;
@@ -0,0 +1,20 @@
+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;
@@ -0,0 +1,28 @@
+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;
@@ -0,0 +1,84 @@
+var util   = require('util'),
+    net    = require('net'),
+    tls    = require('tls'),
+    crypto = require('crypto'),
+    url    = require('url'),
+    driver = require('websocket-driver'),
+    API    = require('./api'),
+    Event  = require('./api/event');
+
+var DEFAULT_PORTS    = {'http:': 80, 'https:': 443, 'ws:':80, 'wss:': 443},
+    SECURE_PROTOCOLS = ['https:', 'wss:'];
+
+var Client = function(_url, protocols, options) {
+  options = options || {};
+
+  this.url     = _url;
+  this._driver = driver.client(this.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 proxy     = options.proxy || {},
+      endpoint  = url.parse(proxy.origin || this.url),
+      port      = endpoint.port || DEFAULT_PORTS[endpoint.protocol],
+      secure    = SECURE_PROTOCOLS.indexOf(endpoint.protocol) >= 0,
+      onConnect = function() { self._onConnect() },
+      originTLS = options.tls || {},
+      socketTLS = proxy.origin ? (proxy.tls || {}) : originTLS,
+      self      = this;
+
+  originTLS.ca = originTLS.ca || options.ca;
+
+  this._stream = secure
+               ? tls.connect(port, endpoint.hostname, socketTLS, onConnect)
+               : net.connect(port, endpoint.hostname, onConnect);
+
+  if (proxy.origin) this._configureProxy(proxy, originTLS);
+
+  API.call(this, options);
+};
+util.inherits(Client, API);
+
+Client.prototype._onConnect = function() {
+  var worker = this._proxy || this._driver;
+  worker.start();
+};
+
+Client.prototype._configureProxy = function(proxy, originTLS) {
+  var uri    = url.parse(this.url),
+      secure = SECURE_PROTOCOLS.indexOf(uri.protocol) >= 0,
+      self   = this,
+      name;
+
+  this._proxy = this._driver.proxy(proxy.origin);
+
+  if (proxy.headers) {
+    for (name in proxy.headers) this._proxy.setHeader(name, proxy.headers[name]);
+  }
+
+  this._proxy.pipe(this._stream, {end: false});
+  this._stream.pipe(this._proxy);
+
+  this._proxy.on('connect', function() {
+    if (secure) {
+      var options = {socket: self._stream, servername: uri.hostname};
+      for (name in originTLS) options[name] = originTLS[name];
+      self._stream = tls.connect(options);
+      self._configureStream();
+    }
+    self._driver.io.pipe(self._stream);
+    self._stream.pipe(self._driver.io);
+    self._driver.start();
+  });
+
+  this._proxy.on('error', function(error) {
+    self._driver.emit('error', error);
+  });
+};
+
+module.exports = Client;
@@ -1,44 +0,0 @@
-// 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 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(/\s*,\s*/).indexOf('upgrade') >= 0 &&
-           upgrade.toLowerCase() === 'websocket';
-  }
-};
-
-module.exports = Driver;
-
@@ -1,126 +0,0 @@
-var Emitter = require('events').EventEmitter,
-    util    = require('util'),
-    streams = require('../streams'),
-    Headers = require('./headers');
-
-var Base = function(request, url, options) {
-  Emitter.call(this);
-
-  this._request   = request;
-  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);
-
-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;
-  },
-
-  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;
-    this._write(this._handshakeResponse());
-    if (this._stage !== -1) this._open();
-    return true;
-  },
-
-  text: function(message) {
-    return this.frame(message);
-  },
-
-  binary: function(message) {
-    return false;
-  },
-
-  ping: 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;
-
@@ -1,112 +0,0 @@
-var url        = require('url'),
-    util       = require('util'),
-    HttpParser = require('./http_parser'),
-    Base       = require('./base'),
-    Hybi       = require('./hybi');
-
-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');
-};
-util.inherits(Client, Hybi);
-
-Client.generateKey = function() {
-  var buffer = new Buffer(16), i = buffer.length;
-  while (i--) buffer[i] = Math.floor(Math.random() * 256);
-  return buffer.toString('base64');
-};
-
-var instance = {
-  start: function() {
-    if (this.readyState !== -1) return false;
-    this._write(this._handshakeRequest());
-    this.readyState = 0;
-    return true;
-  },
-
-  parse: function(data) {
-    if (this.readyState > 0) return Hybi.prototype.parse.call(this, data);
-
-    this._http.parse(data);
-    if (!this._http.isComplete()) return;
-    
-    this._validateHandshake();
-    this.parse(this._http.body);
-  },
-
-  _handshakeRequest: function() {
-    var uri = url.parse(this.url);
-
-    var headers = [ 'GET ' + (uri.pathname || '/') + (uri.search || '') + ' HTTP/1.1',
-                    'Host: ' + uri.hostname + (uri.port ? ':' + uri.port : ''),
-                    'Upgrade: websocket',
-                    'Connection: Upgrade',
-                    'Sec-WebSocket-Key: ' + this._key,
-                    'Sec-WebSocket-Version: 13'
-                  ];
-
-    if (this._protocols.length > 0)
-      headers.push('Sec-WebSocket-Protocol: ' + this._protocols.join(', '));
-
-    if (uri.auth)
-      headers.push('Authorization: Basic ' + new Buffer(uri.auth, 'utf8').toString('base64'));
-
-    return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
-  },
-
-  _failHandshake: function(message) {
-    message = 'Error during WebSocket handshake: ' + message;
-    this.emit('error', new Error(message));
-    this.readyState = 3;
-    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;
-    }
-
-    this._open();
-  }
-};
-
-for (var key in instance)
-  Client.prototype[key] = instance[key];
-
-module.exports = Client;
-
@@ -1,118 +0,0 @@
-var Base = require('./base'),
-    util = require('util');
-
-var Draft75 = function(request, url, options) {
-  Base.apply(this, arguments);
-  this._stage = 0;
-  this.version = 'hixie-75';
-};
-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(buffer) {
-    if (this.readyState > 1) return;
-
-    var data, message, value;
-    for (var i = 0, n = buffer.length; i < n; i++) {
-      data = buffer[i];
-
-      switch (this._stage) {
-        case -1:
-          this._body.push(data);
-          this._sendHandshakeBody();
-          break;
-
-        case 0:
-          this._parseLeadingByte(data);
-          break;
-
-        case 1:
-          value = (data & 0x7F);
-          this._length = value + 128 * this._length;
-
-          if (this._closing && this._length === 0) {
-            return this.close();
-          }
-          else if ((0x80 & data) !== 0x80) {
-            if (this._length === 0) {
-              this._stage = 0;
-            }
-            else {
-              this._skipped = 0;
-              this._stage = 2;
-            }
-          }
-          break;
-
-        case 2:
-          if (data === 0xFF) {
-            message = new Buffer(this._buffer).toString('utf8', 0, this._buffer.length);
-            this.emit('message', new Base.MessageEvent(message));
-            this._stage = 0;
-          }
-          else {
-            if (this._length) {
-              this._skipped += 1;
-              if (this._skipped === this._length)
-                this._stage = 0;
-            } else {
-              this._buffer.push(data);
-              if (this._buffer.length > this._maxLength) return this.close();
-            }
-          }
-          break;
-      }
-    }
-  },
-
-  frame: function(data) {
-    if (this.readyState === 0) return this._queue([data]);
-    if (this.readyState > 1) return false;
-
-    var buffer = new Buffer(data, 'utf8'),
-        frame  = new Buffer(buffer.length + 2);
-
-    frame[0] = 0x00;
-    frame[buffer.length + 1] = 0xFF;
-    buffer.copy(frame, 1);
-
-    this._write(frame);
-    return true;
-  },
-
-  _handshakeResponse: function() {
-    return new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
-                      'Upgrade: WebSocket\r\n' +
-                      'Connection: Upgrade\r\n' +
-                      'WebSocket-Origin: ' + this._request.headers.origin + '\r\n' +
-                      'WebSocket-Location: ' + this.url + '\r\n' +
-                      this.__headers.toString() +
-                      '\r\n',
-                      'utf8');
-  },
-
-  _parseLeadingByte: function(data) {
-    if ((0x80 & data) === 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;
-
@@ -1,109 +0,0 @@
-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 bigEndian = function(number) {
-  var string = '';
-  [24, 16, 8, 0].forEach(function(offset) {
-    string += String.fromCharCode(number >> offset & 0xFF);
-  });
-  return string;
-};
-
-
-var Draft76 = function(request, url, options) {
-  Draft75.apply(this, arguments);
-  this._stage  = -1;
-  this._body   = [];
-  this.version = 'hixie-76';
-};
-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() {
-    return new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
-                      'Upgrade: WebSocket\r\n' +
-                      'Connection: Upgrade\r\n' +
-                      'Sec-WebSocket-Origin: ' + this._request.headers.origin + '\r\n' +
-                      'Sec-WebSocket-Location: ' + this.url + '\r\n' +
-                      this.__headers.toString() +
-                      '\r\n',
-                      'binary');
-  },
-
-  _handshakeSignature: function() {
-    if (this._body.length < this.BODY_SIZE) return null;
-    var body = new Buffer(this._body.slice(0, this.BODY_SIZE));
-
-    var headers = this._request.headers,
-
-        key1    = headers['sec-websocket-key1'],
-        value1  = numberFromKey(key1) / spacesInKey(key1),
-
-        key2    = headers['sec-websocket-key2'],
-        value2  = numberFromKey(key2) / spacesInKey(key2),
-
-        md5     = crypto.createHash('md5');
-
-    md5.update(bigEndian(value1));
-    md5.update(bigEndian(value2));
-    md5.update(body.toString('binary'));
-
-    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(data) {
-    if (data !== 0xFF)
-      return Draft75.prototype._parseLeadingByte.call(this, data);
-
-    this._closing = true;
-    this._length  = 0;
-    this._stage   = 1;
-  }
-};
-
-for (var key in instance)
-  Draft76.prototype[key] = instance[key];
-
-module.exports = Draft76;
-
@@ -1,30 +0,0 @@
-var Headers = function() {
-  this._sent  = {};
-  this._lines = [];
-};
-
-Headers.prototype.ALLOWED_DUPLICATES = ['set-cookie', 'set-cookie2', 'warning', 'www-authenticate']
-
-Headers.prototype.set = function(name, value) {
-  if (value === undefined) return;
-
-  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;
-
@@ -1,81 +0,0 @@
-var HTTPParser = process.binding('http_parser').HTTPParser,
-    version    = HTTPParser.RESPONSE ? 6 : 4;
-
-var HttpParser = function(type) {
-  if (type === 'request')
-    this._parser = new HTTPParser(HTTPParser.REQUEST || 'request');
-  else
-    this._parser = new HTTPParser(HTTPParser.RESPONSE || 'response');
-
-  this._type     = type;
-  this._complete = false;
-  this.headers   = {};
-
-  var current = null,
-      self    = this;
-
-  this._parser.onHeaderField = function(b, start, length) {
-    current = b.toString('utf8', start, start + length).toLowerCase();
-  };
-
-  this._parser.onHeaderValue = function(b, start, length) {
-    self.headers[current] = b.toString('utf8', start, start + length);
-  };
-
-  this._parser.onHeadersComplete = this._parser[HTTPParser.kOnHeadersComplete] = function(info) {
-    self.method     = (typeof info.method === 'number') ? HttpParser.METHODS[info.method] : info.method;
-    self.statusCode = info.statusCode;
-    self.url        = info.url;
-    
-    var headers = info.headers;
-    if (!headers) return;
-
-    for (var i = 0, n = headers.length; i < n; i += 2)
-      self.headers[headers[i].toLowerCase()] = headers[i+1];
-  };
-
-  this._parser.onMessageComplete = this._parser[HTTPParser.kOnMessageComplete] = function() {
-    self._complete = true;
-  };
-};
-
-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(data) {
-  var offset   = (version < 6) ? 1 : 0,
-      consumed = this._parser.execute(data, 0, data.length) + offset;
-
-  if (this._complete)
-    this.body = (consumed < data.length)
-              ? data.slice(consumed)
-              : new Buffer(0);
-};
-
-module.exports = HttpParser;
-
@@ -1,429 +0,0 @@
-var crypto   = require('crypto'),
-    util     = require('util'),
-    Base     = require('./base'),
-    Reader   = require('./hybi/stream_reader');
-
-var Hybi = function(request, url, options) {
-  Base.apply(this, arguments);
-  this._reset();
-
-  this._reader    = new Reader();
-  this._stage     = 0;
-  this._masking   = this._options.masking;
-  this._protocols = this._options.protocols || [];
-
-  if (typeof this._protocols === 'string')
-    this._protocols = this._protocols.split(/\s*,\s*/);
-
-  this._requireMasking = this._options.requireMasking;
-  this._pingCallbacks  = {};
-
-  if (!this.version) {
-    var version = this._request.headers['sec-websocket-version'];
-    this.version = 'hybi-' + version;
-  }
-};
-util.inherits(Hybi, Base);
-
-Hybi.mask = function(payload, mask, offset) {
-  if (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 = {
-  BYTE:   255,
-  FIN:    128,
-  MASK:   128,
-  RSV1:   64,
-  RSV2:   32,
-  RSV3:   16,
-  OPCODE: 15,
-  LENGTH: 127,
-
-  OPCODES: {
-    continuation: 0,
-    text:         1,
-    binary:       2,
-    close:        8,
-    ping:         9,
-    pong:         10
-  },
-
-  OPCODE_CODES:       [0, 1, 2, 8, 9, 10],
-  FRAGMENTED_OPCODES: [0, 1, 2],
-  OPENING_OPCODES:    [1, 2],
-
-  TWO_POWERS: [0, 1, 2, 3, 4, 5, 6, 7].map(function(n) { return Math.pow(2, 8 * n) }),
-
-  ERRORS: {
-    normal_closure:       1000,
-    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],
-  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})*$/,
-
-  parse: function(data) {
-    this._reader.put(data);
-    var buffer = true;
-    while (buffer) {
-      switch (this._stage) {
-        case 0:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseOpcode(buffer[0]);
-          break;
-
-        case 1:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseLength(buffer[0]);
-          break;
-
-        case 2:
-          buffer = this._reader.read(this._lengthSize);
-          if (buffer) this._parseExtendedLength(buffer);
-          break;
-
-        case 3:
-          buffer = this._reader.read(4);
-          if (buffer) {
-            this._mask  = buffer;
-            this._stage = 4;
-          }
-          break;
-
-        case 4:
-          buffer = this._reader.read(this._length);
-          if (buffer) {
-            this._payload = buffer;
-            this._emitFrame();
-            this._stage = 0;
-          }
-          break;
-
-        default:
-          buffer = null;
-      }
-    }
-  },
-
-  frame: function(data, type, code) {
-    if (this.readyState <= 0) return this._queue([data, type, code]);
-    if (this.readyState !== 1) return false;
-
-    if (data instanceof Array) data = new Buffer(data);
-
-    var isText = (typeof data === 'string'),
-        opcode = this.OPCODES[type || (isText ? 'text' : 'binary')],
-        buffer = isText ? new Buffer(data, 'utf8') : data,
-        insert = code ? 2 : 0,
-        length = buffer.length + insert,
-        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
-        offset = header + (this._masking ? 4 : 0),
-        masked = this._masking ? this.MASK : 0,
-        frame  = new Buffer(length + offset),
-        BYTE   = this.BYTE,
-        mask, i;
-
-    frame[0] = this.FIN | opcode;
-
-    if (length <= 125) {
-      frame[1] = masked | length;
-    } else if (length <= 65535) {
-      frame[1] = masked | 126;
-      frame[2] = Math.floor(length / 256);
-      frame[3] = length & BYTE;
-    } else {
-      frame[1] = masked | 127;
-      frame[2] = Math.floor(length / Math.pow(2,56)) & BYTE;
-      frame[3] = Math.floor(length / Math.pow(2,48)) & BYTE;
-      frame[4] = Math.floor(length / Math.pow(2,40)) & BYTE;
-      frame[5] = Math.floor(length / Math.pow(2,32)) & BYTE;
-      frame[6] = Math.floor(length / Math.pow(2,24)) & BYTE;
-      frame[7] = Math.floor(length / Math.pow(2,16)) & BYTE;
-      frame[8] = Math.floor(length / Math.pow(2,8))  & BYTE;
-      frame[9] = length & BYTE;
-    }
-
-    if (code) {
-      frame[offset]   = Math.floor(code / 256) & BYTE;
-      frame[offset+1] = code & BYTE;
-    }
-    buffer.copy(frame, offset + insert);
-
-    if (this._masking) {
-      mask = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256),
-              Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
-      new Buffer(mask).copy(frame, header);
-      Hybi.mask(frame, mask, offset);
-    }
-
-    this._write(frame);
-    return true;
-  },
-
-  text: function(message) {
-    return this.frame(message, 'text');
-  },
-
-  binary: function(message) {
-    return this.frame(message, 'binary');
-  },
-
-  ping: function(message, callback) {
-    message = message || '';
-    if (callback) this._pingCallbacks[message] = callback;
-    return this.frame(message, 'ping');
-  },
-
-  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.frame(reason, 'close', code);
-      this.readyState = 2;
-      return true;
-    } else {
-      return false;
-    }
-  },
-
-  _handshakeResponse: function() {
-    var secKey = this._request.headers['sec-websocket-key'];
-    if (!secKey) return '';
-
-    var accept    = Hybi.generateAccept(secKey),
-        protos    = this._request.headers['sec-websocket-protocol'],
-        supported = this._protocols,
-        proto,
-
-        headers = [
-          'HTTP/1.1 101 Switching Protocols',
-          'Upgrade: websocket',
-          'Connection: Upgrade',
-          'Sec-WebSocket-Accept: ' + accept
-        ];
-
-    if (protos !== undefined) {
-      if (typeof protos === 'string') protos = protos.split(/\s*,\s*/);
-      proto = protos.filter(function(p) { return supported.indexOf(p) >= 0 })[0];
-      if (proto) {
-        this.protocol = proto;
-        headers.push('Sec-WebSocket-Protocol: ' + proto);
-      }
-    }
-
-    return new Buffer(headers.concat(this.__headers.toString(), '').join('\r\n'), 'utf8');
-  },
-
-  _shutdown: function(code, reason) {
-    this.frame(reason, 'close', code);
-    this.readyState = 3;
-    this._stage = 5;
-    this.emit('close', new Base.CloseEvent(code, reason));
-  },
-
-  _fail: function(type, message) {
-    this.emit('error', new Error(message));
-    this._shutdown(this.ERRORS[type], message);
-  },
-
-  _parseOpcode: function(data) {
-    var rsvs = [this.RSV1, this.RSV2, this.RSV3].map(function(rsv) {
-      return (data & rsv) === rsv;
-    });
-
-    if (rsvs.filter(function(rsv) { return rsv }).length > 0)
-      return this._fail('protocol_error',
-          'One or more reserved bits are on: reserved1 = ' + (rsvs[0] ? 1 : 0) +
-          ', reserved2 = ' + (rsvs[1] ? 1 : 0) +
-          ', reserved3 = ' + (rsvs[2] ? 1 : 0));
-
-    this._final   = (data & this.FIN) === this.FIN;
-    this._opcode  = (data & this.OPCODE);
-    this._mask    = [];
-    this._payload = [];
-
-    if (this.OPCODE_CODES.indexOf(this._opcode) < 0)
-      return this._fail('protocol_error', 'Unrecognized frame opcode: ' + this._opcode);
-
-    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && !this._final)
-      return this._fail('protocol_error', 'Received fragmented control frame: opcode = ' + this._opcode);
-
-    if (this._mode && this.OPENING_OPCODES.indexOf(this._opcode) >= 0)
-      return this._fail('protocol_error', 'Received new data frame but previous continuous frame is unfinished');
-
-    this._stage = 1;
-  },
-
-  _parseLength: function(data) {
-    this._masked = (data & this.MASK) === this.MASK;
-    if (this._requireMasking && !this._masked)
-      return this._fail('unacceptable', 'Received unmasked frame but masking is required');
-
-    this._length = (data & this.LENGTH);
-
-    if (this._length >= 0 && this._length <= 125) {
-      if (!this._checkFrameLength()) return;
-      this._stage = this._masked ? 3 : 4;
-    } else {
-      this._lengthSize = (this._length === 126 ? 2 : 8);
-      this._stage      = 2;
-    }
-  },
-
-  _parseExtendedLength: function(buffer) {
-    this._length = this._getInteger(buffer);
-
-    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && this._length > 125)
-      return this._fail('protocol_error', 'Received control frame having too long payload: ' + this._length);
-
-    if (!this._checkFrameLength()) return;
-
-    this._stage  = this._masked ? 3 : 4;
-  },
-
-  _checkFrameLength: function() {
-    if (this.__blength + this._length > this._maxLength) {
-      this._fail('too_large', 'WebSocket frame length too large');
-      return false;
-    } else {
-      return true;
-    }
-  },
-
-  _emitFrame: function() {
-    var payload = Hybi.mask(this._payload, this._mask),
-        opcode  = this._opcode;
-
-    if (opcode === this.OPCODES.continuation) {
-      if (!this._mode) return this._fail('protocol_error', 'Received unexpected continuation frame');
-      this._buffer(payload);
-      if (this._final) {
-        var message = this._concatBuffer();
-        if (this._mode === 'text') message = this._encode(message);
-        this._reset();
-        if (message === null)
-          this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
-        else
-          this.emit('message', new Base.MessageEvent(message));
-      }
-    }
-    else if (opcode === this.OPCODES.text) {
-      if (this._final) {
-        var message = this._encode(payload);
-        if (message === null)
-          this._fail('encoding_error', 'Could not decode a text frame as UTF-8');
-        else
-          this.emit('message', new Base.MessageEvent(message));
-      } else {
-        this._mode = 'text';
-        this._buffer(payload);
-      }
-    }
-    else if (opcode === this.OPCODES.binary) {
-      if (this._final) {
-        this.emit('message', new Base.MessageEvent(payload));
-      } else {
-        this._mode = 'binary';
-        this._buffer(payload);
-      }
-    }
-    else if (opcode === this.OPCODES.close) {
-      var code   = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null,
-          reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
-
-      if (!(payload.length === 0) &&
-          !(code !== null && code >= this.MIN_RESERVED_ERROR && code <= this.MAX_RESERVED_ERROR) &&
-          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, reason || '');
-    }
-    else if (opcode === this.OPCODES.ping) {
-      this.frame(payload, 'pong');
-    }
-    else if (opcode === this.OPCODES.pong) {
-      var callbacks = this._pingCallbacks,
-          message   = this._encode(payload),
-          callback  = callbacks[message];
-
-      delete callbacks[message];
-      if (callback) callback()
-    }
-  },
-
-  _buffer: function(fragment) {
-    this.__buffer.push(fragment);
-    this.__blength += fragment.length;
-  },
-
-  _concatBuffer: function() {
-    var buffer = new Buffer(this.__blength),
-        offset = 0;
-
-    for (var i = 0, n = this.__buffer.length; i < n; i++) {
-      this.__buffer[i].copy(buffer, offset);
-      offset += this.__buffer[i].length;
-    }
-    return buffer;
-  },
-
-  _reset: function() {
-    this._mode     = null;
-    this.__buffer  = [];
-    this.__blength = 0;
-  },
-
-  _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);
-  },
-
-  _getInteger: function(bytes) {
-    var number = 0;
-    for (var i = 0, n = bytes.length; i < n; i++)
-      number += bytes[i] * this.TWO_POWERS[n - 1 - i];
-    return number;
-  }
-};
-
-for (var key in instance)
-  Hybi.prototype[key] = instance[key];
-
-module.exports = Hybi;
-
@@ -1,46 +0,0 @@
-var StreamReader = function() {
-  this._queue     = [];
-  this._queueSize = 0;
-  this._cursor    = 0;
-};
-
-StreamReader.prototype.read = function(bytes) {
-  return this._readBuffer(bytes);
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!buffer.copy) buffer = new Buffer(buffer);
-  this._queue.push(buffer);
-  this._queueSize += buffer.length;
-};
-
-StreamReader.prototype._readBuffer = function(length) {
-  if (length > this._queueSize) return null;
-
-  var buffer = new Buffer(length),
-      queue  = this._queue,
-      remain = length,
-      n      = queue.length,
-      i      = 0,
-      chunk, offset, size;
-
-  if (remain === 0) return buffer;
-
-  while (remain > 0 && i < n) {
-    chunk = queue[i];
-    offset = (i === 0) ? this._cursor : 0;
-    size = Math.min(remain, chunk.length - offset);
-    chunk.copy(buffer, length - remain, offset, offset + size);
-    remain -= size;
-    this._queueSize -= size;
-    i += 1;
-  }
-
-  queue.splice(0, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
-
-  return buffer;
-};
-
-module.exports = StreamReader;
@@ -1,104 +0,0 @@
-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(data) {
-    if (this._delegate) return this._delegate.parse(data);
-
-    this._http.parse(data);
-    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._delegate.on('open', function() { self._open() });
-    this.EVENTS.forEach(function(event) {
-      this._delegate.on(event, function(e) { self.emit(event, e) });
-    }, this);
-
-    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 = [];
-  }
-};
-
-['setHeader', 'start', 'state', 'frame', 'text', 'binary', 'ping', 'close'].forEach(function(method) {
-  instance[method] = function() {
-    if (this._delegate) {
-      return this._delegate[method].apply(this._delegate, arguments);
-    } 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;
-
@@ -1,144 +0,0 @@
-/**
-
-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;
-  this._driver.frame(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;
-
@@ -1,21 +1,21 @@
-{ "name"            : "websocket-driver"
-, "description"     : "WebSocket protocol handler with pluggable I/O"
-, "homepage"        : "http://github.com/faye/websocket-driver-node"
+{ "name"            : "faye-websocket"
+, "description"     : "Standards-compliant WebSocket server and client"
+, "homepage"        : "http://github.com/faye/faye-websocket-node"
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
-, "keywords"        : ["websocket"]
+, "keywords"        : ["websocket", "eventsource"]
 , "license"         : "MIT"

-, "version"         : "0.3.2"
+, "version"         : "0.9.2"
 , "engines"         : {"node": ">=0.4.0"}
-, "main"            : "./lib/websocket/driver"
-, "devDependencies" : {"jstest": ""}
+, "main"            : "./lib/faye/websocket"
+, "dependencies"    : {"websocket-driver": ">=0.5.1"}
+, "devDependencies" : {"jstest": "", "pace": "", "permessage-deflate": ""}

 , "scripts"         : {"test": "jstest spec/runner.js"}

 , "repository"      : { "type"  : "git"
-                      , "url"   : "git://github.com/faye/websocket-driver-node.git"
+                      , "url"   : "git://github.com/faye/faye-websocket-node.git"
                      }

-, "bugs"            : "http://github.com/faye/websocket-driver-node/issues"
+, "bugs"            : "http://github.com/faye/faye-websocket-node/issues"
 }
-
@@ -0,0 +1,31 @@
+var fs    = require('fs'),
+    http  = require('http'),
+    https = require('https');
+
+var WebSocket = require('../lib/faye/websocket');
+
+var EchoServer = function(secure) {
+  var server = secure
+             ? 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;
+};
+
+EchoServer.prototype.listen = function(port) {
+  this._httpServer.listen(port);
+};
+
+EchoServer.prototype.stop = function() {
+  this._httpServer.close();
+};
+
+module.exports = EchoServer;
@@ -0,0 +1,272 @@
+var Client      = require('../../../lib/faye/websocket/client'),
+    EchoServer  = require('../../echo_server'),
+    ProxyServer = require('../../proxy_server'),
+    test        = require('jstest').Test,
+    fs          = require('fs')
+
+var WebSocketSteps = test.asyncSteps({
+  server: function(port, secure, callback) {
+    this._echoServer = new EchoServer(secure)
+    this._echoServer.listen(port)
+    process.nextTick(callback)
+  },
+
+  stop: function(callback) {
+    this._echoServer.stop()
+    process.nextTick(callback)
+  },
+
+  proxy: function(port, secure, callback) {
+    this._proxyServer = new ProxyServer({tls: secure})
+    this._proxyServer.listen(port)
+    process.nextTick(callback)
+  },
+
+  stop_proxy: function(callback) {
+    this._proxyServer.stop()
+    process.nextTick(callback)
+  },
+
+  open_socket: function(url, protocols, callback) {
+    var done = false,
+        self = this,
+
+        tlsOptions = { ca: fs.readFileSync(__dirname + '/../../server.crt') },
+
+        resume = function(open) {
+                   if (done) return
+                   done = true
+                   self._open = open
+                   callback()
+                 }
+
+    this._ws = new Client(url, protocols, {
+      proxy: { origin: this.proxy_url, tls: tlsOptions },
+      tls:   tlsOptions
+    })
+
+    this._ws.onopen  = function() { resume(true)  }
+    this._ws.onclose = function() { resume(false) }
+  },
+
+  open_socket_and_close_it_fast: function(url, protocols, callback) {
+    var self = this
+
+    this._ws = new Client(url, protocols, {
+      ca: fs.readFileSync(__dirname + '/../../server.crt')
+    })
+
+    this._ws.onopen  = function() { self._open = self._ever_opened = true  }
+    this._ws.onclose = function() { self._open = false }
+
+    this._ws.close()
+
+    callback()
+  },
+
+  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_never_opened: function(callback) {
+    this.assert( !this._ever_opened )
+    callback()
+  },
+
+  check_readable: function(callback) {
+    this.assert( this._ws.readable )
+    callback()
+  },
+
+  check_not_readable: function(callback) {
+    this.assert( ! this._ws.readable )
+    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()
+  },
+
+  wait: function (ms, callback) {
+    setTimeout(callback, ms)
+  }
+})
+
+
+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
+
+    this.plain_text_proxy_url  = "http://localhost:4181"
+    this.secure_text_proxy_url = "https://localhost:4181"
+    this.proxy_port            = 4181
+  })
+
+  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)
+      check_readable()
+      close_socket()
+      check_closed()
+      check_not_readable()
+    }})
+
+    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()
+      }})
+    }})
+
+    it("can be closed before connecting", function() { with(this) {
+      open_socket_and_close_it_fast(socket_url, protocols)
+      wait(10)
+      check_closed()
+      check_never_opened()
+      check_not_readable()
+    }})
+  }})
+
+  sharedBehavior("socket server", function() { with(this) {
+    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(this.port, 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(this.port, true) })
+      after (function() { this.stop() })
+
+      behavesLike("socket client")
+    }})
+  }})
+
+  describe("with no proxy", function() { with(this) {
+    behavesLike("socket server")
+  }})
+
+  describe("with a proxy", function() { with(this) {
+    before(function() {
+      this.proxy_url = this.plain_text_proxy_url
+    })
+
+    before(function() { this.proxy(this.proxy_port, false) })
+    after (function() { this.stop_proxy() })
+
+    behavesLike("socket server")
+  }})
+
+  describe("with a secure proxy", function() { with(this) {
+    before(function() {
+      this.proxy_url = this.secure_text_proxy_url
+    })
+
+    before(function() { this.proxy(this.proxy_port, true) })
+    after (function() { this.stop_proxy() })
+
+    behavesLike("socket server")
+  }})
+}})
@@ -0,0 +1,82 @@
+var fs    = require('fs'),
+    http  = require('http'),
+    https = require('https'),
+    net   = require('net'),
+    url   = require('url');
+
+var AGENTS = {'http:': http, 'https:': https},
+    PORTS  = {'http:': 80,   'https:': 443};
+
+var ProxyServer = function(options) {
+  var proxy = options.tls
+            ? https.createServer({
+                key:  fs.readFileSync(__dirname + '/server.key'),
+                cert: fs.readFileSync(__dirname + '/server.crt')
+              })
+            : http.createServer();
+
+  options = options || {};
+
+  var onRequest = function(request, response) {
+    if (options.debug) console.log(request.method, request.url, request.headers);
+
+    var uri     = url.parse(request.url),
+        agent   = AGENTS[uri.protocol],
+        headers = {};
+
+    for (var key in request.headers) {
+      if (key.split('-')[0] !== 'proxy') headers[key] = request.headers[key];
+    }
+
+    var backend = agent.request({
+      method:  request.method,
+      host:    uri.hostname,
+      port:    uri.port || PORTS[uri.protocol],
+      path:    uri.path,
+      headers: headers,
+      rejectUnauthorized: false
+    });
+
+    request.pipe(backend);
+
+    backend.on('response', function(resp) {
+      if (options.debug) console.log(resp.statusCode, resp.headers);
+      response.writeHead(resp.statusCode, resp.headers);
+      resp.pipe(response);
+    });
+  };
+
+  var onConnect = function(request, frontend, body) {
+    var parts   = request.url.split(':'),
+        backend = net.connect(parts[1], parts[0]);
+
+    frontend.pipe(backend);
+    backend.pipe(frontend);
+
+    backend.on('connect', function() {
+      frontend.write('HTTP/1.1 200 OK\r\n\r\n');
+    });
+
+    if (!options.debug) return;
+    console.log(request.method, request.url, request.headers);
+
+    frontend.on('data', function(data) { console.log('I', data) });
+    backend.on( 'data', function(data) { console.log('O', data) });
+  };
+
+  proxy.on('request', onRequest);
+  proxy.on('connect', onConnect);
+  proxy.on('upgrade', onConnect);
+
+  this._proxy = proxy;
+};
+
+ProxyServer.prototype.listen = function(port) {
+  this._proxy.listen(port);
+};
+
+ProxyServer.prototype.stop = function() {
+  this._proxy.close();
+};
+
+module.exports = ProxyServer;
@@ -1,45 +1 @@
-var test   = require('jstest').Test,
-    Stream = require('stream').Stream,
-    util   = require('util')
-
-var BufferMatcher = function(data) {
-  this._data = (typeof data === 'string')
-             ? new Buffer(data, 'utf8')
-             : new Buffer(data)
-}
-BufferMatcher.prototype.equals = function(other) {
-  if (this._data.length !== other.length) return false;
-  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
-}
-
-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')
-
+require('./faye/websocket/client_spec')
@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICIzCCAYwCCQDZaunNGmqaHjANBgkqhkiG9w0BAQUFADBWMQswCQYDVQQGEwJH
+QjETMBEGA1UECBMKU29tZS1TdGF0ZTEPMA0GA1UEBxMGTG9uZG9uMQ0wCwYDVQQK
+EwRGYXllMRIwEAYDVQQDEwlsb2NhbGhvc3QwHhcNMTQwNjIxMDkzNjAyWhcNMTUw
+NjIxMDkzNjAyWjBWMQswCQYDVQQGEwJHQjETMBEGA1UECBMKU29tZS1TdGF0ZTEP
+MA0GA1UEBxMGTG9uZG9uMQ0wCwYDVQQKEwRGYXllMRIwEAYDVQQDEwlsb2NhbGhv
+c3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBANc64/S51F2OVw1IGZql483S
+sUf7QiuHyHCYxeHB8CeTKXyaH5h3ITmmqjzT5MWgTYuXf39XRf2VqicLWqs0xIAc
+RKBE1VouLM0sbNzMv1yNG7im0bMywXNlOlOmUhtjYZvEx5I10UiJrVxIpEnNiCuZ
+dgCuB944l/lQrndkaqWtAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEA1UmNwUA7KVaU
+jg3iofsr0UgFCNO9sZ6PeEoh6NETrckhYd1TB3S7QAgHMiu4e8cEVnlYyIm6oJnp
+l5edfaUHh3PGwt5jLzpg/l+OVT5qkixRJdazx+pd/CFYIgot2+7hEao9NC4GV1Tl
+yR0IxlKRsQO3iZlpe7/Klqjaq/r9tQM=
+-----END CERTIFICATE-----
@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDXOuP0udRdjlcNSBmapePN0rFH+0Irh8hwmMXhwfAnkyl8mh+Y
+dyE5pqo80+TFoE2Ll39/V0X9laonC1qrNMSAHESgRNVaLizNLGzczL9cjRu4ptGz
+MsFzZTpTplIbY2GbxMeSNdFIia1cSKRJzYgrmXYArgfeOJf5UK53ZGqlrQIDAQAB
+AoGBAK8U+NrbUCXK5IWpYSqsR+PmwNANVIaUrjjqDg7X9MQ8skLqHUmpnx2GtnVE
+6ZTaEjq7wruUAxuF5CRe2CLtieouaLvF/gcAsff2Q4kL8taDrM54ECC69JFfijE4
+jJfEkoJRi1B0nq2QxJke3Sm3vrW2zLDqAZ4EUIh3uxXIYgcBAkEA+imv190S+bCM
+3H/3L5LHeTRwL58HWcYYjx+/K85yaCqf4wrwyYQ1jRho76uqkjq1mvL65nOniIxd
+NRnLTiQ+jwJBANxAiY4ww16fUkBGBh2np0FfDUhWgk5G5aZWHsK+5SJZXvlV0kmn
+kf2R+8hEzAAaOh3Y4d4UBXzOZCKh0nxYdgMCQQCNsQ7oNU+KHXWrbs+TIo/ZFtp0
+Hp8LOiiu6Exfg49JcNsevhOkED5ErI7DMXhrWtWB7h4uaVN7BAXHDdUZbW4BAkAp
+Yys1/+3GaxPOphniGq3wN8dML41e3i2rOwWevLZb5QVWvwy78HQbfQIeGOdooYUI
+NMgErih10ma4p0XhPdI3AkBFp830jNItVGZtVvNRmtx2AR370qMs+AwFTK76mcMW
+xysAGnAUv7h6Qx+M6b3He8OcWVMNqMiv8yI/o2PnsvUS
+-----END RSA PRIVATE KEY-----
@@ -1,252 +0,0 @@
-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("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 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("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 )
-      }})
-    }})
-  }})
-}})
-
@@ -1,115 +0,0 @@
-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("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() )
-        }})
-      }})
-    }})
-  }})
-}})
-
@@ -1,100 +0,0 @@
-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")
-}})
-
@@ -1,187 +0,0 @@
-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('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 Web Socket 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("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" +
-            "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 Web Socket 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()
-      }})
-    }})
-  }})
-}})
-
@@ -1,542 +0,0 @@
-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 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("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("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("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 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("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() )
-      }})
-    }})
-  }})
-
-  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("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() )
-      }})
-    }})
-  }})
-}})
-
Author	SHA1	Message	Date
James Coglan	cd8f337278	Bump version to 0.9.2.	2014-12-21 22:24:01 +00:00
James Coglan	76ffac630c	Close cleanly if close() is called before the TCP connection is established.	2014-12-21 18:22:03 +00:00
James Coglan	d2abdb1870	Refactor event emitters to make sure errors are only emitted once before the closing procedure is started.	2014-12-21 16:46:33 +00:00
James Coglan	f14a49b6eb	Only emit the first error before closing the socket.	2014-12-19 08:07:46 +00:00
James Coglan	73284c858c	Bump version to 0.9.1.	2014-12-18 02:25:03 +00:00
James Coglan	ec5838e27e	Typo; I'd used . instead of , in an arglist.	2014-12-17 22:50:19 +00:00
James Coglan	2627293613	Validate the option names passed into the WebSocket constructor.	2014-12-17 22:42:34 +00:00
James Coglan	4f1eced5e0	Bump version to 0.9.0 and document how to add extensions.	2014-12-13 14:03:37 +00:00
James Coglan	ca0544fa6a	Revert 29d07c5; see https://github.com/faye/faye-websocket-node/pull/34	2014-12-13 01:25:33 +00:00
James Coglan	091d98ef0c	Merge pull request #34 from lpinca/fix/close-on-handshake Handle cases where the socket is closed before being passed to the server	2014-12-13 00:15:22 +00:00
James Coglan	8d1f652056	Stylistic tweaks to the Autobahn client.	2014-12-06 10:51:18 +00:00
Luigi Pinca	b779876f07	Handle cases where the socket is closed before being passed to the server See #32	2014-11-26 16:08:05 +01:00
James Coglan	243e39b7b7	Refactor the Autobahn client script.	2014-11-24 22:05:56 +00:00
James Coglan	04eda7bc4f	Allow the user to pass extensions through to websocket-driver via the WebSocket constructor.	2014-11-24 00:37:12 +00:00
James Coglan	43ac090594	Add vanilla request support to the proxy server.	2014-11-23 21:56:51 +00:00
James Coglan	1120828003	Bump version to 0.8.1.	2014-11-12 19:35:37 +00:00
James Coglan	59911312ac	Merge pull request #33 from meteor/specify-servername Fix proxy connections to non-localhost SSL origins	2014-11-12 19:27:41 +00:00
David Glasser	98298acb36	Fix proxy connections to non-localhost SSL origins The socket form of tls.connect needs to be told the server name it is connecting to in order to validate the server certificate (and to perform SNI). Without this change, just about any attempt to proxy to an SSL origin will fail. This name defaults to 'localhost': https://github.com/joyent/node/blob/v0.10/lib/tls.js#L1349 so an attempt to proxy to an SSL origin named 'localhost' would have succeeded, which is why tests passed.	2014-11-10 16:47:56 -08:00
James Coglan	89a9b0d9b8	Update the release date for 0.8.0.	2014-11-08 19:47:25 +00:00
James Coglan	0e00ea5107	Fix the off-by-one error in the Autobahn client's progress bar.	2014-11-08 19:45:47 +00:00
James Coglan	d471a6a707	Don't test on v0.6, its tls.connect({socket}) doesn't seem to work.	2014-11-08 15:40:12 +00:00
James Coglan	5dc1d7f682	Migrate back to the driver API from https://github.com/faye/websocket-driver-node/commit/0bb47c17b467980293a9f010de485722c4298b43 , and perform all necessary TLS in this module.	2014-11-08 15:34:02 +00:00
James Coglan	dfe361a18b	Adjust formatting of example log messages.	2014-11-08 12:47:12 +00:00
James Coglan	140171307e	Make ProxyServer work on Node 0.6.	2014-11-07 19:25:06 +00:00
James Coglan	6c5ef1c884	Load websocket-driver from git.	2014-11-07 08:57:51 +00:00
James Coglan	7ffe738208	Use an http: endpoint for the proxy example.	2014-11-06 23:35:45 +00:00
James Coglan	2db4ef20ff	Pass in the client certificate for navigating https: proxies in the client example, and log the handshake headers.	2014-11-06 23:05:30 +00:00
James Coglan	54cd6f5831	Accientally left part of the proxy tests commented out.	2014-11-06 23:04:56 +00:00
James Coglan	35d9e6998e	Log the request headers in the example servers, and log all I/O through the proxy server.	2014-11-06 09:01:39 +00:00
James Coglan	e649b62396	Replace the old client example with echo_client.js.	2014-11-06 08:46:44 +00:00
James Coglan	d0ec17d6a3	Migrate to the new simplified websocket-driver proxy API, and add integration tests for ws: and wss: sockets via an http: proxy.	2014-11-05 23:36:00 +00:00
James Coglan	1d3878e3ed	Remove the stream.resume() call from Client, not needed now that Proxy emits 'close'.	2014-10-30 00:36:45 +00:00
James Coglan	97dfaf71cf	Replace an empty on('data') hook with resume().	2014-10-29 23:09:20 +00:00
James Coglan	723f4ce6a7	Migrate proxy support onto the API introduced in https://github.com/faye/websocket-driver-node/commit/76f41286342e517e7ff562495b249a7fa103bbe9 .	2014-10-29 22:26:22 +00:00
James Coglan	97b7342538	[wip] Use the proxy-connect event from the driver to perform a TLS handshake when using wss: via a proxy.	2014-10-29 19:28:55 +00:00
James Coglan	9d8e5384b7	Use 'tls' not 'ssl' to indicate a secure server in the examples.	2014-10-29 19:28:18 +00:00
James Coglan	42ea7fb0a5	Adjust the UA string used for the Autobahn client.	2014-10-29 08:52:10 +00:00
James Coglan	03acb154e2	Set readyState to CLOSED as soon as finalize() is called to prevent reentrant calls from events this method emits.	2014-10-28 09:51:31 +00:00
James Coglan	b40fc25444	Fix secure connection via proxies; the client was hard-coded to only treat wss:, not https:, as a secure protocol.	2014-10-27 22:43:38 +00:00
James Coglan	05cc735582	Add support for connecting via an HTTP proxy and bump version to 0.8.0.	2014-10-27 09:39:40 +00:00
James Coglan	29d07c5002	Close the socket if close() is called when we're still waiting for a handshake.	2014-10-26 13:04:06 +00:00
James Coglan	2118283941	Bump the copyright year.	2014-10-04 08:51:29 +01:00
James Coglan	4db640660d	Bump version to 0.7.3.	2014-10-04 08:34:14 +01:00
James Coglan	4353dd8c36	Remove some redundant steps from the fast-close spec. Until the next tick of the event loop no socket events will have fired.	2014-10-03 01:03:53 +01:00
James Coglan	308f930160	Merge pull request #29 from meteor/close-before-start Test for faye/websocket-driver-node#8	2014-09-07 21:29:48 +01:00
James Coglan	5d7e9ef9a3	Use the SVG build status icon from Travis.	2014-09-07 21:06:21 +01:00
David Glasser	07217fe317	Test for faye/websocket-driver-node#8 If you decide to open a client connection but then close it before the TCP connection succeeds, the websocket-driver change tested by this commit will ensure that it will actually close, rather than ignoring the close() method. The change to API.close also seems correct to me, though I'm not sure if there are any observable changes if you don't do it.	2014-08-17 19:50:10 -07:00
James Coglan	29ef6b04a5	Update the self-signed certs used for HTTPS testing.	2014-07-05 11:07:52 +01:00
James Coglan	1030d38093	Trailing blank lines are bad.	2014-05-17 00:37:42 +01:00
James Coglan	fa7dcf365c	Bump version to 0.7.2.	2013-12-29 12:28:24 +00:00
James Coglan	018ef183bf	Share more tcp-handling code between server and client connections. Makes sure clients emit 'close' on Node v0.10.	2013-12-29 02:17:01 +00:00
James Coglan	b545e8b80f	Make Node 0.6 work on Travis.	2013-12-28 17:49:13 +00:00
James Coglan	07f5ef6f95	Document the new lower frame size limit.	2013-12-28 17:48:26 +00:00
James Coglan	052120b3d5	Bump version to 0.7.1.	2013-12-03 00:49:02 +00:00
James Coglan	f97fd88e02	A little formatting change around network error handling.	2013-12-02 21:44:24 +00:00
faye	a8481f8cdd	Merge pull request #27 from ramsperger/master Forward networking error events to the websocket event listeners.	2013-12-02 13:31:02 -08:00
James Coglan	d0c9689747	Remove unneeded options existence check.	2013-12-02 21:19:20 +00:00
James Coglan	e668e64271	Expose the driver's maxLength option.	2013-12-02 21:15:32 +00:00
James Coglan	f0b97a8005	Restructure tests slightly.	2013-12-02 13:08:02 +00:00
ramsperger	e3cc891187	Forward networking error events to the websocket event listeners. Handshake failures from HTTP were being fired as errors connection errors failed to show up. Dispatch network failure events (like connection refused, etc.)	2013-10-24 14:53:16 -04:00
James Coglan	d1f2c2172d	Bump version to 0.7.0.	2013-09-09 22:22:28 +01:00
James Coglan	0eb7d7173d	Document the headers option to EventSource.	2013-08-24 11:52:47 +01:00
James Coglan	426e72786b	Remove extra line break in EventSource headers.	2013-08-24 11:28:11 +01:00
James Coglan	b126e31b81	Allow custom headers to be set on EventSource connections.	2013-08-24 11:21:05 +01:00
James Coglan	067df9aaf4	Bump version to 0.6.1.	2013-07-05 15:18:10 +01:00
James Coglan	c6b40aefbb	Older Nodes don't support chained pipe().	2013-07-05 11:15:36 +01:00
James Coglan	a68ff2c035	Start the driver asynchronously on the server to allow onopen hooks to be registered.	2013-07-04 21:55:30 +01:00
James Coglan	da424b7d71	Modernize package.json.	2013-07-01 02:21:41 +01:00
James Coglan	f2c08de98f	Migrate to jstest.	2013-07-01 02:20:52 +01:00
James Coglan	bbdbf1cb46	Correct package.json formatting.	2013-06-23 01:13:50 +01:00
James Coglan	d5d4d9e009	Merge pull request #22 from cezor/master Use singular repository to avoid warning	2013-06-22 17:12:14 -07:00
James Coglan	8a8e44b283	Support the 'ca' option to client connections, and remove the verify: false option.	2013-06-19 08:09:19 +01:00
Nick Nissen	db9bbba6bc	renamed repossitories keyword	2013-06-16 22:13:53 +02:00
Nick Nissen	085d8d2b43	Use singular repository to avoid warning	2013-06-15 13:54:20 +02:00
James Coglan	ad572ca5e0	Turn the reflexive piping into a one-liner.	2013-05-29 02:21:53 +01:00
James Coglan	b861f1a779	Woops, left a console.log in.	2013-05-12 15:04:10 +01:00
James Coglan	047f87e4cd	Set status and headers on error, not just on open.	2013-05-12 14:44:57 +01:00
James Coglan	d6728e115d	Add support for custom handshake headers.	2013-05-12 14:39:30 +01:00
James Coglan	15aedb7ca3	Make mention of streams more prominent.	2013-05-05 09:54:47 +01:00
James Coglan	7e9149faff	Remove .redcar from .npmignore.	2013-05-05 01:51:52 +01:00
James Coglan	7fc369fc82	Bump version to 0.5.0.	2013-05-05 01:47:37 +01:00
James Coglan	ec4ba0eb74	Use pipe() for the Autobahn echo client.	2013-05-05 00:01:17 +01:00
James Coglan	d9475f5b07	Don't end the EventSource when piping a file into it.	2013-05-04 21:37:46 +01:00
James Coglan	c68b3fdc46	Remove the websocket-driver submodule.	2013-05-04 20:45:26 +01:00
James Coglan	827af89809	Refer to 3rd 'upgrade' argument as 'body' instead of 'head'.	2013-05-04 17:37:53 +01:00
James Coglan	0d503a31e3	Return a normal HTTP response if the request is not a WebSocket in the documentation.	2013-05-04 17:33:57 +01:00
James Coglan	99fa7a57ca	Various bits of stream-related refactoring.	2013-05-04 17:30:07 +01:00
James Coglan	b0b39b8325	websocket-protocol is now websocket-driver.	2013-05-04 16:43:03 +01:00
James Coglan	77ee71c678	A few updates to the readme.	2013-05-04 15:09:45 +01:00
James Coglan	fc759a66e9	s/this/self/ because otherwise error dispatching doesn't work.	2013-05-02 01:26:16 +01:00
James Coglan	459499d6d6	Expose parser error events to the user.	2013-05-02 00:12:56 +01:00
James Coglan	30d3eda575	Don't return anything from EventTarget methods.	2013-05-01 09:07:55 +01:00
James Coglan	699c023286	Turn EventTarget into a proxy to EventEmitter since classes are now Streams.	2013-05-01 08:57:53 +01:00
James Coglan	9ff5d28799	Implement EventSource as a writable stream.	2013-05-01 08:50:27 +01:00
James Coglan	43bd4dceb3	Change port used for tests.	2013-05-01 01:14:51 +01:00
James Coglan	971968be85	Rename supportedProtos to protocols.	2013-05-01 01:03:27 +01:00
James Coglan	2a2b7dfb11	Bump websocket-protocol.	2013-05-01 01:00:14 +01:00
James Coglan	83925f68d3	The protocol library now uses a version property instead of a getVersion() method.	2013-05-01 00:56:23 +01:00
James Coglan	ee3212fada	Implement the read/write stream interface on the API class.	2013-05-01 00:32:14 +01:00
James Coglan	789759bf07	Move most WebSocket logic into the API class so that the server and client classes just deal with getting a parser and setting up an IO stream.	2013-05-01 00:14:05 +01:00
James Coglan	3baa12600a	Write the request body to the IO stream before piping the request socket in.	2013-04-30 23:48:11 +01:00
James Coglan	339cc7ad1c	Bump websocket-protocol module and support legacy stream interface.	2013-04-30 23:36:54 +01:00
James Coglan	fdd5cc6db2	Migrate to new protocol event API.	2013-04-30 09:07:06 +01:00
James Coglan	36d4e053d8	Bump the websocket-protocol submodule.	2013-04-29 22:35:28 +01:00
James Coglan	347e5df9a2	Bump the websocket-protocol submodule.	2013-04-29 21:51:58 +01:00
James Coglan	96d31cf694	Remove the hixie protocol handlers, they're now in websocket-protocol.	2013-04-29 21:45:03 +01:00
James Coglan	4ccd6f5a59	Bump the websocket-protocol submodule.	2013-04-29 21:36:46 +01:00
James Coglan	56f9b8ec4d	Write the head to the handler so that draft-76 works.	2013-04-29 20:47:03 +01:00
James Coglan	217b32c383	Bump the websocket-protocol submodule.	2013-04-29 20:28:05 +01:00
James Coglan	6571e070a0	Remove some unneeded test code.	2013-04-29 19:08:38 +01:00
James Coglan	7e5d85278d	Fix TCP error-catching. We should probably fix this in websocket-protocol instead, maybe.	2013-04-29 00:59:42 +01:00
James Coglan	178b2eebde	Reinstate the exported Client.	2013-04-29 00:46:16 +01:00
James Coglan	e6dd7b0749	Remove old Hybi parsers and update websocket-protocol submodule.	2013-04-29 00:20:01 +01:00
James Coglan	ad4ca36a8c	Move protocol handlers into a submodule.	2013-04-28 19:08:10 +01:00