Bump version to 0.2.1.

Messages should be queued when the driver is in the 'pre-connecting' state, as the client is initially.
Expose the isSecureRequest() method.
2013-05-17 11:51:34 +01:00 · 2013-05-17 11:48:36 +01:00 · 2013-05-17 11:47:56 +01:00 · 2013-05-12 15:09:18 +01:00 · 2013-05-12 15:08:17 +01:00 · 2013-05-12 14:44:17 +01:00
45 changed files with 2586 additions and 1885 deletions
@@ -1,4 +1,6 @@
 .git
 .gitignore
-.redcar
+.npmignore
+.travis.yml
 node_modules
+spec
@@ -1,5 +1,8 @@
 language: node_js
+
 node_js:
-  - 0.4
-  - 0.6
-  - 0.7
+  - "0.6"
+  - "0.8"
+  - "0.10"
+  - "0.11"
+
@@ -0,0 +1,14 @@
+### 0.2.1 / 2013-05-17
+
+* Export the isSecureRequest() method since faye-websocket relies on it
+* Queue sent messages in the client's initial state
+
+### 0.2.0 / 2013-05-12
+
+* Add API for setting and reading headers
+* Add Driver.server() method for getting a driver for TCP servers
+
+### 0.1.0 / 2013-05-04
+
+* First stable release
+
@@ -1,40 +0,0 @@
-=== 0.4.0 / 2012-02-13
-
-* Add ping() method to server-side WebSocket and EventSource
-* Buffer send() calls until the draft-76 handshake is complete
-* Fix HTTPS problems on Node 0.7
-
-
-=== 0.3.1 / 2012-01-16
-
-* Call setNoDelay(true) on net.Socket objects to reduce latency
-
-
-=== 0.3.0 / 2012-01-13
-
-* Add support for EventSource connections
-
-
-=== 0.2.0 / 2011-12-21
-
-* Add support for Sec-WebSocket-Protocol negotiation
-* Support hixie-76 close frames and 75/76 ignored segments
-* Improve performance of HyBi parsing/framing functions
-* Decouple parsers from TCP and reduce write volume
-
-
-=== 0.1.2 / 2011-12-05
-
-* Detect closed sockets on the server side when TCP connection breaks
-* Make hixie-76 sockets work through HAProxy
-
-
-=== 0.1.1 / 2011-11-30
-
-* Fix addEventListener() interface methods
-
-
-=== 0.1.0 / 2011-11-27
-
-* Initial release, based on WebSocket components from Faye
-
@@ -1,248 +0,0 @@
-# faye-websocket
-
-* Travis CI build: [<img src="https://secure.travis-ci.org/faye/faye-websocket-node.png" />](http://travis-ci.org/faye/faye-websocket-node)
-* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/), [client](http://faye.jcoglan.com/autobahn/clients/)
-
-This is a robust, general-purpose WebSocket implementation extracted from the
-[Faye](http://faye.jcoglan.com) project. It provides classes for easily building
-WebSocket servers and clients in Node. It does not provide a server itself, but
-rather makes it easy to handle WebSocket connections within an existing
-[Node](http://nodejs.org/) application. It does not provide any abstraction
-other than the standard [WebSocket API](http://dev.w3.org/html5/websockets/).
-
-It also provides an abstraction for handling [EventSource](http://dev.w3.org/html5/eventsource/)
-connections, which are one-way connections that allow the server to push data to
-the client. They are based on streaming HTTP responses and can be easier to
-access via proxies than WebSockets.
-
-The server-side socket can process [draft-75](http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75),
-[draft-76](http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76),
-[hybi-07](http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07)
-and later versions of the protocol. It selects protocol versions automatically,
-supports both `text` and `binary` messages, and transparently handles `ping`,
-`pong`, `close` and fragmented messages.
-
-
-## Handling WebSocket connections in Node
-
-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 WebSocket = require('faye-websocket'),
-    http      = require('http');
-
-var server = http.createServer();
-
-server.addListener('upgrade', function(request, socket, head) {
-  var ws = new WebSocket(request, socket, head);
-  
-  ws.onmessage = function(event) {
-    ws.send(event.data);
-  };
-  
-  ws.onclose = function(event) {
-    console.log('close', event.code, event.reason);
-    ws = null;
-  };
-});
-
-server.listen(8000);
-```
-
-Note that under certain circumstances (notably a draft-76 client connecting
-through an HTTP proxy), the WebSocket handshake will not be complete after you
-call `new WebSocket()` because the server will not have received the entire
-handshake from the client yet. In this case, calls to `ws.send()` will buffer
-the message in memory until the handshake is complete, at which point any
-buffered messages will be sent to the client.
-
-If you need to detect when the WebSocket handshake is complete, you can use the
-`onopen` event.
-
-If the connection's protocol version supports it, you can call `ws.ping()` to
-send a ping message and wait for the client's response. This method takes a
-message string, and an optional callback that fires when a matching pong message
-is received. It returns `true` iff a ping message was sent. If the client does
-not support ping/pong, this method sends no data and returns `false`.
-
-```js
-ws.ping('Mic check, one, two', function() {
-  // fires when pong is received
-});
-```
-
-
-## Using the WebSocket client
-
-The client supports both the plain-text `ws` protocol and the encrypted `wss`
-protocol, and has exactly the same interface as a socket you would use in a web
-browser. On the wire it identifies itself as hybi-13.
-
-```js
-var WebSocket = require('faye-websocket'),
-    ws        = new WebSocket.Client('ws://www.example.com/');
-
-ws.onopen = function(event) {
-  console.log('open');
-  ws.send('Hello, world!');
-};
-
-ws.onmessage = function(event) {
-  console.log('message', event.data);
-};
-
-ws.onclose = function(event) {
-  console.log('close', event.code, event.reason);
-  ws = null;
-};
-```
-
-
-## Subprotocol negotiation
-
-The WebSocket protocol allows peers to select and identify the application
-protocol to use over the connection. On the client side, you can set which
-protocols the client accepts by passing a list of protocol names when you
-construct the socket:
-
-```js
-var ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
-```
-
-On the server side, you can likewise pass in the list of protocols the server
-supports after the other constructor arguments:
-
-```js
-var ws = new WebSocket(request, socket, head, ['irc', 'amqp']);
-```
-
-If the client and server agree on a protocol, both the client- and server-side
-socket objects expose the selected protocol through the `ws.protocol` property.
-If they cannot agree on a protocol to use, the client closes the connection.
-
-
-## WebSocket API
-
-The WebSocket API consists of several event handlers and a method for sending
-messages.
-
-* <b><tt>onopen</tt></b> fires when the socket connection is established. Event
-  has no attributes.
-* <b><tt>onerror</tt></b> fires when the connection attempt fails. Event has no
-  attributes.
-* <b><tt>onmessage</tt></b> fires when the socket receives a message. Event has
-  one attribute, <b><tt>data</tt></b>, which is either a `String` (for text
-  frames) or a `Buffer` (for binary frames).
-* <b><tt>onclose</tt></b> fires when either the client or the server closes the
-  connection. Event has two optional attributes, <b><tt>code</tt></b> and
-  <b><tt>reason</tt></b>, that expose the status code and message sent by the
-  peer that closed the connection.
-* <b><tt>send(message)</tt></b> accepts either a `String` or a `Buffer` and
-  sends a text or binary message over the connection to the other peer.
-* <b><tt>close(code, reason)</tt></b> closes the connection, sending the given
-  status code and reason text, both of which are optional.
-* <b><tt>protocol</tt></b> 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.addListener('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.onclose = function() {
-      clearInterval(loop);
-      es = null;
-    };
-  
-  } else {
-    // Normal HTTP request
-    response.writeHead(200, {'Content-Type': 'text/plain'});
-    response.write('Hello');
-    response.end();
-  }
-});
-
-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:
-
-* <b><tt>url</tt></b> is a string containing the URL the client used to create
-  the EventSource.
-* <b><tt>lastEventId</tt></b> is a string containing the last event ID
-  received by the client. You can use this when the client reconnects after a
-  dropped connection to determine which messages need resending.
-
-When you initialize an EventSource with ` new EventSource()`, you can pass
-configuration options after the `response` parameter. Available options are:
-
-* <b><tt>retry</tt></b> is a number that tells the client how long (in seconds)
-  it should wait after a dropped connection before attempting to reconnect.
-* <b><tt>ping</tt></b> is a number that tells the server how often (in seconds)
-  to send 'ping' packets to the client to keep the connection open, to defeat
-  timeouts set by proxies. The client will ignore these messages.
-
-For example, this creates a connection that pings every 15 seconds and is
-retryable every 10 seconds if the connection is broken:
-
-```js
-var es = new EventSource(request, response, {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.
-
-
-## License
-
-(The MIT License)
-
-Copyright (c) 2009-2012 James Coglan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the 'Software'), to deal in
-the Software without restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
@@ -0,0 +1,308 @@
+# websocket-driver [![Build Status](https://travis-ci.org/faye/websocket-driver-node.png)](https://travis-ci.org/faye/websocket-driver-node)
+
+This module provides a complete implementation of the WebSocket protocols that
+can be hooked up to any I/O stream. It aims to simplify things by decoupling
+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.
+
+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.
+
+
+## Installation
+
+```
+$ npm install websocket-driver
+```
+
+
+## Usage
+
+This module provides protocol drivers that have the same interface on the
+server and on the client. A WebSocket driver is an object with two duplex
+streams attached; one for incoming/outgoing messages and one for managing the
+wire protocol over an I/O stream. The full API is described below.
+
+
+### Server-side with HTTP
+
+A Node webserver emits a special event for 'upgrade' requests, and this is
+where you should handle WebSockets. You first check whether the request is a
+WebSocket, and if so you can create a driver and attach the request's I/O
+stream to it.
+
+```js
+var http = require('http'),
+    websocket = require('websocket-driver');
+
+var server = http.createServer();
+
+server.on('upgrade', function(request, socket, body) {
+  if (!websocket.isWebSocket(request)) return;
+
+  var driver = websocket.http(request);
+
+  driver.io.write(body);
+  socket.pipe(driver.io);
+  driver.io.pipe(socket);
+
+  driver.messages.on('data', function(message) {
+    console.log('Got a message', message);
+  });
+
+  driver.start();
+};
+```
+
+Note the line `driver.io.write(body)` - you must pass the `body` buffer to the
+socket driver in order to make certain versions of the protocol work.
+
+
+### Server-side with TCP
+
+You can also handle WebSocket connections in a bare TCP server, if you're not
+using an HTTP server and don't want to implement HTTP parsing yourself.
+
+The driver will emit a `connect` event when a request is received, and at this
+point you can detect whether it's a WebSocket and handle it as such. Here's an
+example using the Node `net` module:
+
+```js
+var 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);
+  driver.io.pipe(connection);
+
+  driver.messages.pipe(driver.messages);
+});
+
+server.listen(4180);
+```
+
+In the `connect` event, the driver gains several properties to describe the
+request, similar to a Node request object, such as `method`, `url` and
+`headers`. However you should remember it's not a real request object; you
+cannot write data to it, it only tells you what request data we parsed from the
+input.
+
+If the request has a body, it will be in the `driver.body` buffer, but only as
+much of the body as has been piped into the driver when the `connect` event
+fires.
+
+
+### Client-side
+
+Similarly, to implement a WebSocket client you just need to make a driver by
+passing in a URL. After this you use the driver API as described below to
+process incoming data and send outgoing data.
+
+
+```js
+var net = require('net'),
+    websocket = require('websocket-driver');
+
+var driver = websocket.client('ws://www.example.com/socket'),
+    tcp = net.createConnection(80, 'www.example.com');
+
+tcp.pipe(driver.io);
+driver.io.pipe(tcp);
+
+driver.messages.on('data', function(message) {
+  console.log('Got a message', message);
+});
+
+tcp.on('connect', function() {
+  driver.start();
+});
+```
+
+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
+
+
+### Driver API
+
+Drivers are created using one of the following methods:
+
+```js
+driver = websocket.http(request, options)
+driver = websocket.server(options)
+driver = websocket.client(url, options)
+```
+
+The `http` method returns a driver chosen using the headers from a Node HTTP
+request object. The `server` method returns a driver that will parse an HTTP
+request and then decide which driver to use for it using the `http` method. The
+`client` method always returns a driver for the RFC version of the protocol
+with masking enabled on outgoing frames.
+
+The `options` argument is optional, and is an object. It may contain the
+following fields:
+
+* `protocols` - an array of strings representing acceptable subprotocols for
+  use over the socket. The driver will negotiate one of these to use via the
+  `Sec-WebSocket-Protocol` header if supported by the other peer.
+
+A driver has two duplex streams attached to it:
+
+* <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.
+
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2010-2013 James Coglan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the 'Software'), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
@@ -1,40 +0,0 @@
-var WebSocket = require('../lib/faye/websocket');
-
-var host  = 'ws://localhost:9001',
-    agent = 'Faye (Node ' + process.version + ')',
-    cases = 0,
-    skip  = [];
-
-var socket = new WebSocket.Client(host + '/getCaseCount');
-
-socket.onmessage = function(event) {
-  console.log('Total cases to run: ' + event.data);
-  cases = parseInt(event.data);
-};
-
-socket.onclose = function() {
-  var runCase = function(n) {
-    if (n > cases) {
-      socket = new WebSocket.Client(host + '/updateReports?agent=' + encodeURIComponent(agent));
-      socket.onclose = process.exit
-      
-    } else if (skip.indexOf(n) >= 0) {
-      runCase(n + 1);
-      
-    } else {
-      console.log('Running test case #' + n + ' ...');
-      socket = new WebSocket.Client(host + '/runCase?case=' + n + '&agent=' + encodeURIComponent(agent));
-      
-      socket.onmessage = function(event) {
-        socket.send(event.data);
-      };
-      
-      socket.onclose = function() {
-        runCase(n + 1);
-      };
-    }
-  };
-  
-  runCase(1);
-};
-
@@ -1,22 +0,0 @@
-var WebSocket = require('../lib/faye/websocket'),
-    port      = process.argv[2] || 7000,
-    secure    = process.argv[3] === 'ssl',
-    scheme    = secure ? 'wss' : 'ws',
-    ws        = new WebSocket.Client(scheme + '://localhost:' + port + '/');
-
-console.log('Connecting to ' + ws.url);
-
-ws.onopen = function(event) {
-  console.log('open');
-  ws.send('Hello, WebSocket!');
-};
-
-ws.onmessage = function(event) {
-  console.log('message', event.data);
-  // ws.close(1002, 'Going away');
-};
-
-ws.onclose = function(event) {
-  console.log('close', event.code, event.reason);
-};
-
@@ -1,21 +0,0 @@
-defaults
-   mode http
-   timeout client  5s
-   timeout connect 5s
-   timeout server  5s
-
-frontend all 0.0.0.0:3000
-   mode http
-   timeout client 120s
-
-   option forwardfor
-   option http-server-close
-   option http-pretend-keepalive
-
-   default_backend sockets
-
-backend sockets
-   balance uri depth 2
-   timeout server  120s
-   server socket1 127.0.0.1:7000
-
@@ -1,70 +0,0 @@
-var WebSocket = require('../lib/faye/websocket'),
-    fs        = require('fs'),
-    http      = require('http'),
-    https     = require('https');
-
-var port   = process.argv[2] || 7000,
-    secure = process.argv[3] === 'ssl';
-
-var upgradeHandler = function(request, socket, head) {
-  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], {ping: 5});
-  console.log('open', ws.url, ws.version, ws.protocol);
-  
-  ws.onmessage = function(event) {
-    ws.send(event.data);
-  };
-  
-  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);
-  
-  es.send('Welcome!\n\nThis is an EventSource server.');
-  
-  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.addListener('request', requestHandler);
-server.addListener('upgrade', upgradeHandler);
-server.listen(port);
-
@@ -1,39 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
-    <title>EventSource test</title>
-  </head>
-  <body>
-    
-    <h1>EventSource test</h1>
-    <ul></ul>
-    
-    <script type="text/javascript">
-      var logger = document.getElementsByTagName('ul')[0],
-          socket = new EventSource('/');
-      
-      var log = function(text) {
-        logger.innerHTML += '<li>' + text + '</li>';
-      };
-      
-      socket.onopen = function() {
-        log('OPEN');
-      };
-      
-      socket.onmessage = function(event) {
-        log('MESSAGE: ' + event.data);
-      };
-      
-      socket.addEventListener('update', function(event) {
-        log('UPDATE(' + event.lastEventId + '): ' + event.data);
-      });
-      
-      socket.onerror = function(event) {
-        log('ERROR: ' + event.message);
-      };
-    </script>
-    
-  </body>
-</html>
-
@@ -0,0 +1,21 @@
+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]);
+
@@ -1,44 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
-    <title>WebSocket test</title>
-  </head>
-  <body>
-    
-    <h1>WebSocket test</h1>
-    <ul></ul>
-    
-    <script type="text/javascript">
-      var logger = document.getElementsByTagName('ul')[0],
-          Socket = window.MozWebSocket || window.WebSocket,
-          protos = ['foo', 'bar', 'xmpp'],
-          socket = new Socket('ws://' + location.hostname + ':' + location.port + '/', protos),
-          index  = 0;
-      
-      var log = function(text) {
-        logger.innerHTML += '<li>' + text + '</li>';
-      };
-      
-      socket.addEventListener('open', function() {
-        log('OPEN: ' + socket.protocol);
-        socket.send('Hello, world');
-      });
-      
-      socket.onerror = function(event) {
-        log('ERROR: ' + event.message);
-      };
-      
-      socket.onmessage = function(event) {
-        log('MESSAGE: ' + event.data);
-        setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
-      };
-      
-      socket.onclose = function(event) {
-        log('CLOSE: ' + event.code + ', ' + event.reason);
-      };
-    </script>
-    
-  </body>
-</html>
-
@@ -1,104 +0,0 @@
-var API   = require('./websocket/api'),
-    Event = require('./websocket/api/event');
-
-var isSecureConnection = function(request) {
-  if (request.headers['x-forwarded-proto']) {
-    return request.headers['x-forwarded-proto'] === 'https';
-  } else {
-    return (request.connection && request.connection.authorized !== undefined) ||
-           (request.socket && request.socket.secure);
-  }
-};
-
-var EventSource = function(request, response, options) {
-  options = options || {};
-  
-  this._request  = request;
-  this._response = response;
-  this._stream   = response.socket;
-  this._ping     = options.ping  || this.DEFAULT_PING;
-  this._retry    = options.retry || this.DEFAULT_RETRY;
-  
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
-  
-  var scheme = isSecureConnection(request) ? 'https:' : 'http:';
-  this.url = scheme + '//' + request.headers.host + request.url;
-  
-  this.lastEventId = request.headers['last-event-id'] || '';
-  
-  var self = this;
-  this.readyState = API.CONNECTING;
-  this._sendBuffer = [];
-  process.nextTick(function() { self._open() });
-  
-  var handshake = 'HTTP/1.1 200 OK\r\n' +
-                  'Content-Type: text/event-stream\r\n' +
-                  'Cache-Control: no-cache, no-store\r\n' +
-                  '\r\n\r\n' +
-                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
-  
-  try {
-    this._stream.write(handshake, 'utf8');
-  } catch (e) {}
-  
-  this.readyState = API.OPEN;
-  
-  if (this._ping)
-    this._pingLoop = setInterval(function() { self.ping() }, this._ping * 1000);
-  
-  ['close', 'end', 'error'].forEach(function(event) {
-    self._stream.addListener(event, function() { self.close() });
-  });
-};
-
-EventSource.isEventSource = function(request) {
-  var accept = (request.headers.accept || '').split(/\s*,\s*/);
-  return accept.indexOf('text/event-stream') >= 0;
-};
-
-var instance = {
-  DEFAULT_PING:   10,
-  DEFAULT_RETRY:  5,
-  
-  send: function(message, options) {
-    message = 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';
-    
-    try {
-      this._stream.write(frame, 'utf8');
-    } catch (e) {}
-  },
-  
-  ping: function() {
-    try {
-      this._stream.write(':\r\n\r\n', 'utf8');
-      return true;
-    } catch (e) {
-      return false;
-    }
-  },
-  
-  close: function() {
-    if (this.readyState === API.CLOSING || this.readyState === API.CLOSED)
-      return;
-    
-    this.readyState = API.CLOSED;
-    clearInterval(this._pingLoop);
-    this._response.end();
-    
-    var event = new Event('close');
-    event.initEvent('close', false, false);
-    this.dispatchEvent(event);
-  }
-};
-
-for (var key in API) EventSource.prototype[key] = API[key];
-for (var key in instance) EventSource.prototype[key] = instance[key];
-module.exports = EventSource;
-
@@ -1,91 +0,0 @@
-// API and protocol references:
-// 
-// * http://dev.w3.org/html5/websockets/
-// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
-// * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
-// * 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 Draft75Parser = require('./websocket/draft75_parser'),
-    Draft76Parser = require('./websocket/draft76_parser'),
-    HybiParser    = require('./websocket/hybi_parser'),
-    API           = require('./websocket/api'),
-    Event         = require('./websocket/api/event');
-
-var getParser = function(request) {
-  var headers = request.headers;
-  return headers['sec-websocket-version']
-       ? HybiParser
-       : (headers['sec-websocket-key1'] && headers['sec-websocket-key2'])
-       ? Draft76Parser
-       : Draft75Parser;
-};
-
-var isSecureConnection = function(request) {
-  if (request.headers['x-forwarded-proto']) {
-    return request.headers['x-forwarded-proto'] === 'https';
-  } else {
-    return (request.connection && request.connection.authorized !== undefined) ||
-           (request.socket && request.socket.secure);
-  }
-};
-
-var WebSocket = function(request, socket, head, supportedProtos, options) {
-  this.request = request;
-  this._stream = request.socket;
-  this._ping   = options && options.ping;
-  this._pingId = 0;
-  
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
-  
-  var scheme = isSecureConnection(request) ? 'wss:' : 'ws:';
-  this.url = scheme + '//' + request.headers.host + request.url;
-  this.readyState = API.CONNECTING;
-  this.bufferedAmount = 0;
-  
-  var Parser = getParser(request);
-  this._parser = new Parser(this, {protocols: supportedProtos});
-  
-  var self = this;
-  this._sendBuffer = [];
-  process.nextTick(function() { self._open() });
-  
-  var handshake = this._parser.handshakeResponse(head);
-  try { this._stream.write(handshake, 'binary') } catch (e) {}
-  
-  if (this._parser.isOpen()) this.readyState = API.OPEN;
-  
-  if (this._ping)
-    this._pingLoop = setInterval(function() {
-      self._pingId += 1;
-      self.ping(self._pingId.toString());
-    }, this._ping * 1000);
-  
-  this.protocol = this._parser.protocol || '';
-  this.version = this._parser.getVersion();
-  
-  this._stream.addListener('data', function(data) {
-    var response = self._parser.parse(data);
-    if (!response) return;
-    try { self._stream.write(response, 'binary') } catch (e) {}
-    self._open();
-  });
-  ['close', 'end', 'error'].forEach(function(event) {
-    self._stream.addListener(event, function() { self.close(1006, '', false) });
-  });
-};
-
-WebSocket.prototype.ping = function(message, callback, context) {
-  if (!this._parser.ping) return false;
-  return this._parser.ping(message, callback, context);
-};
-
-for (var key in API) WebSocket.prototype[key] = API[key];
-
-WebSocket.WebSocket   = WebSocket;
-WebSocket.Client      = require('./websocket/client');
-WebSocket.EventSource = require('./eventsource');
-module.exports        = WebSocket;
-
@@ -1,83 +0,0 @@
-var EventTarget = require('./api/event_target'),
-    Event       = require('./api/event');
-
-var API = {
-  CONNECTING:   0,
-  OPEN:         1,
-  CLOSING:      2,
-  CLOSED:       3,
-  
-  _open: function() {
-    if (this._parser && !this._parser.isOpen()) return;
-    this.readyState = API.OPEN;
-    
-    var buffer = this._sendBuffer || [],
-        message;
-    
-    while (message = buffer.shift())
-      this.send.apply(this, message);
-    
-    var event = new Event('open');
-    event.initEvent('open', false, false);
-    this.dispatchEvent(event);
-  },
-  
-  receive: function(data) {
-    if (this.readyState !== API.OPEN) return false;
-    var event = new Event('message');
-    event.initEvent('message', false, false);
-    event.data = data;
-    this.dispatchEvent(event);
-  },
-  
-  send: function(data, type, errorType) {
-    if (this.readyState === API.CONNECTING) {
-      if (this._sendBuffer) {
-        this._sendBuffer.push(arguments);
-        return true;
-      } else {
-        throw new Error('Cannot call send(), socket is not open yet');
-      }
-    }
-    
-    if (this.readyState === API.CLOSED)
-      return false;
-    
-    var frame = this._parser.frame(data, type, errorType);
-    try {
-      this._stream.write(frame, 'binary');
-      return true;
-    } catch (e) {
-      return false;
-    }
-  },
-  
-  close: function(code, reason, ack) {
-    if (this.readyState === API.CLOSING ||
-        this.readyState === API.CLOSED) return;
-    
-    this.readyState = API.CLOSING;
-    
-    var close = function() {
-      this.readyState = API.CLOSED;
-      if (this._pingLoop) clearInterval(this._pingLoop);
-      this._stream.end();
-      var event = new Event('close', {code: code || 1000, reason: reason || ''});
-      event.initEvent('close', false, false);
-      this.dispatchEvent(event);
-    };
-    
-    if (ack !== false) {
-      if (this._parser.close) this._parser.close(code, reason, close, this);
-      else close.call(this);
-    } else {
-      if (this._parser.close) this._parser.close(code, reason);
-      close.call(this);
-    }
-  }
-};
-
-for (var key in EventTarget) API[key] = EventTarget[key];
-
-module.exports = API;
-
@@ -1,21 +0,0 @@
-var Event = function(eventType, options) {
-  this.type = eventType;
-  for (var key in options)
-    this[key] = options[key];
-};
-    
-Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
-  this.type       = eventType;
-  this.bubbles    = canBubble;
-  this.cancelable = cancelable;
-};
-
-Event.prototype.stopPropagation = function() {};
-Event.prototype.preventDefault  = function() {};
-    
-Event.CAPTURING_PHASE = 1;
-Event.AT_TARGET       = 2;
-Event.BUBBLING_PHASE  = 3;
-
-module.exports = Event;
-
@@ -1,47 +0,0 @@
-var Event = require('./event');
-
-var EventTarget = {
-  onopen:     null,
-  onmessage:  null,
-  onerror:    null,
-  onclose:    null,
-  
-  addEventListener: function(eventType, listener, useCapture) {
-    this._listeners = this._listeners || {};
-    var list = this._listeners[eventType] = this._listeners[eventType] || [];
-    list.push(listener);
-  },
-  
-  removeEventListener: function(eventType, listener, useCapture) {
-    if (!this._listeners || !this._listeners[eventType]) return;
-    
-    if (!listener) {
-      delete this._listeners[eventType];
-      return;
-    }
-    var list = this._listeners[eventType],
-        i    = list.length;
-    
-    while (i--) {
-      if (listener !== list[i]) continue;
-      list.splice(i,1);
-    }
-  },
-  
-  dispatchEvent: function(event) {
-    event.target = event.currentTarget = this;
-    event.eventPhase = Event.AT_TARGET;
-    
-    if (this['on' + event.type])
-      this['on' + event.type](event);
-    
-    if (!this._listeners || !this._listeners[event.type]) return;
-    
-    this._listeners[event.type].forEach(function(listener) {
-      listener(event);
-    }, this);
-  }
-};
-
-module.exports = EventTarget;
-
@@ -1,83 +0,0 @@
-var net = require('net'),
-    tls = require('tls');
-
-var HybiParser = require('./hybi_parser'),
-    API        = require('./api'),
-    Event      = require('./api/event');
-
-var Client = function(url, protocols) {
-  this.url  = url;
-  this._uri = require('url').parse(url);
-  
-  this.protocol = '';
-  this.readyState = API.CONNECTING;
-  this.bufferedAmount = 0;
-  
-  var secure     = (this._uri.protocol === 'wss:'),
-      self       = this,
-      onConnect  = function() { self._onConnect() },
-      
-      connection = secure
-                 ? tls.connect(this._uri.port || 443, this._uri.hostname, {}, onConnect)
-                 : net.createConnection(this._uri.port || 80, this._uri.hostname);
-  
-  this._parser = new HybiParser(this, {masking: true, protocols: protocols});
-  this._stream = connection;
-  
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
-  
-  if (!secure) connection.addListener('connect', onConnect);
-  
-  connection.addListener('data', function(data) {
-    self._onData(data);
-  });
-  ['close', 'end', 'error'].forEach(function(event) {
-    connection.addListener(event, function() { self.close(1006, '', false) });
-  });
-};
-  
-Client.prototype._onConnect = function() {
-  this._handshake = this._parser.createHandshake(this._uri, this._stream);
-  this._message = [];
-  try {
-    this._stream.write(this._handshake.requestData(), 'binary');
-  } catch (e) {}
-};
-
-Client.prototype._onData = function(data) {
-  switch (this.readyState) {
-    case API.CONNECTING:
-      var bytes = this._handshake.parse(data);
-      for (var i = 0, n = bytes.length; i < n; i++)
-        this._message.push(bytes[i]);
-      
-      if (!this._handshake.isComplete()) return;
-      
-      if (this._handshake.isValid()) {
-        this.protocol = this._handshake.protocol || '';
-        this.readyState = API.OPEN;
-        var event = new Event('open');
-        event.initEvent('open', false, false);
-        this.dispatchEvent(event);
-        
-        this._parser.parse(this._message);
-        
-      } else {
-        this.readyState = API.CLOSED;
-        var event = new Event('close', {code: 1006, reason: ''});
-        event.initEvent('close', false, false);
-        this.dispatchEvent(event);
-      }
-      break;
-      
-    case API.OPEN:
-    case API.CLOSING:
-      this._parser.parse(data);
-  }
-};
-
-for (var key in API) Client.prototype[key] = API[key];
-
-module.exports = Client;
-
@@ -1,99 +0,0 @@
-var crypto        = require('crypto'),
-    Draft75Parser = require('./draft75_parser'),
-    Draft76Parser = function() { Draft75Parser.apply(this, arguments) };
-
-var bridge = function() {};
-bridge.prototype = Draft75Parser.prototype;
-Draft76Parser.prototype = new bridge();
-
-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;
-};
-
-Draft76Parser.prototype.getVersion = function() {
-  return 'hixie-76';
-};
-  
-Draft76Parser.prototype.handshakeResponse = function(head) {
-  var request = this._socket.request, tmp;
-  
-  var response = new Buffer('HTTP/1.1 101 Web Socket Protocol Handshake\r\n' +
-                            'Upgrade: WebSocket\r\n' +
-                            'Connection: Upgrade\r\n' +
-                            'Sec-WebSocket-Origin: ' + request.headers.origin + '\r\n' +
-                            'Sec-WebSocket-Location: ' + this._socket.url + '\r\n\r\n',
-                            'binary');
-  
-  var signature = this.handshakeSignature(head);
-  if (signature) {
-    tmp = new Buffer(response.length + signature.length);
-    response.copy(tmp, 0);
-    signature.copy(tmp, response.length);
-    response = tmp;
-  }
-  
-  return response;
-};
-
-Draft76Parser.prototype.isOpen = function() {
-  return !!this._handshakeComplete;
-};
-
-Draft76Parser.prototype.handshakeSignature = function(head) {
-  if (head.length === 0) return null;
-  
-  var request = this._socket.request,
-      
-      key1    = request.headers['sec-websocket-key1'],
-      value1  = numberFromKey(key1) / spacesInKey(key1),
-      
-      key2    = request.headers['sec-websocket-key2'],
-      value2  = numberFromKey(key2) / spacesInKey(key2),
-      
-      MD5     = crypto.createHash('md5');
-  
-  MD5.update(bigEndian(value1));
-  MD5.update(bigEndian(value2));
-  MD5.update(head.toString('binary'));
-  
-  this._handshakeComplete = true;
-  return new Buffer(MD5.digest('binary'), 'binary');
-};
-
-Draft76Parser.prototype.parse = function(data) {
-  if (this._handshakeComplete)
-    return Draft75Parser.prototype.parse.call(this, data);
-  
-  return this.handshakeSignature(data);
-};
-
-Draft76Parser.prototype._parseLeadingByte = function(data) {
-  if (data !== 0xFF)
-    return Draft75Parser.prototype._parseLeadingByte.call(this, data);
-  
-  this._closing = true;
-  this._length = 0;
-  this._stage = 1;
-};
-
-Draft76Parser.prototype.close = function(code, reason, callback, context) {
-  if (this._closed) return;
-  if (this._closing) this._socket.send(new Buffer([0xFF, 0x00]));
-  this._closed = true;
-  if (callback) callback.call(context);
-};
-
-module.exports = Draft76Parser;
-
@@ -1,91 +0,0 @@
-var crypto = require('crypto');
-
-var Handshake = function(uri, protocols) {
-  this._uri = uri;
-  this._protocols = protocols;
-  
-  var buffer = new Buffer(16), i = 16;
-  while (i--) buffer[i] = Math.floor(Math.random() * 256);
-  this._key = buffer.toString('base64');
-  
-  var SHA1 = crypto.createHash('sha1');
-  SHA1.update(this._key + Handshake.GUID);
-  this._accept = SHA1.digest('base64');
-  
-  var HTTPParser = process.binding('http_parser').HTTPParser,
-      parser     = new HTTPParser(HTTPParser.RESPONSE || 'response'),
-      current    = null,
-      self       = this;
-  
-  this._nodeVersion = HTTPParser.RESPONSE ? 6 : 4;
-  this._complete    = false;
-  this._headers     = {};
-  this._parser      = parser;
-  
-  parser.onHeaderField = function(b, start, length) {
-    current = b.toString('utf8', start, start + length);
-  };
-  parser.onHeaderValue = function(b, start, length) {
-    self._headers[current] = b.toString('utf8', start, start + length);
-  };
-  parser.onHeadersComplete = function(info) {
-    self._status = info.statusCode;
-    var headers = info.headers;
-    if (!headers) return;
-    for (var i = 0, n = headers.length; i < n; i += 2)
-      self._headers[headers[i]] = headers[i+1];
-  };
-  parser.onMessageComplete = function() {
-    self._complete = true;
-  };
-};
-
-Handshake.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
-    
-Handshake.prototype.requestData = function() {
-  var u = this._uri;
-  
-  var headers = [
-    'GET ' + u.pathname + (u.search || '') + ' HTTP/1.1',
-    'Host: ' + u.hostname + (u.port ? ':' + u.port : ''),
-    'Upgrade: websocket',
-    'Connection: Upgrade',
-    'Sec-WebSocket-Key: ' + this._key,
-    'Sec-WebSocket-Version: 13'
-  ];
-  
-  if (this._protocols)
-    headers.push('Sec-WebSocket-Protocol: ' + this._protocols.join(', '));
-  
-  return new Buffer(headers.concat('','').join('\r\n'), 'utf8');
-};
-
-Handshake.prototype.parse = function(data) {
-  var consumed = this._parser.execute(data, 0, data.length),
-      offset   = (this._nodeVersion < 6) ? 1 : 0;
-  
-  return (consumed === data.length) ? [] : data.slice(consumed + offset);
-};
-
-Handshake.prototype.isComplete = function() {
-  return this._complete;
-};
-
-Handshake.prototype.isValid = function() {
-  if (this._status !== 101) return false;
-  
-  var upgrade    = this._headers.Upgrade,
-      connection = this._headers.Connection,
-      protocol   = this._headers['Sec-WebSocket-Protocol'];
-  
-  this.protocol = this._protocols && this._protocols.indexOf(protocol) >= 0
-                ? protocol
-                : null;
-  
-  return upgrade && /^websocket$/i.test(upgrade) &&
-         connection && connection.split(/\s*,\s*/).indexOf('Upgrade') >= 0 &&
-         ((!this._protocols && !protocol) || this.protocol) &&
-         this._headers['Sec-WebSocket-Accept'] === this._accept;
-};
-
-module.exports = Handshake;
@@ -0,0 +1,44 @@
+// 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;
+
@@ -0,0 +1,121 @@
+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;
+
@@ -0,0 +1,109 @@
+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;
+
@@ -1,98 +1,109 @@
-var Draft75Parser = function(webSocket) {
-  this._socket = webSocket;
-  this._stage  = 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 = {
-  getVersion: function() {
-    return 'hixie-75';
-  },
-  
-  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._socket.request.headers.origin + '\r\n' +
-                      'WebSocket-Location: ' + this._socket.url + '\r\n\r\n',
-                      'utf8');
-  },
-  
-  isOpen: function() {
-    return true;
-  },
-  
  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._socket.close(null, null, false);
+            this.readyState = 3;
+            this.emit('close', new Base.CloseEvent(null, null));
          }
          else if ((0x80 & data) !== 0x80) {
            if (this._length === 0) {
-              this._socket.receive('');
              this._stage = 0;
            }
            else {
-              this._buffer = [];
+              this._skipped = 0;
              this._stage = 2;
            }
          }
          break;
-          
+
        case 2:
          if (data === 0xFF) {
-            message = new Buffer(this._buffer);
-            this._socket.receive(message.toString('utf8', 0, this._buffer.length));
+            message = new Buffer(this._buffer).toString('utf8', 0, this._buffer.length);
+            this.emit('message', new Base.MessageEvent(message));
            this._stage = 0;
          }
          else {
-            this._buffer.push(data);
-            if (this._length && this._buffer.length === this._length)
-              this._stage = 0;
+            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;
    }
-  },
-  
-  frame: function(data) {
-    if (Buffer.isBuffer(data)) return data;
-    
-    var buffer = new Buffer(data, 'utf8'),
-        frame  = new Buffer(buffer.length + 2);
-    
-    frame[0] = 0x00;
-    frame[buffer.length + 1] = 0xFF;
-    buffer.copy(frame, 1);
-    
-    return frame;
  }
 };

 for (var key in instance)
-  Draft75Parser.prototype[key] = instance[key];
+  Draft75.prototype[key] = instance[key];

-module.exports = Draft75Parser;
+module.exports = Draft75;

@@ -0,0 +1,109 @@
+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;
+
@@ -0,0 +1,30 @@
+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;
+
@@ -0,0 +1,57 @@
+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;
+
@@ -1,31 +1,48 @@
-var crypto    = require('crypto'),
-    Handshake = require('./hybi_parser/handshake'),
-    Reader    = require('./hybi_parser/stream_reader');
+var crypto   = require('crypto'),
+    util     = require('util'),
+    Base     = require('./base'),
+    Reader   = require('./hybi/stream_reader');

-var HybiParser = function(webSocket, options) {
+var Hybi = function(request, url, options) {
+  Base.apply(this, arguments);
  this._reset();
-  this._socket    = webSocket;
+
  this._reader    = new Reader();
  this._stage     = 0;
-  this._masking   = options && options.masking;
-  this._protocols = options && options.protocols;
-  
-  this._pingCallbacks = {};
-  
+  this._masking   = this._options.masking;
+  this._protocols = this._options.protocols || [];
+
  if (typeof this._protocols === 'string')
    this._protocols = this._protocols.split(/\s*,\s*/);
-};

-HybiParser.mask = function(payload, mask, offset) {
+  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,
@@ -35,7 +52,7 @@ var instance = {
  RSV3:   16,
  OPCODE: 15,
  LENGTH: 127,
-  
+
  OPCODES: {
    continuation: 0,
    text:         1,
@@ -44,69 +61,33 @@ var instance = {
    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
+    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
  },
-  
-  FRAGMENTED_OPCODES: [0,1,2],
-  OPENING_OPCODES:    [1,2],
-  
-  ERROR_CODES: [1000,1001,1002,1003,1007,1008,1009,1010],
-  
+
+  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})*$/,
-  
-  getVersion: function() {
-    var version = this._socket.request.headers['sec-websocket-version'];
-    return 'hybi-' + version;
-  },
-  
-  handshakeResponse: function() {
-    var secKey = this._socket.request.headers['sec-websocket-key'];
-    if (!secKey) return null;
-    
-    var SHA1 = crypto.createHash('sha1');
-    SHA1.update(secKey + Handshake.GUID);
-    
-    var accept    = SHA1.digest('base64'),
-        protos    = this._socket.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 && supported !== 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('','').join('\r\n'), 'utf8');
-  },
-  
-  isOpen: function() {
-    return true;
-  },
-  
-  createHandshake: function(uri) {
-    return new Handshake(uri, this._protocols);
-  },
-  
+
  parse: function(data) {
    this._reader.put(data);
    var buffer = true;
@@ -116,17 +97,17 @@ var instance = {
          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) {
@@ -134,7 +115,7 @@ var instance = {
            this._stage = 4;
          }
          break;
-          
+
        case 4:
          buffer = this._reader.read(this._length);
          if (buffer) {
@@ -146,57 +127,13 @@ var instance = {
      }
    }
  },
-  
-  _parseOpcode: function(data) {
-    var rsvs = [this.RSV1, this.RSV2, this.RSV3].filter(function(rsv) {
-      return (data & rsv) === rsv;
-    }, this);
-    
-    if (rsvs.length > 0) return this._socket.close(this.ERRORS.protocol_error, null, false);
-    
-    this._final   = (data & this.FIN) === this.FIN;
-    this._opcode  = (data & this.OPCODE);
-    this._mask    = [];
-    this._payload = [];
-    
-    var valid = false;
-    
-    for (var key in this.OPCODES) {
-      if (this.OPCODES[key] === this._opcode)
-        valid = true;
-    }
-    if (!valid) return this._socket.close(this.ERRORS.protocol_error, null, false);
-    
-    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && !this._final)
-      return this._socket.close(this.ERRORS.protocol_error, null, false);
-    
-    if (this._mode && this.OPENING_OPCODES.indexOf(this._opcode) >= 0)
-      return this._socket.close(this.ERRORS.protocol_error, null, false);
-    
-    this._stage = 1;
-  },
-  
-  _parseLength: function(data) {
-    this._masked = (data & this.MASK) === this.MASK;
-    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);
-    this._stage  = this._masked ? 3 : 4;
-  },
-  
+
  frame: function(data, type, code) {
-    if (this._closed) return null;
-    
+    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,
@@ -208,9 +145,9 @@ var instance = {
        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) {
@@ -228,109 +165,224 @@ var instance = {
      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);
-      HybiParser.mask(frame, mask, offset);
+      Hybi.mask(frame, mask, offset);
    }
-    
-    return frame;
+
+    this._write(frame);
+    return true;
  },
-  
-  ping: function(message, callback, context) {
+
+  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, context];
-    return this._socket.send(message, 'ping');
+    if (callback) this._pingCallbacks[message] = callback;
+    return this.frame(message, 'ping');
  },
-  
-  close: function(code, reason, callback, context) {
-    if (this._closed) return;
-    if (callback) this._closingCallback = [callback, context];
-    this._socket.send(reason || '', 'close', code || this.ERRORS.normal_closure);
-    this._closed = true;
+
+  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;
+    }
  },
-  
-  buffer: function(fragment) {
-    for (var i = 0, n = fragment.length; i < n; i++)
-      this._buffer.push(fragment[i]);
+
+  _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 = HybiParser.mask(this._payload, this._mask),
+    var payload = Hybi.mask(this._payload, this._mask),
        opcode  = this._opcode;
-    
+
    if (opcode === this.OPCODES.continuation) {
-      if (!this._mode) return this._socket.close(this.ERRORS.protocol_error, null, false);
-      this.buffer(payload);
+      if (!this._mode) return this._fail('protocol_error', 'Received unexpected continuation frame');
+      this._buffer(payload);
      if (this._final) {
-        var message = new Buffer(this._buffer);
+        var message = new Buffer(this.__buffer);
        if (this._mode === 'text') message = this._encode(message);
        this._reset();
-        if (message !== null) this._socket.receive(message);
-        else this._socket.close(this.ERRORS.encoding_error, null, false);
+        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._socket.receive(message);
-        else this._socket.close(this.ERRORS.encoding_error, null, false);
+        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);
+        this._buffer(payload);
      }
    }
    else if (opcode === this.OPCODES.binary) {
      if (this._final) {
-        this._socket.receive(payload);
+        this.emit('message', new Base.MessageEvent(payload));
      } else {
        this._mode = 'binary';
-        this.buffer(payload);
+        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 >= 3000 && code < 5000) &&
+          !(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._socket.close(code, (payload.length > 2) ? reason : null, false);
-      if (this._closingCallback)
-        this._closingCallback[0].call(this._closingCallback[1]);
+
+      this._shutdown(code, reason || '');
    }
    else if (opcode === this.OPCODES.ping) {
-      if (payload.length > 125) return this._socket.close(this.ERRORS.protocol_error, null, false);
-      this._socket.send(payload, 'pong');
+      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[0].call(callback[1]);
+      if (callback) callback()
    }
  },
-  
-  _reset: function() {
-    this._mode   = null;
-    this._buffer = [];
+
+  _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);
@@ -338,17 +390,17 @@ var instance = {
    } 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] << (8 * (n - 1 - i));
+      number += bytes[i] * this.TWO_POWERS[n - 1 - i];
    return number;
  }
 };

 for (var key in instance)
-  HybiParser.prototype[key] = instance[key];
+  Hybi.prototype[key] = instance[key];

-module.exports = HybiParser;
+module.exports = Hybi;

@@ -20,9 +20,9 @@ StreamReader.prototype._readBuffer = function(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;
@@ -31,12 +31,12 @@ StreamReader.prototype._readBuffer = function(length) {
    remain -= size;
    i += 1;
  }
-  
+
  if (remain > 0) return null;
-  
+
  queue.splice(0, i-1);
  this._cursor = (i === 1 ? this._cursor : 0) + size;
-  
+
  return buffer;
 };

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

-, "version"         : "0.4.0"
+, "version"         : "0.2.1"
 , "engines"         : {"node": ">=0.4.0"}
-, "main"            : "./lib/faye/websocket"
+, "main"            : "./lib/websocket/driver"
 , "devDependencies" : {"jsclass": ""}

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

-, "bugs"            : "http://github.com/faye/faye-websocket-node/issues"
+, "bugs"            : "http://github.com/faye/websocket-driver-node/issues"

-, "licenses"        : [ { "type"    : "MIT"
-                        , "url"     : "http://www.opensource.org/licenses/mit-license.php"
+, "licenses"        : [ { "type"  : "MIT"
+                        , "url"   : "http://www.opensource.org/licenses/mit-license.php"
                        }
                      ]

-, "repositories"    : [ { "type"    : "git"
-                        , "url"     : "git://github.com/faye/faye-websocket-node.git"
+, "repositories"    : [ { "type"  : "git"
+                        , "url"   : "git://github.com/faye/websocket-driver-node.git"
                        }
                      ]
 }
@@ -1,162 +0,0 @@
-var Client = require('../../../lib/faye/websocket/client')
-
-JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
-  server: function(port, secure, callback) {
-    this._adapter = new EchoServer()
-    this._adapter.listen(port, secure)
-    this._port = port
-    setTimeout(callback, 100)
-  },
-  
-  stop: function(callback) {
-    this._adapter.stop()
-    setTimeout(callback, 100)
-  },
-  
-  open_socket: function(url, protocols, callback) {
-    var done = false,
-        self = this,
-        
-        resume = function(open) {
-                   if (done) return
-                   done = true
-                   self._open = open
-                   callback()
-                 }
-    
-    this._ws = new Client(url, protocols)
-    
-    this._ws.onopen  = function() { resume(true)  }
-    this._ws.onclose = function() { resume(false) }
-  },
-  
-  close_socket: function(callback) {
-    var self = this
-    this._ws.onclose = function() {
-      self._open = false
-      callback()
-    }
-    this._ws.close()
-  },
-  
-  check_open: function(callback) {
-    this.assert( this._open )
-    callback()
-  },
-  
-  check_closed: function(callback) {
-    this.assert( !this._open )
-    callback()
-  },
-  
-  check_protocol: function(protocol, callback) {
-    this.assertEqual( protocol, this._ws.protocol )
-    callback()
-  },
-  
-  listen_for_message: function(callback) {
-    var self = this
-    this._ws.addEventListener('message', function(message) { self._message = message.data })
-    callback()
-  },
-  
-  send_message: function(callback) {
-    this._ws.send("I expect this to be echoed")
-    setTimeout(callback, 100)
-  },
-  
-  check_response: function(callback) {
-    this.assertEqual( "I expect this to be echoed", this._message )
-    callback()
-  },
-  
-  check_no_response: function(callback) {
-    this.assert( !this._message )
-    callback()
-  }
-})
-
-
-JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
-  include(WebSocketSteps)
-  
-  before(function() {
-    this.protocols       = ["foo", "echo"]
-    this.plain_text_url  = "ws://localhost:8000/bayeux"
-    this.secure_url      = "wss://localhost:8000/bayeux"
-  })
-  
-  sharedBehavior("socket client", function() { with(this) {
-    it("can open a connection", function() { with(this) {
-      open_socket(socket_url, protocols)
-      check_open()
-      check_protocol("echo")
-    }})
-    
-    it("cannot open a connection to the wrong host", function() { with(this) {
-      open_socket(blocked_url, protocols)
-      check_closed()
-    }})
-    
-    it("cannot open a connection with unacceptable protocols", function() { with(this) {
-      open_socket(socket_url, ["foo"])
-      check_closed()
-    }})
-    
-    it("can close the connection", function() { with(this) {
-      open_socket(socket_url, protocols)
-      close_socket()
-      check_closed()
-    }})
-    
-    describe("in the OPEN state", function() { with(this) {
-      before(function() { with(this) {
-        open_socket(socket_url, protocols)
-      }})
-      
-      it("can send and receive messages", function() { with(this) {
-        listen_for_message()
-        send_message()
-        check_response()
-      }})
-    }})
-    
-    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) {
-        listen_for_message()
-        send_message()
-        check_no_response()
-      }})
-    }})
-  }})
-  
-  describe("with a plain-text server", function() { with(this) {
-    before(function() {
-      this.socket_url  = this.plain_text_url
-      this.blocked_url = this.secure_url
-    })
-    
-    before(function() { this.server(8000, 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(8000, true) })
-    after (function() { this.stop() })
-    
-    behavesLike("socket client")
-  }})
-}})
-
@@ -1,72 +0,0 @@
-var Draft75Parser = require('../../../lib/faye/websocket/draft75_parser')
-
-JS.ENV.Draft75ParserSpec = JS.Test.describe("Draft75Parser", function() { with(this) {
-  before(function() { with(this) {
-    this.webSocket = {dispatchEvent: function() {}}
-    this.parser = new Draft75Parser(webSocket)
-  }})
-  
-  describe("parse", function() { with(this) {
-    sharedBehavior("draft-75 parser", function() { with(this) {
-      it("parses text frames", function() { with(this) {
-        expect(webSocket, "receive").given("Hello")
-        parser.parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-      }})
-      
-      it("parses multiple frames from the same packet", function() { with(this) {
-        expect(webSocket, "receive").given("Hello").exactly(2)
-        parser.parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-      }})
-      
-      it("parses text frames beginning 0x00-0x7F", function() { with(this) {
-        expect(webSocket, "receive").given("Hello")
-        parser.parse([0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-      }})
-      
-      it("ignores frames with a length header", function() { with(this) {
-        expect(webSocket, "receive").exactly(0)
-        parser.parse([0x80, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      }})
-      
-      it("parses text following an ignored block", function() { with(this) {
-        expect(webSocket, "receive").given("Hello")
-        parser.parse([0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
-      }})
-      
-      it("parses multibyte text frames", function() { with(this) {
-        expect(webSocket, "receive").given("Apple = ")
-        parser.parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
-      }})
-      
-      it("parses frames received in several packets", function() { with(this) {
-        expect(webSocket, "receive").given("Apple = ")
-        parser.parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65])
-        parser.parse([0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
-      }})
-      
-      it("parses fragmented frames", function() { with(this) {
-        expect(webSocket, "receive").given("Hello")
-        parser.parse([0x00, 0x48, 0x65, 0x6c])
-        parser.parse([0x6c, 0x6f, 0xff])
-      }})
-    }})
-    
-    behavesLike("draft-75 parser")
-    
-    it("does not close the socket if a 76 close frame is received", function() { with(this) {
-      expect(webSocket, "close").exactly(0)
-      expect(webSocket, "receive").given("")
-      parser.parse([0xFF, 0x00])
-    }})
-  }})
-  
-  describe("frame", function() { with(this) {
-    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
-      assertBufferEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], parser.frame("Hello") )
-    }})
-    
-    it("encodes multibyte characters correctly", function() { with(this) {
-      assertBufferEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], parser.frame("Apple = ") )
-    }})
-  }})
-}})
@@ -1,28 +0,0 @@
-var Draft76Parser = require('../../../lib/faye/websocket/draft76_parser')
-
-JS.ENV.Draft76ParserSpec = JS.Test.describe("Draft76Parser", function() { with(this) {
-  before(function() { with(this) {
-    this.webSocket = {dispatchEvent: function() {}}
-    this.parser = new Draft76Parser(webSocket)
-    parser._handshakeComplete = true
-  }})
-  
-  describe("parse", function() { with(this) {
-    behavesLike("draft-75 parser")
-    
-    it("closes the socket if a close frame is received", function() { with(this) {
-      expect(webSocket, "close")
-      parser.parse([0xFF, 0x00])
-    }})
-  }})
-  
-  describe("frame", function() { with(this) {
-    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
-      assertBufferEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], parser.frame("Hello") )
-    }})
-    
-    it("encodes multibyte characters correctly", function() { with(this) {
-      assertBufferEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], parser.frame("Apple = ") )
-    }})
-  }})
-}})
@@ -1,157 +0,0 @@
-var HybiParser = require('../../../lib/faye/websocket/hybi_parser')
-
-JS.ENV.HybiParserSpec = JS.Test.describe("HybiParser", function() { with(this) {
-  before(function() { with(this) {
-    this.webSocket = {dispatchEvent: function() {}}
-    this.parser = new HybiParser(webSocket)
-  }})
-  
-  define("parse", function() {
-    var bytes = [];
-    for (var i = 0, n = arguments.length; i < n; i++) bytes = bytes.concat(arguments[i])
-    this.parser.parse(new Buffer(bytes))
-  })
-  
-  define("buffer", function(string) {
-    return {
-      equals: function(buffer) {
-        return buffer.toString('utf8', 0, buffer.length) === string
-      }
-    }
-  })
-  
-  describe("parse", function() { with(this) {
-    define("mask", function() {
-      return this._mask = this._mask || [1,2,3,4].map(function() { return Math.floor(Math.random() * 255) })
-    })
-    
-    define("maskMessage", function(bytes) {
-      var output = []
-      Array.prototype.forEach.call(bytes, function(b, i) {
-        output[i] = bytes[i] ^ this.mask()[i % 4]
-      }, this)
-      return output
-    })
-    
-    it("parses unmasked text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Hello")
-      parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-    }})
-    
-    it("parses multiple frames from the same packet", function() { with(this) {
-      expect(webSocket, "receive").given("Hello").exactly(2)
-      parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-    }})
-    
-    it("parses empty text frames", function() { with(this) {
-      expect(webSocket, "receive").given("")
-      parse([0x81, 0x00])
-    }})
-    
-    it("parses fragmented text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Hello")
-      parse([0x01, 0x03, 0x48, 0x65, 0x6c])
-      parse([0x80, 0x02, 0x6c, 0x6f])
-    }})
-    
-    it("parses masked text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Hello")
-      parse([0x81, 0x85], mask(), maskMessage([0x48, 0x65, 0x6c, 0x6c, 0x6f]))
-    }})
-    
-    it("parses masked empty text frames", function() { with(this) {
-      expect(webSocket, "receive").given("")
-      parse([0x81, 0x80], mask(), maskMessage([]))
-    }})
-    
-    it("parses masked fragmented text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Hello")
-      parse([0x01, 0x81], mask(), maskMessage([0x48]))
-      parse([0x80, 0x84], mask(), maskMessage([0x65, 0x6c, 0x6c, 0x6f]))
-    }})
-    
-    it("closes the socket if the frame has an unrecognized opcode", function() { with(this) {
-      expect(webSocket, "close").given(1002, null, false)
-      parse([0x83, 0x00])
-    }})
-    
-    it("closes the socket if a close frame is received", function() { with(this) {
-      expect(webSocket, "close").given(1000, "Hello", false)
-      parse([0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
-    }})
-    
-    it("parses unmasked multibyte text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Apple = ")
-      parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-    }})
-    
-    it("parses frames received in several packets", function() { with(this) {
-      expect(webSocket, "receive").given("Apple = ")
-      parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c])
-      parse([0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
-    }})
-    
-    it("parses fragmented multibyte text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Apple = ")
-      parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])
-      parse([0x80, 0x01, 0xbf])
-    }})
-    
-    it("parses masked multibyte text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Apple = ")
-      parse([0x81, 0x8b], mask(), maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]))
-    }})
-    
-    it("parses masked fragmented multibyte text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Apple = ")
-      parse([0x01, 0x8a], mask(), maskMessage([0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]))
-      parse([0x80, 0x81], mask(), maskMessage([0xbf]))
-    }})
-    
-    it("parses unmasked medium-length text frames", function() { with(this) {
-      expect(webSocket, "receive").given("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
-      parse([129, 126, 0, 200, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111])
-    }})
-    
-    it("parses masked medium-length text frames", function() { with(this) {
-      expect(webSocket, "receive").given("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
-      parse([129, 254, 0, 200], mask(), maskMessage([72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111]))
-    }})
-    
-    it("replies to pings with a pong", function() { with(this) {
-      expect(webSocket, "send").given(buffer("OHAI"), "pong")
-      parse([0x89, 0x04, 0x4f, 0x48, 0x41, 0x49])
-    }})
-  }})
-  
-  describe("frame", function() { with(this) {
-    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
-      assertBufferEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], parser.frame("Hello") )
-    }})
-    
-    it("encodes multibyte characters correctly", function() { with(this) {
-      assertBufferEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], parser.frame("Apple = ") )
-    }})
-    
-    it("encodes medium-length strings using extra length bytes", function() { with(this) {
-      assertBufferEqual( [129, 126, 0, 200, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111], parser.frame("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello") )
-    }})
-    
-    it("encodes long strings using extra length bytes", function() { with(this) {
-      var reps = 13108, message = '', output = [0x81, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04]
-      while (reps--) {
-        message += "Hello"
-        output = output.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
-      }
-      assertBufferEqual( output, parser.frame(message) )
-    }})
-    
-    it("encodes close frames with an error code", function() { with(this) {
-      assertBufferEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], parser.frame("Hello", "close", 1002) )
-    }})
-    
-    it("encodes pong frames", function() { with(this) {
-      assertBufferEqual( [0x8a, 0x00], parser.frame("", "pong") )
-    }})
-  }})
-}})
@@ -1,54 +1,49 @@
 require('jsclass')

-var WebSocket = require('../lib/faye/websocket'),
-    fs        = require('fs'),
-    http      = require('http'),
-    https     = require('https')
+var Stream = require('stream').Stream,
+    util   = require('util')

-
-JS.ENV.EchoServer = function() {}
-EchoServer.prototype.listen = function(port, ssl) {
-  var server = ssl
-             ? https.createServer({
-                 key:  fs.readFileSync(__dirname + '/server.key'),
-                 cert: fs.readFileSync(__dirname + '/server.crt')
-               })
-             : http.createServer()
-  
-  server.addListener('upgrade', function(request, socket, head) {
-    var ws = new WebSocket(request, socket, head, ["echo"])
-    ws.onmessage = function(event) {
-      ws.send(event.data)
-    }
-  })
-  this._httpServer = server
-  server.listen(port)
+var BufferMatcher = function(data) {
+  this._data = (typeof data === 'string')
+             ? new Buffer(data, 'utf8')
+             : new Buffer(data)
 }
-EchoServer.prototype.stop = function(callback, scope) {
-  this._httpServer.addListener('close', function() {
-    if (callback) callback.call(scope);
-  });
-  this._httpServer.close();
+BufferMatcher.prototype.equals = function(other) {
+  if (this._data.length !== other.length) return false;
+  for (var i = 0, n = other.length; i < n; i++) {
+    if (other[i] !== this._data[i]) return false;
+  }
+  return true;
 }

-
-JS.Packages(function() { with(this) {
-  autoload(/.*Spec/, {from: 'spec/faye/websocket'})
-}})
-
+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
+}

 JS.require('JS.Test', function() {
-  JS.Test.Unit.Assertions.define("assertBufferEqual", function(array, buffer) {
-    this.assertEqual(array.length, buffer.length);
-    var ary = [], n = buffer.length;
-    while (n--) ary[n] = buffer[n];
-    this.assertEqual(array, ary);
+  JS.Test.Unit.TestCase.include({
+    buffer: function(data) {
+      return new BufferMatcher(data)
+    },
+    collector: function() {
+      return this._collector = this._collector || new Collector()
+    }
  })
-  
-  JS.require( 'ClientSpec',
-              'Draft75ParserSpec',
-              'Draft76ParserSpec',
-              'HybiParserSpec',
-              JS.Test.method('autorun'))
+
+  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')
+  JS.Test.autorun()
 })

@@ -1,15 +0,0 @@
-----BEGIN CERTIFICATE-----
-MIICZTCCAc4CCQDxyrJZrFA0vjANBgkqhkiG9w0BAQUFADB3MQswCQYDVQQGEwJV
-SzEPMA0GA1UECBMGTG9uZG9uMQ8wDQYDVQQHEwZMb25kb24xDTALBgNVBAoTBEZh
-eWUxFTATBgNVBAMTDEphbWVzIENvZ2xhbjEgMB4GCSqGSIb3DQEJARYRamNvZ2xh
-bkBnbWFpbC5jb20wHhcNMTEwODMwMTIzOTM2WhcNMTIwODI5MTIzOTM2WjB3MQsw
-CQYDVQQGEwJVSzEPMA0GA1UECBMGTG9uZG9uMQ8wDQYDVQQHEwZMb25kb24xDTAL
-BgNVBAoTBEZheWUxFTATBgNVBAMTDEphbWVzIENvZ2xhbjEgMB4GCSqGSIb3DQEJ
-ARYRamNvZ2xhbkBnbWFpbC5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-AMDjU5fAK7fvUCZIYHcGXDZD/m9bY+B/UcwGcowk0hMQGYNlLKrpiK7xXBmZpDb6
-r8n+7L/epBeSumbRIm4TDzeNHhuQGYLIeGQy7JNLoPBr6GxubjuJhKOOBnCqcupR
-CLGG7Zw5oL4UvtZVH6kL9XnjyokQQbxxeoV9DqtqOaHHAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEAvQjSpzE1ahaeH1CmbLwckTxvWMZfxcZOrxTruK1po3cNnDOjGqFQ
-KEkNj3K5WfwTBD4QgUdYDykhDX2m6HaMz4JEbgrwQv8M8FiswIA3dyGsbOifOk8H
-r3GPNKMzm4o6vrn6RGOpt9q6bsWUBUHfNpP93uU2C9QEwDua3cFjDA0=
-----END CERTIFICATE-----
@@ -1,15 +0,0 @@
-----BEGIN RSA PRIVATE KEY-----
-MIICXAIBAAKBgQDA41OXwCu371AmSGB3Blw2Q/5vW2Pgf1HMBnKMJNITEBmDZSyq
-6Yiu8VwZmaQ2+q/J/uy/3qQXkrpm0SJuEw83jR4bkBmCyHhkMuyTS6Dwa+hsbm47
-iYSjjgZwqnLqUQixhu2cOaC+FL7WVR+pC/V548qJEEG8cXqFfQ6rajmhxwIDAQAB
-AoGABlk1DiCQD8y7mZb2PdSiwlJ4lFewsNnf6lQn/v7TPzdfb5ir4LAxBHkDLACH
-jBuyH3bZefMs+W2l3u5xMKhF7uJqYcUlJdH2UwRfNG54Hn4SGAjQOK3ONer99sUf
-USlsWSX1HjAAFMCBwUfKxMZA3VNQfYKTPdm0jSVf85kHO1ECQQD3s6ksm3QpfD0L
-eG9EoDrqmwnEfpKoWPpz1O0i5tY9VcmhmLwS5Zpd7lB1qjTqzZk4RygU73T/BseJ
-azehIHK5AkEAx1mSXt+ec8RfzVi/io6oqi2vOcACXRbOG4NQmqUWPnumdwsJjsjR
-RzEoDFC2lu6448p9sgEq+CkbmgVeiyp4fwJAQnmgySve/NMuvslPcyddKGD7OhSN
-30ghzrwx98/jZwqC1i9bKeccimDOjwVitjD/Ea9m/ldVGqwDGMoBX+iJYQJAEIOO
-CYfyw1pQKV2huGOq+zX/nwQV7go2lrbhFX55gkGR/6iNaSOfmosq6yJAje5GqLAc
-i4NnQNl+7NpnA5ZIFwJBAI1+OsZyjbRI99pYkTdOpa5IPlIb3j3JbSfjAWHLxlRY
-0HLvN3Q1mE9kbB+uKH6syF/S7nALgsLgq7eHYvIaE/A=
-----END RSA PRIVATE KEY-----
@@ -0,0 +1,230 @@
+var Client = require("../../../lib/websocket/driver/client")
+
+JS.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 )
+      }})
+    }})
+  }})
+}})
+
@@ -0,0 +1,113 @@
+JS.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() )
+        }})
+      }})
+    }})
+  }})
+}})
+
@@ -0,0 +1,99 @@
+var Draft75 = require("../../../lib/websocket/driver/draft75")
+
+JS.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")
+}})
+
@@ -0,0 +1,186 @@
+var Draft76 = require("../../../lib/websocket/driver/draft76")
+
+JS.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()
+      }})
+    }})
+  }})
+}})
+
@@ -0,0 +1,541 @@
+var Hybi = require("../../../lib/websocket/driver/hybi")
+
+JS.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() )
+      }})
+    }})
+  }})
+}})
+
Author	SHA1	Message	Date
James Coglan	5a1dcd5773	Bump version to 0.2.1.	2013-05-17 11:51:34 +01:00
James Coglan	17e2bd4084	Messages should be queued when the driver is in the 'pre-connecting' state, as the client is initially.	2013-05-17 11:48:36 +01:00
James Coglan	3dfaaf497f	Expose the isSecureRequest() method.	2013-05-17 11:47:56 +01:00
James Coglan	0e4f13d0e4	Bump version to 0.2.0.	2013-05-12 15:09:18 +01:00
James Coglan	4f8e10ead6	Add a changelog.	2013-05-12 15:08:17 +01:00
James Coglan	97451f81ab	Set status and headers as soon as we have them so they're available if there is an error.	2013-05-12 14:44:17 +01:00
James Coglan	390ebee4d8	Parameterize the port we run the example server on.	2013-05-12 13:19:13 +01:00
James Coglan	de001a0f54	Remove a blank line.	2013-05-12 01:45:56 +01:00
James Coglan	26c4873f3e	Apply offset to the consumed offset from HTTP parsing before we check whether the whole buffer has been used.	2013-05-12 01:45:04 +01:00
James Coglan	b2472e89a6	Document the Server driver.	2013-05-12 01:31:14 +01:00
James Coglan	1124df2bf5	Add a Server driver for running WebSockets through a bare TCP server.	2013-05-12 01:13:50 +01:00
James Coglan	ea4e289669	Add a setHeader() function to allow peers to add headers to their handshake responses.	2013-05-11 22:26:20 +01:00
James Coglan	d7c65eedd9	Expose the status and headers from the response in the client driver.	2013-05-11 21:58:37 +01:00
James Coglan	d594f7d708	Include more possible headers as indicators of a secure connection.	2013-05-11 21:55:52 +01:00
James Coglan	746977d2e4	Don't package the spec directory.	2013-05-04 20:40:53 +01:00
James Coglan	aa25393a6c	Check for GET in isWebSocket() and expose the isSecureRequest() method.	2013-05-04 17:27:25 +01:00
James Coglan	88202e66d5	Stream.end() should write() if given an empty stream.	2013-05-04 17:26:59 +01:00
James Coglan	25c075a408	Rename the module to websocket-driver.	2013-05-04 16:42:44 +01:00
James Coglan	a582cb8224	Justify some lines in readme properly.	2013-05-04 15:05:16 +01:00
James Coglan	37da202fd2	Readme should tell you how to install the library.	2013-05-04 14:59:38 +01:00
James Coglan	4965dc1214	Some small changes to the readme.	2013-05-04 14:49:51 +01:00
James Coglan	f16ad50db0	Raise an error if the length header is larger than the max int that JS can represent precisely.	2013-05-04 13:33:27 +01:00
James Coglan	d716650499	Add more robust error handling for Hybi and Client and emit error events when the protocol goes wrong.	2013-05-02 00:09:14 +01:00
James Coglan	103c39c664	Correct the name of a test suite.	2013-05-01 02:11:32 +01:00
James Coglan	cbb33e4924	Allow default handler options to be overridden.	2013-05-01 00:59:54 +01:00
James Coglan	23f296b926	Replace the getVersion() method with a version property.	2013-05-01 00:55:49 +01:00
James Coglan	b56a960bb2	s/addListener/on/	2013-05-01 00:24:33 +01:00
James Coglan	86a6d59617	Write request body before piping socket in the docs.	2013-04-30 23:47:43 +01:00
James Coglan	f6481422b9	Firm up the event system. Make handlers only emit their own events, and then map those to Messages and IO events with a bit of glue. Only emit 'data' when streams are readable, same for 'end'.	2013-04-30 23:35:51 +01:00
James Coglan	9975aa089b	Use the Node EventEmitter class to publish events.	2013-04-30 08:20:14 +01:00
James Coglan	46f58dc5b0	s/Node/Note/	2013-04-29 22:03:58 +01:00
James Coglan	d2e958096c	Refer to the draft-76 request body as 'body' rather than 'head'.	2013-04-29 22:00:39 +01:00
James Coglan	e9bdd17cef	Correct a typo in stream docs.	2013-04-29 21:54:52 +01:00
James Coglan	e98eb72c6c	Remove comments about Node streams.	2013-04-29 21:51:00 +01:00
James Coglan	5dfe9ecdad	Return the protocol version from the Client handler.	2013-04-29 21:35:57 +01:00
James Coglan	c957874493	Make protocol.http() select the right driver for the request.	2013-04-29 20:46:17 +01:00
James Coglan	b354dd69fa	Implement the draft-76 protocol.	2013-04-29 20:27:35 +01:00
James Coglan	c70c5618da	Only end the messages stream when we trigger onclose.	2013-04-29 19:11:26 +01:00
James Coglan	6c025087f7	Emit 'end' from the messages stream when the socket's onclose event runs.	2013-04-29 19:08:10 +01:00
James Coglan	9ed82bc0ab	Extract the IO and Messages streams and flesh them out to implement backpressure.	2013-04-29 19:00:08 +01:00
James Coglan	94a8d0b7be	Correct typo in server-side example.	2013-04-29 09:18:21 +01:00
James Coglan	e3b8033c58	Placeholder for draft-76 support just to get the common tests passing.	2013-04-29 08:56:05 +01:00
James Coglan	950cd9f1e2	Implement and test draft-75.	2013-04-29 08:40:05 +01:00
James Coglan	6f7942d5b7	Begin writing the draft75 module.	2013-04-29 07:48:09 +01:00
James Coglan	c0e1e8d2c3	Add a title to call out the streams interface.	2013-04-29 07:40:30 +01:00
James Coglan	0ff6767355	GitHub's markdown processor handles bolded code inconsistently.	2013-04-29 07:39:53 +01:00
James Coglan	83865ac1da	Some corrections to the docs.	2013-04-29 07:33:01 +01:00
James Coglan	52216a5c27	Merge a couple of paragraphs.	2013-04-29 00:04:20 +01:00
James Coglan	fc4c166fef	Remove an item from .npmignore.	2013-04-29 00:02:46 +01:00
James Coglan	ab416619b7	Add a README.	2013-04-29 00:01:40 +01:00
James Coglan	41ddd82932	Add tests for Hybi and Client handlers and fix some minor bugs.	2013-04-28 23:22:05 +01:00
James Coglan	847bdc1773	Strip the repo down to just the protocol handlers.	2013-04-28 19:04:03 +01:00
James Coglan	13e27bdc3b	Update Node versions for Travis.	2013-04-28 18:56:32 +01:00
James Coglan	62a0c7597f	First steps toward streaming I/O-independent parsing. Implement the Hybi and Client protocol handlers as stateful protcol drivers with two duplex streams, one for messages and one for I/O.	2013-04-28 18:55:58 +01:00
James Coglan	78f8bfb26b	Remove parser specs.	2013-04-28 14:01:28 +01:00
James Coglan	99aacf67a5	Bump copyright date.	2013-02-15 00:02:57 +00:00
James Coglan	1a6cdd3e43	Bump version to 0.4.4.	2013-02-14 22:40:48 +00:00
James Coglan	0e2417cd51	Change name used in Autobahn tests.	2013-02-14 22:39:13 +00:00
James Coglan	86f882f189	Return early rather than have an else-clause.	2013-02-10 23:41:37 +00:00
James Coglan	87f1abad08	s/close/finalize/ -- I missed one rename in the last commit.	2012-12-24 16:43:41 +00:00
James Coglan	b86f505441	If WebSocket.close() is called without asking for an ack, then don't return if we're in the CLOSING state. This can happen if one peer sends a closing frame and the other peer terminates TCP before sending the reply, and as currently implemented this will no emit a close event or end the Node stream.	2012-12-24 16:37:57 +00:00
James Coglan	14a1a7372d	Use progress bar using Autobahn client tests.	2012-12-23 18:25:50 +00:00
James Coglan	ee22f75959	Remove trailing whitespace.	2012-12-22 23:13:04 +00:00
James Coglan	7b63baa5a6	Fix specs on v0.9.	2012-12-22 23:12:08 +00:00
James Coglan	0dc749e565	Merge pull request #18 from gsoltis/master Fix for closing a socket in the CONNECTING state	2012-10-15 11:54:53 -07:00
Greg Soltis	3280f38c27	Fix check of readyState for immediate close	2012-10-15 11:34:44 -07:00
James Coglan	64b52a0be2	Update Node versions for Travis.	2012-10-13 17:02:07 +01:00
James Coglan	bd6e89f290	If close() is called in the CONNECTING readyState, then close the TCP connection immediately without waiting for the handshake to complete.	2012-10-13 16:59:58 +01:00
James Coglan	f50de64532	Update changelog.	2012-07-09 08:58:00 +01:00
James Coglan	d071ec3acd	Check that incoming requests have an output stream before doing anything with it.	2012-07-08 20:30:53 +01:00
James Coglan	59fd729a03	Bump version to 0.4.3.	2012-07-01 18:15:01 +01:00
James Coglan	b458959e6a	Update Node versions for Travis.	2012-07-01 18:12:54 +01:00
James Coglan	7f18af7c90	Use Connection:close on EventSource connections.	2012-05-21 19:41:26 +01:00
James Coglan	680d8fc759	Remove an expensive test.	2012-05-21 19:37:40 +01:00
James Coglan	90d039e371	Bump version to 0.4.2.	2012-04-06 18:57:29 +01:00
James Coglan	b42cdf741d	Add error code 1011.	2012-04-06 13:52:21 +01:00
James Coglan	bd7c52dfa2	Use / as the default path if the client URI has no path.	2012-04-01 22:57:16 +01:00
James Coglan	adee8ba51c	Bump version to 0.4.1.	2012-02-26 19:00:04 +00:00
James Coglan	3675cfb798	Treat anything but a Buffer as a text message in WebSocket#send.	2012-02-25 09:49:53 +00:00
James Coglan	1222308201	Return boolean from EventSource.send().	2012-02-16 23:15:16 +00:00
James Coglan	8c9ae84740	Treat numbers as strings when passed to Socket.send().	2012-02-16 23:09:29 +00:00
James Coglan	d404c78c46	Add items to .npmignore.	2012-02-13 12:43:12 +00:00