Remove jstest copy of nopt, which will not run on Node <= v12

Set close timer before closing the driver.

.github/workflows/test.yml

@@ -0,0 +1,41 @@
+on:
+  - push
+  - pull_request
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        node:
+          - '0.8'
+          - '0.10'
+          - '0.12'
+          - '4'
+          - '6'
+          - '8'
+          - '10'
+          - '12'
+          - '14'
+          - '16'
+          - '18'
+          - '20'
+    name: node.js v${{ matrix.node }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+
+      - if: matrix.node == '0.8'
+        run: npm conf set strict-ssl false
+
+      - run: node --version
+      - run: npm install
+
+      - run: npm install 'nopt@5'
+      - run: rm -rf node_modules/jstest/node_modules/nopt
+
+      - run: npm test

.gitignore

@@ -1 +1,2 @@
 node_modules
+package-lock.json

.npmignore

@@ -1,6 +0,0 @@
-.git
-.gitignore
-.npmignore
-.travis.yml
-node_modules
-spec

.travis.yml

@@ -1,8 +0,0 @@
-language: node_js
-
-node_js:
-  - "0.6"
-  - "0.8"
-  - "0.10"
-  - "0.11"
-

CHANGELOG.md

@@ -1,18 +1,139 @@
-### 0.2.2 / 2013-07-05
+### 0.11.4 / 2021-05-24
 
-* No functional changes, just updates to package.json
+- Prevent the client hanging if `close()` is called when already closing
 
-### 0.2.1 / 2013-05-17
+### 0.11.3 / 2019-06-10
 
-* Export the isSecureRequest() method since faye-websocket relies on it
-* Queue sent messages in the client's initial state
+- Fix a race condition that caused a timeout not to be cancelled immediately
+  when the WebSocket is closed
+- Change license from MIT to Apache 2.0
 
-### 0.2.0 / 2013-05-12
+### 0.11.2 / 2019-06-10
 
-* Add API for setting and reading headers
-* Add Driver.server() method for getting a driver for TCP servers
+(This version was pulled due to an error when publishing)
 
-### 0.1.0 / 2013-05-04
+### 0.11.1 / 2017-01-22
 
-* First stable release
+- Forcibly close the I/O stream after a timeout if the peer does not respond
+  after calling `close()`
 
+### 0.11.0 / 2016-02-24
+
+- Introduce a `net` option to the `Client` class for setting things like, say,
+  `servername`
+
+### 0.10.0 / 2015-07-08
+
+- Add the standard `code` and `reason` parameters to the `close` method
+
+### 0.9.4 / 2015-03-08
+
+- Don't send input to the driver before `start()` is called
+
+### 0.9.3 / 2015-02-19
+
+- Make sure the TCP socket is not left open when closing the connection
+
+### 0.9.2 / 2014-12-21
+
+- Only emit `error` once, and don't emit it after `close`
+
+### 0.9.1 / 2014-12-18
+
+- Check that all options to the WebSocket constructor are recognized
+
+### 0.9.0 / 2014-12-13
+
+- Allow protocol extensions to be passed into websocket-extensions
+
+### 0.8.1 / 2014-11-12
+
+- Send the correct hostname when upgrading a connection to TLS
+
+### 0.8.0 / 2014-11-08
+
+- 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

CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+# Code of Conduct
+
+All projects under the [Faye](https://github.com/faye) umbrella are covered by
+the [Code of Conduct](https://github.com/faye/code-of-conduct).

LICENSE.md

@@ -0,0 +1,12 @@
+Copyright 2010-2021 James Coglan
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

README.md

@@ -1,305 +1,311 @@
-# 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.
+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](https://nodejs.org/) application. It does not provide any abstraction
+other than the standard [WebSocket
+API](https://html.spec.whatwg.org/multipage/comms.html#network).
 
-Due to this design, you get a lot of things for free. In particular, if you
-hook this module up to some I/O object, it will do all of this for you:
-
-* Select the correct server-side driver to talk to the client
-* Generate and send both server- and client-side handshakes
-* Recognize when the handshake phase completes and the WS protocol begins
-* Negotiate subprotocol selection based on `Sec-WebSocket-Protocol`
-* 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](https://html.spec.whatwg.org/multipage/comms.html#server-sent-events)
+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;
+  if (WebSocket.isWebSocket(request)) {
+    var ws = new WebSocket(request, socket, body);
 
-  var driver = websocket.http(request);
+    ws.on('message', function(event) {
+      ws.send(event.data);
+    });
 
-  driver.io.write(body);
-  socket.pipe(driver.io).pipe(socket);
-
-  driver.messages.on('data', function(message) {
-    console.log('Got a message', message);
-  });
-
-  driver.start();
+    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` if and only if 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.
 
-* `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.
+```js
+var ws = new WebSocket.Client('ws://www.example.com/', [], {
+  proxy: {
+    origin:  'http://username:password@proxy.example.com',
+    headers: { 'User-Agent': 'node' },
+    tls:     { cert: fs.readFileSync('client.crt') }
+  }
+});
+```
 
-A driver has two duplex streams attached to it:
-
-* <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.
-
-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.
-
-#### `driver.on('open', function(event) {})`
-
-Sets the callback to execute when the socket becomes open.
-
-#### `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.
-
-You can also listen for messages using the `driver.messages.on('data')` event,
-which emits strings for text messages and buffers for binary messages.
-
-#### `driver.on('error', function(event) {})`
-
-Sets the callback to execute when a protocol error occurs due to the other peer
-sending an invalid byte sequence. `event` will have a `message` attribute
-describing the error.
-
-#### `driver.on('close', function(event) {})`
-
-Sets the callback to execute when the socket becomes closed. The `event` object
-has `code` and `reason` attributes.
-
-#### `driver.setHeader(name, value)`
-
-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.
-
-#### `driver.start()`
-
-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.
-
-#### `driver.parse(string)`
-
-Takes a string and parses it, potentially resulting in message events being
-emitted (see `on('message')` above) or in data being sent to `driver.io`.  You
-should send all data you receive via I/O to this method by piping a stream into
-`driver.io`.
-
-#### `driver.text(string)`
-
-Sends a text message over the socket. If the socket handshake is not yet
-complete, the message will be queued until it is. Returns `true` if the message
-was sent or queued, and `false` if the socket can no longer send messages.
-
-This method is equivalent to `driver.messages.write(string)`.
-
-#### `driver.binary(buffer)`
-
-Takes a `Buffer` and sends it as a binary message. Will queue and return `true`
-or `false` the same way as the `text` method. It will also return `false` if
-the driver does not support binary messages.
-
-This method is equivalent to `driver.messages.write(buffer)`.
-
-#### `driver.ping(string = '', function() {})`
-
-Sends a ping frame over the socket, queueing it if necessary. `string` and the
-callback are both optional. If a callback is given, it will be invoked when the
-socket receives a pong frame whose content matches `string`. Returns `false` if
-frames can no longer be sent, or if the driver does not support ping/pong.
-
-#### `driver.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.
+The `tls` value is an object that will be passed to
+[`tls.connect()`](https://nodejs.org/api/tls.html#tls_tls_connect_options_callback).
 
 
-## License
+## Subprotocol negotiation
 
-(The MIT License)
+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:
 
-Copyright (c) 2010-2013 James Coglan
+```js
+var ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
+```
 
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the 'Software'), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
+On the server side, you can likewise pass in the list of protocols the server
+supports after the other constructor arguments:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+```js
+var ws = new WebSocket(request, socket, body, ['irc', 'amqp']);
+```
 
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+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, socket, body, [], { 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.
+- `ping` - an integer that sets how often the WebSocket should send ping frames,
+  measured in seconds
+
+The client accepts some additional options:
+
+- `proxy` - settings for a proxy as described above
+- `net` - an object containing settings for the origin server that will be
+  passed to
+  [`net.connect()`](https://nodejs.org/api/net.html#net_socket_connect_options_connectlistener)
+- `tls` - an object containing TLS settings for the origin server, this will be
+  passed to
+  [`tls.connect()`](https://nodejs.org/api/tls.html#tls_tls_connect_options_callback)
+- `ca` - (legacy) a shorthand for passing `{ tls: { ca: value } }`
+
+
+## WebSocket API
+
+Both server- and client-side `WebSocket` objects support the following API.
+
+- **`on('open', function(event) {})`** fires when the socket connection is
+  established. Event has no attributes.
+- **`on('message', function(event) {})`** fires when the socket receives a
+  message. Event has one attribute, **`data`**, which is either a `String` (for
+  text frames) or a `Buffer` (for binary frames).
+- **`on('error', function(event) {})`** 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.
+- **`on('close', function(event) {})`** fires when either the client or the
+  server closes the connection. Event has two optional attributes, **`code`**
+  and **`reason`**, that expose the status code and message sent by the peer
+  that closed the connection.
+- **`send(message)`** accepts either a `String` or a `Buffer` and sends a text
+  or binary message over the connection to the other peer.
+- **`ping(message, function() {})`** sends a ping frame with an optional message
+  and fires the callback when a matching pong is received.
+- **`close(code, reason)`** closes the connection, sending the given status code
+  and reason text, both of which are optional.
+- **`version`** is a string containing the version of the `WebSocket` protocol
+  the connection is using.
+- **`protocol`** is a string (which may be empty) identifying the subprotocol
+  the socket is using.
+
+
+## Handling EventSource connections in Node
+
+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.
+
+```js
+var WebSocket   = require('faye-websocket'),
+    EventSource = WebSocket.EventSource,
+    http        = require('http');
+
+var server = http.createServer();
+
+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');
+  }
+});
+
+server.listen(8000);
+```
+
+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`:
+
+```js
+es.send('Breaking News!', { event: 'notification', id: '99' });
+```
+
+The `EventSource` object exposes the following properties:
+
+- **`url`** is a string containing the URL the client used to create the
+  EventSource.
+- **`lastEventId`** 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.
+
+When you initialize an EventSource with ` new EventSource()`, you can pass
+configuration options after the `response` parameter. Available options are:
+
+- **`headers`** is an object containing custom headers to be set on the
+  EventSource response.
+- **`retry`** is a number that tells the client how long (in seconds) it should
+  wait after a dropped connection before attempting to reconnect.
+- **`ping`** 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.
+
+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:
+
+```js
+var es = new EventSource(request, response, {
+  headers: { 'Access-Control-Allow-Origin': '*' },
+  ping:    15,
+  retry:   10
+});
+```
+
+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.

examples/autobahn_client.js

@@ -0,0 +1,39 @@
+var WebSocket = require('..').Client,
+    deflate   = require('permessage-deflate'),
+    pace      = require('pace');
+
+var host    = 'ws://0.0.0.0:9001',
+    agent   = encodeURIComponent('node-' + process.version),
+    cases   = 0,
+    options = { extensions: [deflate] };
+
+var socket = new WebSocket(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(url);
+    socket.onclose = function() { process.exit() };
+    return;
+  }
+
+  url = host + '/runCase?case=' + n + '&agent=' + agent;
+  socket = new WebSocket(url, [], options);
+  socket.pipe(socket);
+
+  socket.on('close', function() {
+    progress.op();
+    runCase(n + 1);
+  });
+};
+
+socket.onclose = function() {
+  runCase(1);
+};

examples/client.js

@@ -0,0 +1,32 @@
+var WebSocket = require('..').Client,
+    deflate   = require('permessage-deflate'),
+    fs        = require('fs');
+
+var url   = process.argv[2],
+    proxy = process.argv[3],
+    ca    = fs.readFileSync(__dirname + '/../spec/server.crt'),
+    tls   = { ca: ca };
+
+var ws = new WebSocket(url, [], {
+  proxy:      { origin: proxy, headers: { 'User-Agent': 'Echo' }, tls: tls },
+  tls:        tls,
+  headers:    { Origin: 'http://faye.jcoglan.com' },
+  extensions: [deflate]
+});
+
+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);
+};

examples/haproxy.conf

@@ -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

examples/proxy_server.js

@@ -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);

examples/server.js

@@ -0,0 +1,69 @@
+var WebSocket = require('..'),
+    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);

examples/sse.html

@@ -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>

examples/tcp_server.js

@@ -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]);
-

examples/ws.html

@@ -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>

lib/faye/eventsource.js

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

lib/faye/websocket.js

@@ -0,0 +1,47 @@
+// API references:
+//
+// * https://html.spec.whatwg.org/multipage/comms.html#network
+// * https://dom.spec.whatwg.org/#interface-eventtarget
+// * https://dom.spec.whatwg.org/#interface-event
+
+'use strict';
+
+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);
+
+  API.call(this, options);
+
+  process.nextTick(function() {
+    self._driver.start();
+    self._driver.io.write(body);
+  });
+};
+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;

lib/faye/websocket/api.js

@@ -0,0 +1,199 @@
+'use strict';
+
+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;
+
+API.CLOSE_TIMEOUT = 30000;
+
+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(code, reason) {
+    if (code === undefined) code = 1000;
+    if (reason === undefined) reason = '';
+
+    if (code !== 1000 && (code < 3000 || code > 4999))
+      throw new Error("Failed to execute 'close' on WebSocket: " +
+                      "The code must be either 1000, or between 3000 and 4999. " +
+                      code + " is neither.");
+
+    if (this.readyState < API.CLOSING) {
+      var self = this;
+      this._closeTimer = setTimeout(function() {
+        self._beginClose('', 1006);
+      }, API.CLOSE_TIMEOUT);
+    }
+
+    if (this.readyState !== API.CLOSED) this.readyState = API.CLOSING;
+
+    this._driver.close(reason, code);
+  },
+
+  _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;
+    this._closeParams = [reason, code];
+
+    if (this._stream) {
+      this._stream.destroy();
+      if (!this._stream.readable) this._finalizeClose();
+    }
+  },
+
+  _finalizeClose: function() {
+    if (this.readyState === API.CLOSED) return;
+    this.readyState = API.CLOSED;
+
+    if (this._closeTimer) clearTimeout(this._closeTimer);
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    if (this._stream) this._stream.end();
+
+    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;

lib/faye/websocket/api/event.js

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

lib/faye/websocket/api/event_target.js

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

lib/faye/websocket/client.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var util   = require('util'),
+    net    = require('net'),
+    tls    = require('tls'),
+    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() },
+      netOptions = options.net || {},
+      originTLS  = options.tls || {},
+      socketTLS  = proxy.origin ? (proxy.tls || {}) : originTLS,
+      self       = this;
+
+  netOptions.host = socketTLS.host = endpoint.hostname;
+  netOptions.port = socketTLS.port = port;
+
+  originTLS.ca = originTLS.ca || options.ca;
+  socketTLS.servername = socketTLS.servername || endpoint.hostname;
+
+  this._stream = secure
+               ? tls.connect(socketTLS, onConnect)
+               : net.connect(netOptions, 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;

lib/websocket/driver.js

@@ -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;
-

lib/websocket/driver/base.js

@@ -1,121 +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.__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 = {
-  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;
-

lib/websocket/driver/client.js

@@ -1,109 +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(', '));
-
-    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;
-

lib/websocket/driver/draft75.js

@@ -1,109 +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 = {
-  parse: function(buffer) {
-    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) {
-            this.readyState = 3;
-            this.emit('close', new Base.CloseEvent(null, null));
-          }
-          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);
-            }
-          }
-          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;
-

lib/websocket/driver/draft76.js

@@ -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;
-

lib/websocket/driver/headers.js

@@ -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;
-

lib/websocket/driver/http_parser.js

@@ -1,57 +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 = function(info) {
-    self.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 = function() {
-    self._complete = true;
-  };
-};
-
-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;
-

lib/websocket/driver/hybi.js

@@ -1,406 +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],
-
-  MAX_LENGTH: Math.pow(2, 53) - 1,
-  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;
-      }
-    }
-  },
-
-  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.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) {
-      this._stage = this._masked ? 3 : 4;
-    } else {
-      this._lengthBuffer = [];
-      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._length > this.MAX_LENGTH)
-      return this._fail('too_large', 'WebSocket frame length too large');
-
-    this._stage  = this._masked ? 3 : 4;
-  },
-
-  _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 = new Buffer(this.__buffer);
-        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) {
-    for (var i = 0, n = fragment.length; i < n; i++)
-      this.__buffer.push(fragment[i]);
-  },
-
-  _reset: function() {
-    this._mode    = null;
-    this.__buffer = [];
-  },
-
-  _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;
-

lib/websocket/driver/hybi/stream_reader.js

@@ -1,43 +0,0 @@
-var StreamReader = function() {
-  this._queue  = [];
-  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);
-};
-
-StreamReader.prototype._readBuffer = function(length) {
-  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;
-    i += 1;
-  }
-
-  if (remain > 0) return null;
-
-  queue.splice(0, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
-
-  return buffer;
-};
-
-module.exports = StreamReader;

lib/websocket/driver/server.js

@@ -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;
-

lib/websocket/streams.js

@@ -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;
-

package.json

@@ -1,21 +1,35 @@
-{ "name"            : "websocket-driver"
-, "description"     : "WebSocket protocol handler with pluggable I/O"
-, "homepage"        : "http://github.com/faye/websocket-driver-node"
-, "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
-, "keywords"        : ["websocket"]
-, "license"         : "MIT"
-
-, "version"         : "0.2.2"
-, "engines"         : {"node": ">=0.4.0"}
-, "main"            : "./lib/websocket/driver"
-, "devDependencies" : {"jstest": ""}
-
-, "scripts"         : {"test": "jstest spec/runner.js"}
-
-, "repository"      : { "type"  : "git"
-                      , "url"   : "git://github.com/faye/websocket-driver-node.git"
-                      }
-
-, "bugs"            : "http://github.com/faye/websocket-driver-node/issues"
+{
+          "name": "faye-websocket",
+          "description": "Standards-compliant WebSocket server and client",
+          "homepage": "https://github.com/faye/faye-websocket-node",
+          "author": "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)",
+          "keywords": [
+                    "websocket",
+                    "eventsource"
+          ],
+          "license": "Apache-2.0",
+          "version": "0.11.4",
+          "engines": {
+                    "node": ">=0.8.0"
+          },
+          "files": [
+                    "lib"
+          ],
+          "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/faye-websocket-node.git"
+          },
+          "bugs": "https://github.com/faye/faye-websocket-node/issues"
 }
-

spec/echo_server.js

@@ -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;

spec/faye/websocket/client_spec.js

@@ -0,0 +1,275 @@
+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(status, headers, callback) {
+    this.assert( this._open )
+    this.assertEqual( status, this._ws.statusCode )
+    for (var name in headers)
+      this.assertEqual( headers[name], this._ws.headers[name.toLowerCase()] )
+    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(101, { "Upgrade": "websocket" })
+      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(100)
+      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")
+  }})
+}})

spec/proxy_server.js

@@ -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;

spec/runner.js

@@ -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')

spec/server.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDCTCCAfECFGK6xC8kSXk3aNAjEuRTAeHoO1BFMA0GCSqGSIb3DQEBCwUAMEEx
+CzAJBgNVBAYTAlVLMQ8wDQYDVQQIDAZMb25kb24xDTALBgNVBAoMBEZheWUxEjAQ
+BgNVBAMMCWxvY2FsaG9zdDAeFw0yMzA5MDcxNzU4NTVaFw0yNDA5MDYxNzU4NTVa
+MEExCzAJBgNVBAYTAlVLMQ8wDQYDVQQIDAZMb25kb24xDTALBgNVBAoMBEZheWUx
+EjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
+ggEBAMGREBi/onEuDpfFOi+6ugGeYTEV+n/KrYDWdT5FCFrL3Ab/kCpWCpwzv6A5
+lEPoqyf1Y0+cpcxwZm24fZV8uaaQ53xamzp7/6K+6IeNdI3Lq1J7gJx5wU5tdm2U
+jbWv7U0R+XX6MzWYqRFWuCNu2n9uvTl0AKDnyAWmRbhMKXriD5IWbPvMqgI/FnXh
+VnK7z+UHzLb214Q0VlfUs4U8oJjA5K7IEiMF2FkA3HPnxdvtjDNDCYyahumWLozP
+lbSo8Zlyr4xpp7yUv9TAhJozs+Y320cBpLlEeQoFIel+nOc7xgD2Wmu11ds0p/4j
+8qdFOv1h9d2DsLQ5ZFJxbXVNu0UCAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAaMQl
+AnLCKsdodSl6KV3joaGSSkY8WuD1Y76/bieArwRRqdSA4eGYcAHnsyEUqP2otgCj
++vS9h9jGMbLLjPindE+0jij9TpA9oNk8exUQSN5CNgBbrxWakDR6GmK7nWYD4/uh
+wcj7QuysExGqpvY1eXh8ki81a5g3if2wjSkprF0VEtulv/MB7eBqvyEZ2d6IuNUc
+IG3FmHcCRiGW0S+fPshmSN+OkUtMBJxHXRbr7TFy3Iz4vSDcq0XznVksNTavz5ve
+r4qWhPn0J3lfo9y5GBPCv7RWnxqnQWNM8dXPmS8Wh8hteSde8rtHkPuRDF/1VdER
+myxYuyLx/dhkxp57kw==
+-----END CERTIFICATE-----

spec/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDBkRAYv6JxLg6X
+xTovuroBnmExFfp/yq2A1nU+RQhay9wG/5AqVgqcM7+gOZRD6Ksn9WNPnKXMcGZt
+uH2VfLmmkOd8Wps6e/+ivuiHjXSNy6tSe4CcecFObXZtlI21r+1NEfl1+jM1mKkR
+Vrgjbtp/br05dACg58gFpkW4TCl64g+SFmz7zKoCPxZ14VZyu8/lB8y29teENFZX
+1LOFPKCYwOSuyBIjBdhZANxz58Xb7YwzQwmMmobpli6Mz5W0qPGZcq+Maae8lL/U
+wISaM7PmN9tHAaS5RHkKBSHpfpznO8YA9lprtdXbNKf+I/KnRTr9YfXdg7C0OWRS
+cW11TbtFAgMBAAECggEAB+Pxa4jYRtPRTXeBNTPf5DQAEz+pm+73nqJfWh/3RLg9
+ql1dk5Q5T3++hnoCZLhFzdWvbC3fBlPooP1dxSu156fNf+CzpjEqzQgKM4hdIXCV
+dcHKDtbZvegxZSsika7vte4PJLODxeIItke6LtuUdZBej0p+whBgs3ZBLk+Qe01M
+la73SCNi0Pjg8auyMRvncLqFvKE/KplemeCS30+AMoyhtLKQmrOo+Ub94N+tp8fR
+COtsmIJQX6uj1cg3Ikn23G5Kll66gt3kzNRGgNfkcygWmfPFE4WHBZXvOiLHhs7j
+FsAtA+vVODDyofmgT686LsEg70aM58SCXhX5DtsxYQKBgQDsejwS1Po4rrAqZj7j
+ny9lnZuCGo/P9CnDzcNnsJAxVBh5knKkVNC8r6ubMBwrf3lq+I7RbI3AAS/vxcON
+Rhj39cvUMSv5/fkMAGDIHL2yW8LBufYbyyQm2ChFuas51560aAsCrFN1gB0I8A1M
+eRkNFcoPzeS8GHkjhE8P4EyRkQKBgQDRi/EQ+nA5nfLggl+G67ACiMe2i3FZs1mP
+4WWA7fvfty/L6WBGuxCU1v9hMBj63LhHrlKF2MOHbKNuBwGYjeNgqaBWw+ahwdPX
+N06x/FhR1q8AiVH26S5nRAaoh5ode5H2dx17e0QteEFe29nFoSkT47sAOxRfkWjx
+QqBdBgH0dQKBgG54zAegJyTDttiX21lKzEGUV0l4Tya+0aP/RAH0oefpeWWR3KyY
+UstS5cAhwYcwjfBDHbUIGVBRPautn6Un0hJEaWw/bGPlGatZodzaUGQ6KcmGrkpd
+pA3hfS7VhgAHksSEtmARUQvbRbUfL5dCG0nZnAO2E90rMaw96xFnn12BAoGAeX9J
+jA2Zal7hhzkwiDs5t451NauOUnNCF8GZp/LU2rcNWI79SqWGDLbIJiLMKRA3LSCv
+KnovjOL5s38OdtS2JMLVe9lkbR/EY4Hm+B4XW4Q9vfLg+mfjhu6Tab4OJtASJrST
+/JfRRQf35zdUAlnaRnUBZTXcLzlRfqmh763fDk0CgYEAuBYr1xVFrdwn/YSHn5m5
+amexAv821RCWvuZMUPfnSHGoxOGGI0DEOocznIuExNoRVrsKMeuskbpoVuo/b4S5
+BVjzP+lNlkDEJVcYLnlX3t4elA9IYj7RqwZTmT8BrVEoH3AFns3O2jDzZw47I7dK
+bCewTY0p5+4zEWlgsxX/Mtk=
+-----END PRIVATE KEY-----

spec/websocket/driver/client_spec.js

@@ -1,231 +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("driver", function() {
-    if (this._driver) return this._driver
-    this._driver = new Client("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] })
-    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 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 )
-      }})
-    }})
-  }})
-}})
-

spec/websocket/driver/draft75_examples.js

@@ -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() )
-        }})
-      }})
-    }})
-  }})
-}})
-

spec/websocket/driver/draft75_spec.js

@@ -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")
-}})
-

spec/websocket/driver/draft76_spec.js

@@ -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()
-      }})
-    }})
-  }})
-}})
-

spec/websocket/driver/hybi_spec.js

@@ -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, 0x20, 0x00, 0x00, 0x00, 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() )
-      }})
-    }})
-  }})
-}})
-