Bump version to 0.6.1.

Older Nodes don't support chained pipe().
Start the driver asynchronously on the server to allow onopen hooks to be registered.
2013-07-05 15:18:10 +01:00 · 2013-07-05 11:15:36 +01:00 · 2013-07-04 21:55:30 +01:00 · 2013-07-01 02:21:41 +01:00 · 2013-07-01 02:20:52 +01:00 · 2013-06-23 01:13:50 +01:00
28 changed files with 649 additions and 1976 deletions
@@ -1,6 +1,6 @@
 .git
 .gitignore
 .npmignore
-.redcar
 .travis.yml
 node_modules
+spec
@@ -0,0 +1,79 @@
+### 0.6.1 / 2013-07-05
+
+* Add `ca` option to the client for specifying certificate authorities
+* Start the server driver asynchronously so that `onopen` handlers can be added
+
+
+### 0.6.0 / 2013-05-12
+
+* Add support for custom headers
+
+
+### 0.5.0 / 2013-05-05
+
+* Extract the protocol handlers into the `websocket-driver` library
+* Support the Node streaming API
+
+
+### 0.4.4 / 2013-02-14
+
+* Emit the `close` event if TCP is closed before CLOSE frame is acked
+
+
+### 0.4.3 / 2012-07-09
+
+* Add `Connection: close` to EventSource response
+* Handle situations where `request.socket` is undefined
+
+
+### 0.4.2 / 2012-04-06
+
+* Add WebSocket error code `1011`.
+* Handle URLs with no path correctly by sending `GET /`
+
+
+### 0.4.1 / 2012-02-26
+
+* Treat anything other than a `Buffer` as a string when calling `send()`
+
+
+### 0.4.0 / 2012-02-13
+
+* Add `ping()` method to server-side `WebSocket` and `EventSource`
+* Buffer `send()` calls until the draft-76 handshake is complete
+* Fix HTTPS problems on Node 0.7
+
+
+### 0.3.1 / 2012-01-16
+
+* Call `setNoDelay(true)` on `net.Socket` objects to reduce latency
+
+
+### 0.3.0 / 2012-01-13
+
+* Add support for `EventSource` connections
+
+
+### 0.2.0 / 2011-12-21
+
+* Add support for `Sec-WebSocket-Protocol` negotiation
+* Support `hixie-76` close frames and 75/76 ignored segments
+* Improve performance of HyBi parsing/framing functions
+* Decouple parsers from TCP and reduce write volume
+
+
+### 0.1.2 / 2011-12-05
+
+* Detect closed sockets on the server side when TCP connection breaks
+* Make `hixie-76` sockets work through HAProxy
+
+
+### 0.1.1 / 2011-11-30
+
+* Fix `addEventListener()` interface methods
+
+
+### 0.1.0 / 2011-11-27
+
+* Initial release, based on WebSocket components from Faye
+
@@ -1,62 +0,0 @@
-=== 0.4.4 / 2013-02-14
-
-* Emit the 'close' event if TCP is closed before CLOSE frame is acked
-
-
-=== 0.4.3 / 2012-07-09
-
-* Add 'Connection: close' to EventSource response
-* Handle situations where request.socket is undefined
-
-
-=== 0.4.2 / 2012-04-06
-
-* Add WebSocket error code 1011.
-* Handle URLs with no path correctly by sending 'GET /'
-
-
-=== 0.4.1 / 2012-02-26
-
-* Treat anything other than a Buffer as a string when calling send()
-
-
-=== 0.4.0 / 2012-02-13
-
-* Add ping() method to server-side WebSocket and EventSource
-* Buffer send() calls until the draft-76 handshake is complete
-* Fix HTTPS problems on Node 0.7
-
-
-=== 0.3.1 / 2012-01-16
-
-* Call setNoDelay(true) on net.Socket objects to reduce latency
-
-
-=== 0.3.0 / 2012-01-13
-
-* Add support for EventSource connections
-
-
-=== 0.2.0 / 2011-12-21
-
-* Add support for Sec-WebSocket-Protocol negotiation
-* Support hixie-76 close frames and 75/76 ignored segments
-* Improve performance of HyBi parsing/framing functions
-* Decouple parsers from TCP and reduce write volume
-
-
-=== 0.1.2 / 2011-12-05
-
-* Detect closed sockets on the server side when TCP connection breaks
-* Make hixie-76 sockets work through HAProxy
-
-
-=== 0.1.1 / 2011-11-30
-
-* Fix addEventListener() interface methods
-
-
-=== 0.1.0 / 2011-11-27
-
-* Initial release, based on WebSocket components from Faye
-
@@ -1,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-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.
-
@@ -0,0 +1,287 @@
+# faye-websocket
+
+* Travis CI build: [![Build
+  status](https://secure.travis-ci.org/faye/faye-websocket-node.png)](http://travis-ci.org/faye/faye-websocket-node)
+* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/),
+  [client](http://faye.jcoglan.com/autobahn/clients/)
+
+This is a general-purpose WebSocket implementation extracted from the
+[Faye](http://faye.jcoglan.com) project. It provides classes for easily
+building WebSocket servers and clients in Node. It does not provide a server
+itself, but rather makes it easy to handle WebSocket connections within an
+existing [Node](http://nodejs.org/) application. It does not provide any
+abstraction other than the standard [WebSocket
+API](http://dev.w3.org/html5/websockets/).
+
+It also provides an abstraction for handling
+[EventSource](http://dev.w3.org/html5/eventsource/) connections, which are
+one-way connections that allow the server to push data to the client. They are
+based on streaming HTTP responses and can be easier to access via proxies than
+WebSockets.
+
+
+## Installation
+
+```
+$ npm install faye-websocket
+```
+
+
+## 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.on('upgrade', function(request, socket, body) {
+  if (WebSocket.isWebSocket(request)) {
+    var ws = new WebSocket(request, socket, body);
+    
+    ws.on('message', function(event) {
+      ws.send(event.data);
+    });
+    
+    ws.on('close', function(event) {
+      console.log('close', event.code, event.reason);
+      ws = null;
+    });
+  }
+});
+
+server.listen(8000);
+```
+
+`WebSocket` objects are also duplex streams, so you could replace the
+`ws.on('message', ...)` line with:
+
+```js
+    ws.pipe(ws);
+```
+
+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.on('open', function(event) {
+  console.log('open');
+  ws.send('Hello, world!');
+});
+
+ws.on('message', function(event) {
+  console.log('message', event.data);
+});
+
+ws.on('close', function(event) {
+  console.log('close', event.code, event.reason);
+  ws = null;
+});
+```
+
+The WebSocket client also lets you inspect the status and headers of the
+handshake response via its `statusCode` and `headers` properties.
+
+
+## Subprotocol negotiation
+
+The WebSocket protocol allows peers to select and identify the application
+protocol to use over the connection. On the client side, you can set which
+protocols the client accepts by passing a list of protocol names when you
+construct the socket:
+
+```js
+var ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
+```
+
+On the server side, you can likewise pass in the list of protocols the server
+supports after the other constructor arguments:
+
+```js
+var ws = new WebSocket(request, socket, body, ['irc', 'amqp']);
+```
+
+If the client and server agree on a protocol, both the client- and server-side
+socket objects expose the selected protocol through the `ws.protocol` property.
+
+
+## Initialization options
+
+Both the server- and client-side classes allow an options object to be passed
+in at initialization time, for example:
+
+```js
+var ws = new WebSocket(request, socket, body, protocols, options);
+var ws = new WebSocket.Client(url, protocols, options);
+```
+
+`protocols` is an array of subprotocols as described above, or `null`.
+`options` is an optional object containing any of these fields:
+
+* `headers` - an object containing key-value pairs representing HTTP headers to
+  be sent during the handshake process
+* `ping` - an integer that sets how often the WebSocket should send ping
+  frames, measured in seconds
+
+
+## WebSocket API
+
+Both server- and client-side `WebSocket` objects support the following API.
+
+* <b>`on('open', function(event) {})`</b> fires when the socket connection is
+  established. Event has no attributes.
+* <b>`on('message', function(event) {})`</b> fires when the socket receives a
+  message. Event has one attribute, <b>`data`</b>, which is either a `String`
+  (for text frames) or a `Buffer` (for binary frames).
+* <b>`on('error', function(event) {})`</b> fires when there is a protocol error
+  due to bad data sent by the other peer. This event is purely informational,
+  you do not need to implement error recover.
+* <b>`on('close', function(event) {})`</b> fires when either the client or the
+  server closes the connection. Event has two optional attributes,
+  <b>`code`</b> and <b>`reason`</b>, that expose the status code and message
+  sent by the peer that closed the connection.
+* <b>`send(message)`</b> accepts either a `String` or a `Buffer` and sends a
+  text or binary message over the connection to the other peer.
+* <b>`ping(message = '', function() {})`</b> sends a ping frame with an
+  optional message and fires the callback when a matching pong is received.
+* <b>`close(code, reason)`</b> closes the connection, sending the given status
+  code and reason text, both of which are optional.
+* <b>`version`</b> is a string containing the version of the `WebSocket`
+  protocol the connection is using.
+* <b>`protocol`</b> is a string (which may be empty) identifying the
+  subprotocol the socket is using.
+
+
+## Handling EventSource connections in Node
+
+EventSource connections provide a very similar interface, although because they
+only allow the server to send data to the client, there is no `onmessage` API.
+EventSource allows the server to push text messages to the client, where each
+message has an optional event-type and ID.
+
+```js
+var WebSocket   = require('faye-websocket'),
+    EventSource = WebSocket.EventSource,
+    http        = require('http');
+
+var server = http.createServer();
+
+server.on('request', function(request, response) {
+  if (EventSource.isEventSource(request)) {
+    var es = new EventSource(request, response);
+    console.log('open', es.url, es.lastEventId);
+    
+    // Periodically send messages
+    var loop = setInterval(function() { es.send('Hello') }, 1000);
+    
+    es.on('close', function() {
+      clearInterval(loop);
+      es = null;
+    });
+  
+  } else {
+    // Normal HTTP request
+    response.writeHead(200, {'Content-Type': 'text/plain'});
+    response.end('Hello');
+  }
+});
+
+server.listen(8000);
+```
+
+The `send` method takes two optional parameters, `event` and `id`. The default
+event-type is `'message'` with no ID. For example, to send a `notification`
+event with ID `99`:
+
+```js
+es.send('Breaking News!', {event: 'notification', id: '99'});
+```
+
+The `EventSource` object exposes the following properties:
+
+* <b>`url`</b> is a string containing the URL the client used to create the
+  EventSource.
+* <b>`lastEventId`</b> is a string containing the last event ID received by the
+  client. You can use this when the client reconnects after a dropped
+  connection to determine which messages need resending.
+
+When you initialize an EventSource with ` new EventSource()`, you can pass
+configuration options after the `response` parameter. Available options are:
+
+* <b>`retry`</b> is a number that tells the client how long (in seconds) it
+  should wait after a dropped connection before attempting to reconnect.
+* <b>`ping`</b> is a number that tells the server how often (in seconds) to
+  send 'ping' packets to the client to keep the connection open, to defeat
+  timeouts set by proxies. The client will ignore these messages.
+
+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) 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.
+
@@ -28,14 +28,8 @@ socket.onclose = function() {

    } else {
      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);
-      };
+      socket.pipe(socket);
+      socket.on('close', function() { runCase(n + 1) });
    }
  };

@@ -2,7 +2,9 @@ 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 + '/');
+    url       = scheme + '://localhost:' + port + '/',
+    headers   = {Origin: 'http://faye.jcoglan.com'},
+    ws        = new WebSocket.Client(url, null, {headers: headers});

 console.log('Connecting to ' + ws.url);

@@ -35,7 +35,7 @@ var requestHandler = function(request, response) {
    }, 1000);
  }, 2000);

-  es.send('Welcome!\n\nThis is an EventSource server.');
+  fs.createReadStream(__dirname + '/haproxy.conf').pipe(es, {end: false});

  es.onclose = function() {
    clearInterval(loop);
@@ -62,7 +62,7 @@ var server = secure
             })
           : http.createServer();

-server.addListener('request', requestHandler);
-server.addListener('upgrade', upgradeHandler);
+server.on('request', requestHandler);
+server.on('upgrade', upgradeHandler);
 server.listen(port);

@@ -1,34 +1,31 @@
-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 Stream      = require('stream').Stream,
+    util        = require('util'),
+    driver      = require('websocket-driver'),
+    API         = require('./websocket/api'),
+    EventTarget = require('./websocket/api/event_target'),
+    Event       = require('./websocket/api/event');

 var EventSource = function(request, response, options) {
+  this.writable = true;
  options = options || {};

-  this._request  = request;
-  this._response = response;
-  this._stream   = response.socket;
-  this._ping     = options.ping  || this.DEFAULT_PING;
-  this._retry    = options.retry || this.DEFAULT_RETRY;
-
-  var scheme = isSecureConnection(request) ? 'https:' : 'http:';
-  this.url = scheme + '//' + request.headers.host + request.url;
+  this._stream = response.socket;
+  this._ping   = options.ping  || this.DEFAULT_PING;
+  this._retry  = options.retry || this.DEFAULT_RETRY;

+  var scheme       = driver.isSecureRequest(request) ? 'https:' : 'http:';
+  this.url         = scheme + '//' + request.headers.host + request.url;
  this.lastEventId = request.headers['last-event-id'] || '';
+  this.readyState  = API.CONNECTING;

  var self = this;
-  this.readyState = API.CONNECTING;
-  this._sendBuffer = [];
+
+  if (!this._stream || !this._stream.writable) return;
  process.nextTick(function() { self._open() });

+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
  var handshake = 'HTTP/1.1 200 OK\r\n' +
                  'Content-Type: text/event-stream\r\n' +
                  'Cache-Control: no-cache, no-store\r\n' +
@@ -36,24 +33,21 @@ var EventSource = function(request, response, options) {
                  '\r\n\r\n' +
                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';

-  this.readyState = API.OPEN;
+  this._write(handshake);
+
+  this._stream.on('drain', function() { self.emit('drain') });

  if (this._ping)
-    this._pingLoop = setInterval(function() { self.ping() }, this._ping * 1000);
+    this._pingTimer = setInterval(function() { self.ping() }, this._ping * 1000);

-  if (!this._stream || !this._stream.writable) return;
-
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
-
-  try { this._stream.write(handshake, 'utf8') } catch (e) {}
-
-  ['close', 'end', 'error'].forEach(function(event) {
-    self._stream.addListener(event, function() { self.close() });
+  ['error', 'end'].forEach(function(event) {
+    self._stream.on(event, function() { self.close() });
  });
 };
+util.inherits(EventSource, Stream);

 EventSource.isEventSource = function(request) {
+  if (request.method !== 'GET') return false;
  var accept = (request.headers.accept || '').split(/\s*,\s*/);
  return accept.indexOf('text/event-stream') >= 0;
 };
@@ -62,8 +56,36 @@ var instance = {
  DEFAULT_PING:   10,
  DEFAULT_RETRY:  5,

+  _write: function(chunk) {
+    if (!this.writable) return false;
+    try {
+      return this._stream.write(chunk, 'utf8');
+    } catch (e) {
+      return false;
+    }
+  },
+
+  _open: function() {
+    if (this.readyState !== API.CONNECTING) return;
+
+    this.readyState = API.OPEN;
+
+    var event = new Event('open');
+    event.initEvent('open', false, false);
+    this.dispatchEvent(event);
+  },
+
+  write: function(message) {
+    return this.send(message);
+  },
+
+  end: function(message) {
+    if (message !== undefined) this.write(message);
+    this.close();
+  },
+
  send: function(message, options) {
-    if (this.readyState !== API.OPEN) return false;
+    if (this.readyState > API.OPEN) return false;

    message = String(message).replace(/(\r\n|\r|\n)/g, '$1data: ');
    options = options || {};
@@ -73,38 +95,31 @@ var instance = {
    if (options.id)    frame += 'id: '    + options.id    + '\r\n';
    frame += 'data: ' + message + '\r\n\r\n';

-    try {
-      this._stream.write(frame, 'utf8');
-      return true;
-    } catch (e) {
-      return false;
-    }
+    return this._write(frame);
  },

  ping: function() {
-    try {
-      this._stream.write(':\r\n\r\n', 'utf8');
-      return true;
-    } catch (e) {
-      return false;
-    }
+    return this._write(':\r\n\r\n');
  },

  close: function() {
-    if (this.readyState === API.CLOSING || this.readyState === API.CLOSED)
-      return;
+    if (this.readyState > API.OPEN) return false;

    this.readyState = API.CLOSED;
-    clearInterval(this._pingLoop);
-    this._response.end();
+    this.writable = false;
+    if (this._pingTimer) clearInterval(this._pingTimer);
+    if (this._stream) this._stream.end();

    var event = new Event('close');
    event.initEvent('close', false, false);
    this.dispatchEvent(event);
+
+    return true;
  }
 };

-for (var key in API) EventSource.prototype[key] = API[key];
-for (var key in instance) EventSource.prototype[key] = instance[key];
+for (var method in instance) EventSource.prototype[method] = instance[method];
+for (var key in EventTarget) EventSource.prototype[key] = EventTarget[key];
+
 module.exports = EventSource;

@@ -1,59 +1,46 @@
-// API and protocol references:
+// API references:
 // 
 // * http://dev.w3.org/html5/websockets/
 // * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
 // * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
-// * 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 Stream   = require('stream'),
-    util     = require('util'),
-    protocol = require('../websocket/protocol'),
-    API      = require('./websocket/api'),
-    Event    = require('./websocket/api/event');
+var util   = require('util'),
+    driver = require('websocket-driver'),
+    API    = require('./websocket/api');

-var WebSocket = function(request, socket, head, supportedProtos, options) {
-  this.readable = this.writable = true;
-
-  this._request = request;
-  this._stream  = request.socket;
-  this._ping    = options && options.ping;
-  this._pingId  = 0;
-
-  this._parser = protocol.http(request, {protocols: supportedProtos});
-  this.version = this._parser.getVersion();
-  this.url = this._parser.url;
-  this.readyState = API.CONNECTING;
-  this.bufferedAmount = 0;
+var WebSocket = function(request, socket, body, protocols, options) {
+  this._stream  = socket;
+  this._driver  = driver.http(request, {protocols: protocols});

  var self = this;
-  this._parser.onopen   (function(e) { self._open() });
-  this._parser.onmessage(function(e) { self._receiveMessage(e.data) });
-  this._parser.onclose  (function(e) { self._finalize(e.reason, e.code) });
-
-  if (this._ping)
-    this._pingTimer = setInterval(function() {
-      self._pingId += 1;
-      self.ping(self._pingId.toString());
-    }, this._ping * 1000);
+  if (!this._stream || !this._stream.writable) return;

  var catchup = function() { self._stream.removeListener('data', catchup) };
-  this._stream.addListener('data', catchup);
+  this._stream.on('data', catchup);

  this._stream.setTimeout(0);
  this._stream.setNoDelay(true);
-  this._stream.pipe(this._parser.io);
-  this._parser.io.pipe(this._stream);

-  this._stream.addListener('end', function() { self._finalize('', 1006) });
-  this._parser.start();
+  this._driver.io.write(body);
+  API.call(this, options);
+
+  ['error', 'end'].forEach(function(event) {
+    this._stream.on(event, function() { self._finalize('', 1006) });
+  }, this);
+
+  process.nextTick(function() {
+    self._driver.start();
+  });
 };
-util.inherits(WebSocket, Stream);
+util.inherits(WebSocket, API);

-for (var key in API) WebSocket.prototype[key] = API[key];
+WebSocket.isWebSocket = function(request) {
+  return driver.isWebSocket(request);
+};

 WebSocket.WebSocket   = WebSocket;
+WebSocket.Client      = require('./websocket/client');
 WebSocket.EventSource = require('./eventsource');
+
 module.exports        = WebSocket;

@@ -1,24 +1,109 @@
-var EventTarget = require('./api/event_target'),
+var Stream      = require('stream').Stream,
+    util        = require('util'),
+    EventTarget = require('./api/event_target'),
    Event       = require('./api/event');

-var API = {
-  CONNECTING:   0,
-  OPEN:         1,
-  CLOSING:      2,
-  CLOSED:       3,
+var API = function(options) {
+  options = options || {};

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

  _receiveMessage: function(data) {
-    if (this.readyState !== API.OPEN) return false;
-    this.emit('data', data);
+    if (this.readyState > API.OPEN) return false;
+
+    if (this.readable) this.emit('data', data);
+
    var event = new Event('message', {data: data});
    event.initEvent('message', false, false);
    this.dispatchEvent(event);
@@ -26,40 +111,22 @@ var API = {

  _finalize: function(reason, code) {
    if (this.readyState === API.CLOSED) return;
-    this.readyState = API.CLOSED;
+
    if (this._pingTimer) clearInterval(this._pingTimer);
    if (this._stream) this._stream.end();
+
+    if (this.readable) this.emit('end');
+    this.readable = this.writable = false;
+
+    this.readyState = API.CLOSED;
    var event = new Event('close', {code: code || 1000, reason: reason || ''});
    event.initEvent('close', false, false);
    this.dispatchEvent(event);
-  },
-
-  write: function(data) {
-    if (this.readyState > API.OPEN) return false;
-    if (!(data instanceof Buffer)) data = String(data);
-
-    if (data instanceof Buffer)
-      return this._parser.binary(data);
-    else
-      return this._parser.text(data);
-  },
-
-  send: function(data) {
-    return this.write(data);
-  },
-
-  ping: function(message, callback) {
-    if (this.readyState > API.OPEN) return false;
-    return this._parser.ping(message, callback);
-  },
-
-  close: function() {
-    if (this.readyState === API.OPEN) this.readyState = API.CLOSING;
-    this._parser.close();
  }
 };

-for (var key in EventTarget) API[key] = EventTarget[key];
+for (var method in instance) API.prototype[method] = instance[method];
+for (var key in EventTarget) API.prototype[key] = EventTarget[key];

 module.exports = API;

@@ -7,25 +7,11 @@ var EventTarget = {
  onclose:    null,

  addEventListener: function(eventType, listener, useCapture) {
-    this._listeners = this._listeners || {};
-    var list = this._listeners[eventType] = this._listeners[eventType] || [];
-    list.push(listener);
+    this.on(eventType, 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);
-    }
+    this.removeListener(eventType, listener);
  },

  dispatchEvent: function(event) {
@@ -35,11 +21,7 @@ var EventTarget = {
    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);
+    this.emit(event.type, event);
  }
 };

@@ -1,29 +1,27 @@
-var Stream   = require('stream'),
-    util     = require('util'),
-    net      = require('net'),
-    tls      = require('tls'),
-    protocol = require('../../websocket/protocol'),
-    API      = require('./api'),
-    Event    = require('./api/event');
+var util   = require('util'),
+    net    = require('net'),
+    tls    = require('tls'),
+    driver = require('websocket-driver'),
+    API    = require('./api');

 var Client = function(url, protocols, options) {
-  this.url  = url;
-  this._uri = require('url').parse(url);
+  this.url     = url;
+  this._uri    = require('url').parse(url);
+  this._driver = driver.client(url, {protocols: protocols});

-  this._parser = protocol.client(url, {protocols: protocols});
-  var self = this;
-  this._parser.onopen   (function(e) { self._open() });
-  this._parser.onmessage(function(e) { self._receiveMessage(e.data) });
-  this._parser.onclose  (function(e) { self._finalize(e.reason, e.code) });
-
-  this.readyState = API.CONNECTING;
-  this.bufferedAmount = 0;
+  ['open', 'error'].forEach(function(event) {
+    this._driver.on(event, function() {
+      self.headers    = self._driver.headers;
+      self.statusCode = self._driver.statusCode;
+    });
+  }, this);

  var secure     = (this._uri.protocol === 'wss:'),
-      onConnect  = function() { self._onConnect() },
-      tlsOptions = {};
+      onConnect  = function() { self._driver.start() },
+      tlsOptions = {},
+      self       = this;

-  if (options && options.verify === false) tlsOptions.rejectUnauthorized = false;
+  if (options && options.ca) tlsOptions.ca = options.ca;

  var connection = secure
                 ? tls.connect(this._uri.port || 443, this._uri.hostname, tlsOptions, onConnect)
@@ -33,20 +31,15 @@ var Client = function(url, protocols, options) {
  this._stream.setTimeout(0);
  this._stream.setNoDelay(true);

-  if (!secure) this._stream.addListener('connect', onConnect);
+  if (!secure) this._stream.on('connect', onConnect);

-  this._stream.pipe(this._parser.io);
-  this._parser.io.pipe(this._stream);
+  API.call(this, options);

-  this._stream.addListener('close', function() { self._finalize('', 1006) });
+  ['error', 'end'].forEach(function(event) {
+    this._stream.on(event, function() { self._finalize('', 1006) });
+  }, this);
 };
-util.inherits(Client, Stream);
-
-Client.prototype._onConnect = function() {
-  this._parser.start();
-};
-
-for (var key in API) Client.prototype[key] = API[key];
+util.inherits(Client, API);

 module.exports = Client;

@@ -1,98 +0,0 @@
-var Draft75Parser = function(webSocket) {
-  this._socket = webSocket;
-  this._stage  = 0;
-};
-
-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 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);
-          }
-          else if ((0x80 & data) !== 0x80) {
-            if (this._length === 0) {
-              this._socket.receive('');
-              this._stage = 0;
-            }
-            else {
-              this._buffer = [];
-              this._stage = 2;
-            }
-          }
-          break;
-
-        case 2:
-          if (data === 0xFF) {
-            message = new Buffer(this._buffer);
-            this._socket.receive(message.toString('utf8', 0, this._buffer.length));
-            this._stage = 0;
-          }
-          else {
-            this._buffer.push(data);
-            if (this._length && this._buffer.length === this._length)
-              this._stage = 0;
-          }
-          break;
-      }
-    }
-  },
-
-  _parseLeadingByte: function(data) {
-    if ((0x80 & data) === 0x80) {
-      this._length = 0;
-      this._stage = 1;
-    } else {
-      delete this._length;
-      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];
-
-module.exports = Draft75Parser;
-
@@ -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,355 +0,0 @@
-var crypto    = require('crypto'),
-    Handshake = require('./hybi_parser/handshake'),
-    Reader    = require('./hybi_parser/stream_reader');
-
-var HybiParser = function(webSocket, options) {
-  this._reset();
-  this._socket    = webSocket;
-  this._reader    = new Reader();
-  this._stage     = 0;
-  this._masking   = options && options.masking;
-  this._protocols = options && options.protocols;
-
-  this._pingCallbacks = {};
-
-  if (typeof this._protocols === 'string')
-    this._protocols = this._protocols.split(/\s*,\s*/);
-};
-
-HybiParser.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;
-};
-
-var instance = {
-  BYTE:   255,
-  FIN:    128,
-  MASK:   128,
-  RSV1:   64,
-  RSV2:   32,
-  RSV3:   16,
-  OPCODE: 15,
-  LENGTH: 127,
-
-  OPCODES: {
-    continuation: 0,
-    text:         1,
-    binary:       2,
-    close:        8,
-    ping:         9,
-    pong:         10
-  },
-
-  ERRORS: {
-    normal_closure:       1000,
-    going_away:           1001,
-    protocol_error:       1002,
-    unacceptable:         1003,
-    encoding_error:       1007,
-    policy_violation:     1008,
-    too_large:            1009,
-    extension_error:      1010,
-    unexpected_condition: 1011
-  },
-
-  FRAGMENTED_OPCODES: [0,1,2],
-  OPENING_OPCODES:    [1,2],
-
-  ERROR_CODES: [1000,1001,1002,1003,1007,1008,1009,1010,1011],
-
-  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;
-    while (buffer) {
-      switch (this._stage) {
-        case 0:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseOpcode(buffer[0]);
-          break;
-
-        case 1:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseLength(buffer[0]);
-          break;
-
-        case 2:
-          buffer = this._reader.read(this._lengthSize);
-          if (buffer) this._parseExtendedLength(buffer);
-          break;
-
-        case 3:
-          buffer = this._reader.read(4);
-          if (buffer) {
-            this._mask  = buffer;
-            this._stage = 4;
-          }
-          break;
-
-        case 4:
-          buffer = this._reader.read(this._length);
-          if (buffer) {
-            this._payload = buffer;
-            this._emitFrame();
-            this._stage = 0;
-          }
-          break;
-      }
-    }
-  },
-
-  _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;
-
-    var isText = (typeof data === 'string'),
-        opcode = this.OPCODES[type || (isText ? 'text' : 'binary')],
-        buffer = isText ? new Buffer(data, 'utf8') : data,
-        insert = code ? 2 : 0,
-        length = buffer.length + insert,
-        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
-        offset = header + (this._masking ? 4 : 0),
-        masked = this._masking ? this.MASK : 0,
-        frame  = new Buffer(length + offset),
-        BYTE   = this.BYTE,
-        mask, i;
-
-    frame[0] = this.FIN | opcode;
-
-    if (length <= 125) {
-      frame[1] = masked | length;
-    } else if (length <= 65535) {
-      frame[1] = masked | 126;
-      frame[2] = Math.floor(length / 256);
-      frame[3] = length & BYTE;
-    } else {
-      frame[1] = masked | 127;
-      frame[2] = Math.floor(length / Math.pow(2,56)) & BYTE;
-      frame[3] = Math.floor(length / Math.pow(2,48)) & BYTE;
-      frame[4] = Math.floor(length / Math.pow(2,40)) & BYTE;
-      frame[5] = Math.floor(length / Math.pow(2,32)) & BYTE;
-      frame[6] = Math.floor(length / Math.pow(2,24)) & BYTE;
-      frame[7] = Math.floor(length / Math.pow(2,16)) & BYTE;
-      frame[8] = Math.floor(length / Math.pow(2,8))  & BYTE;
-      frame[9] = length & BYTE;
-    }
-
-    if (code) {
-      frame[offset]   = Math.floor(code / 256) & BYTE;
-      frame[offset+1] = code & BYTE;
-    }
-    buffer.copy(frame, offset + insert);
-
-    if (this._masking) {
-      mask = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256),
-              Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
-      new Buffer(mask).copy(frame, header);
-      HybiParser.mask(frame, mask, offset);
-    }
-
-    return frame;
-  },
-
-  ping: function(message, callback, context) {
-    message = message || '';
-    if (callback) this._pingCallbacks[message] = [callback, context];
-    return this._socket.send(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;
-  },
-
-  buffer: function(fragment) {
-    for (var i = 0, n = fragment.length; i < n; i++)
-      this._buffer.push(fragment[i]);
-  },
-
-  _emitFrame: function() {
-    var payload = HybiParser.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._final) {
-        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);
-      }
-    }
-    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);
-      } else {
-        this._mode = 'text';
-        this.buffer(payload);
-      }
-    }
-    else if (opcode === this.OPCODES.binary) {
-      if (this._final) {
-        this._socket.receive(payload);
-      } else {
-        this._mode = 'binary';
-        this.buffer(payload);
-      }
-    }
-    else if (opcode === this.OPCODES.close) {
-      var code   = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null,
-          reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
-
-      if (!(payload.length === 0) &&
-          !(code !== null && code >= 3000 && code < 5000) &&
-          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]);
-    }
-    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');
-    }
-    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]);
-    }
-  },
-
-  _reset: function() {
-    this._mode   = null;
-    this._buffer = [];
-  },
-
-  _encode: function(buffer) {
-    try {
-      var string = buffer.toString('binary', 0, buffer.length);
-      if (!this.UTF8_MATCH.test(string)) return null;
-    } catch (e) {}
-    return buffer.toString('utf8', 0, buffer.length);
-  },
-
-  _getInteger: function(bytes) {
-    var number = 0;
-    for (var i = 0, n = bytes.length; i < n; i++)
-      number += bytes[i] << (8 * (n - 1 - i));
-    return number;
-  }
-};
-
-for (var key in instance)
-  HybiParser.prototype[key] = instance[key];
-
-module.exports = HybiParser;
-
@@ -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;
@@ -1,43 +0,0 @@
-var StreamReader = function() {
-  this._queue  = [];
-  this._cursor = 0;
-};
-
-StreamReader.prototype.read = function(bytes) {
-  return this._readBuffer(bytes);
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!buffer.copy) buffer = new Buffer(buffer);
-  this._queue.push(buffer);
-};
-
-StreamReader.prototype._readBuffer = function(length) {
-  var buffer = new Buffer(length),
-      queue  = this._queue,
-      remain = length,
-      n      = queue.length,
-      i      = 0,
-      chunk, offset, size;
-
-  if (remain === 0) return buffer;
-
-  while (remain > 0 && i < n) {
-    chunk = queue[i];
-    offset = (i === 0) ? this._cursor : 0;
-    size = Math.min(remain, chunk.length - offset);
-    chunk.copy(buffer, length - remain, offset, offset + size);
-    remain -= size;
-    i += 1;
-  }
-
-  if (remain > 0) return null;
-
-  queue.splice(0, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
-
-  return buffer;
-};
-
-module.exports = StreamReader;
@@ -1,46 +0,0 @@
-// Protocol references:
-// 
-// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
-// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
-// * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
-
-var Hybi   = require('./protocol/hybi'),
-    Client = require('./protocol/client');
-
-var Protocol = {
-  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);
-    }
-  },
-
-  determineUrl: function(request) {
-    var scheme = this.isSecureConnection(request) ? 'wss:' : 'ws:';
-    return scheme + '//' + request.headers.host + request.url;
-  },
-
-  client: function(url, options) {
-    options = options || {};
-    options.masking = true;
-    return new Client(url, options);
-  },
-
-  http: function(request, options) {
-    return new Hybi(request, this.determineUrl(request), options);
-  },
-
-  isWebSocket: function(request) {
-    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 = Protocol;
-
@@ -1,134 +0,0 @@
-var Stream = require('stream'),
-    util   = require('util');
-
-// source: readable, pause(), resume(), on('data'), on('end'), on('close'), on('error')
-// dest: writable, write(chunk), end(), destroy(), on('drain'), on('error'), on('close')
-
-var DuplexStream = function(methods) {
-  for (var method in methods) this[method] = methods[method];
-  this.readable = this.writable = true;
-};
-util.inherits(DuplexStream, Stream);
-
-var Base = function(request, url, options) {
-  this._request   = request;
-  this._options   = options || {};
-  this.__queue    = [];
-  this.readyState = 0;
-  this.url        = url;
-
-  var self = this;
-
-  this.messages = new DuplexStream({
-    write: function(message) {
-      return self.frame(message);
-    },
-    end: function(message) {
-      this.write(message);
-      // TODO handle this properly
-    }
-  });
-
-  this.io = new DuplexStream({
-    write: function(chunk) {
-      return self.parse(chunk);
-    },
-    end: function(chunk) {
-      this.write(chunk);
-      // TODO handle this properly
-    }
-  });
-
-  this.messages.addListener('data', function(data) {
-    self._dispatch('onmessage', new Base.MessageEvent(data));
-  });
-};
-
-var instance = {
-  STATES: ['connecting', 'open', 'closing', 'closed'],
-
-  getState: function() {
-    return this.STATES[this.readyState];
-  },
-
-  start: function() {
-    if (this.readyState !== 0) return false;
-    this.io.emit('data', 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._dispatch('onclose', new Base.CloseEvent(null, null));
-    return true;
-  },
-
-  onopen: function(callback) {
-    if (callback) this._onopen = callback;
-    return this._onopen;
-  },
-
-  onmessage: function(callback) {
-    if (callback) this._onmessage = callback;
-    return this._onmessage;
-  },
-
-  onerror: function(callback) {
-    if (callback) this._onerror = callback;
-    return this._onerror;
-  },
-
-  onclose: function(callback) {
-    if (callback) this._onclose = callback;
-    return this._onclose;
-  },
-
-  _open: function() {
-    this.readyState = 1;
-    this.__queue.forEach(function(args) { this.frame.apply(this, args) }, this);
-    this.__queue = [];
-    this._dispatch('onopen', new Base.OpenEvent());
-  },
-
-  _dispatch: function(name, event) {
-    var handler = this[name]();
-    if (handler) handler(event);
-  },
-
-  _queue: function(message) {
-    this.__queue.push(message);
-    return true;
-  }
-};
-
-for (var key in instance)
-  Base.prototype[key] = instance[key];
-
-
-Base.OpenEvent = function() {};
-
-Base.CloseEvent = function(code, reason) {
-  this.code   = code;
-  this.reason = reason;
-};
-
-Base.MessageEvent = function(data) {
-  this.data = data;
-};
-
-module.exports = Base;
-
@@ -1,113 +0,0 @@
-var HTTPParser = process.binding('http_parser').HTTPParser,
-    url        = require('url'),
-    util       = require('util'),
-    Base       = require('./base'),
-    Hybi       = require('./hybi');
-
-var Client = function(url, options) {
-  Hybi.call(this, null, url, options);
-  this.client = true;
-
-  this.readyState = -1;
-  this._key       = Client.generateKey();
-  this._accept    = Hybi.generateAccept(this._key);
-
-  this._http     = new HTTPParser(HTTPParser.RESPONSE || 'response');
-  this._node     = HTTPParser.RESPONSE ? 6 : 4;
-  this._complete = false;
-  this._headers  = {};
-
-  var currentHeader = null,
-      self          = this;
-
-  this._http.onHeaderField = function(b, start, length) {
-    currentHeader = b.toString('utf8', start, start + length);
-  };
-  this._http.onHeaderValue = function(b, start, length) {
-    self._headers[currentHeader] = b.toString('utf8', start, start + length);
-  };
-  this._http.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];
-  };
-  this._http.onMessageComplete = function() {
-    self._complete = true;
-  };
-};
-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.io.emit('data', this._handshakeRequest());
-    this.readyState = 0;
-    return true;
-  },
-
-  parse: function(data) {
-    if (this.readyState > 0) return Hybi.prototype.parse.call(this, data);
-
-    var consumed = this._http.execute(data, 0, data.length),
-        offset   = (this._node < 6) ? 1 : 0; 
-
-    if (consumed <= data.length) {
-      if (this._isValid()) {
-        this._open();
-      } else {
-        this.readyState = 3;
-        this._dispatch('onclose', new Base.CloseEvent(this.ERRORS.protocol_error, ''));
-      }
-    }
-    if (consumed < data.length)
-      this.parse(data.slice(consumed + offset));
-  },
-
-  _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)
-      headers.push('Sec-WebSocket-Protocol: ' + this._protocols.join(', '));
-
-    return new Buffer(headers.concat('','').join('\r\n'), 'utf8');
-  },
-
-  _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.toLowerCase() === 'websocket' &&
-           connection.toLowerCase().split(/\s*,\s*/).indexOf('upgrade') >= 0 &&
-           ((!this._protocols && !protocol) || this.protocol) &&
-           this._headers['Sec-WebSocket-Accept'] === this._accept;
-  }
-};
-
-for (var key in instance)
-  Client.prototype[key] = instance[key];
-
-module.exports = Client;
-
@@ -1,385 +0,0 @@
-var crypto   = require('crypto'),
-    util     = require('util'),
-    Base     = require('./base'),
-    Reader   = require('./hybi/stream_reader');
-
-var Hybi = function(request, url, options) {
-  Base.apply(this, arguments);
-  this._reset();
-
-  this._reader    = new Reader();
-  this._stage     = 0;
-  this._masking   = this._options.masking;
-  this._protocols = this._options.protocols;
-
-  if (typeof this._protocols === 'string')
-    this._protocols = this._protocols.split(/\s*,\s*/);
-
-  this._requireMasking = this._options.requireMasking;
-  this._pingCallbacks  = {};
-};
-util.inherits(Hybi, Base);
-
-Hybi.mask = function(payload, mask, offset) {
-  if (mask.length === 0) return payload;
-  offset = offset || 0;
-
-  for (var i = 0, n = payload.length - offset; i < n; i++) {
-    payload[offset + i] = payload[offset + i] ^ mask[i % 4];
-  }
-  return payload;
-};
-
-Hybi.generateAccept = function(key) {
-  var sha1 = crypto.createHash('sha1');
-  sha1.update(key + Hybi.GUID);
-  return sha1.digest('base64');
-};
-
-Hybi.GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
-
-var instance = {
-  BYTE:   255,
-  FIN:    128,
-  MASK:   128,
-  RSV1:   64,
-  RSV2:   32,
-  RSV3:   16,
-  OPCODE: 15,
-  LENGTH: 127,
-
-  OPCODES: {
-    continuation: 0,
-    text:         1,
-    binary:       2,
-    close:        8,
-    ping:         9,
-    pong:         10
-  },
-
-  FRAGMENTED_OPCODES: [0,1,2],
-  OPENING_OPCODES:    [1,2],
-
-  ERRORS: {
-    normal_closure:       1000,
-    going_away:           1001,
-    protocol_error:       1002,
-    unacceptable:         1003,
-    encoding_error:       1007,
-    policy_violation:     1008,
-    too_large:            1009,
-    extension_error:      1010,
-    unexpected_condition: 1011
-  },
-
-  ERROR_CODES: [1000,1001,1002,1003,1007,1008,1009,1010,1011],
-
-  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._request.headers['sec-websocket-version'];
-    return 'hybi-' + version;
-  },
-
-  parse: function(data) {
-    this._reader.put(data);
-    var buffer = true;
-    while (buffer) {
-      switch (this._stage) {
-        case 0:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseOpcode(buffer[0]);
-          break;
-
-        case 1:
-          buffer = this._reader.read(1);
-          if (buffer) this._parseLength(buffer[0]);
-          break;
-
-        case 2:
-          buffer = this._reader.read(this._lengthSize);
-          if (buffer) this._parseExtendedLength(buffer);
-          break;
-
-        case 3:
-          buffer = this._reader.read(4);
-          if (buffer) {
-            this._mask  = buffer;
-            this._stage = 4;
-          }
-          break;
-
-        case 4:
-          buffer = this._reader.read(this._length);
-          if (buffer) {
-            this._payload = buffer;
-            this._emitFrame();
-            this._stage = 0;
-          }
-          break;
-      }
-    }
-  },
-
-  frame: function(data, type, code) {
-    if (this.readyState === 0) return this._queue([data, type, code]);
-    if (this.readyState !== 1) return false;
-
-    var isText = (typeof data === 'string'),
-        opcode = this.OPCODES[type || (isText ? 'text' : 'binary')],
-        buffer = isText ? new Buffer(data, 'utf8') : data,
-        insert = code ? 2 : 0,
-        length = buffer.length + insert,
-        header = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10),
-        offset = header + (this._masking ? 4 : 0),
-        masked = this._masking ? this.MASK : 0,
-        frame  = new Buffer(length + offset),
-        BYTE   = this.BYTE,
-        mask, i;
-
-    frame[0] = this.FIN | opcode;
-
-    if (length <= 125) {
-      frame[1] = masked | length;
-    } else if (length <= 65535) {
-      frame[1] = masked | 126;
-      frame[2] = Math.floor(length / 256);
-      frame[3] = length & BYTE;
-    } else {
-      frame[1] = masked | 127;
-      frame[2] = Math.floor(length / Math.pow(2,56)) & BYTE;
-      frame[3] = Math.floor(length / Math.pow(2,48)) & BYTE;
-      frame[4] = Math.floor(length / Math.pow(2,40)) & BYTE;
-      frame[5] = Math.floor(length / Math.pow(2,32)) & BYTE;
-      frame[6] = Math.floor(length / Math.pow(2,24)) & BYTE;
-      frame[7] = Math.floor(length / Math.pow(2,16)) & BYTE;
-      frame[8] = Math.floor(length / Math.pow(2,8))  & BYTE;
-      frame[9] = length & BYTE;
-    }
-
-    if (code) {
-      frame[offset]   = Math.floor(code / 256) & BYTE;
-      frame[offset+1] = code & BYTE;
-    }
-    buffer.copy(frame, offset + insert);
-
-    if (this._masking) {
-      mask = [Math.floor(Math.random() * 256), Math.floor(Math.random() * 256),
-              Math.floor(Math.random() * 256), Math.floor(Math.random() * 256)];
-      new Buffer(mask).copy(frame, header);
-      Hybi.mask(frame, mask, offset);
-    }
-
-    this.io.emit('data', frame);
-    return true;
-  },
-
-  text: function(message) {
-    return this.frame(message, 'text');
-  },
-
-  binary: function(message) {
-    return this.frame(message, 'binary');
-  },
-
-  ping: function(message, callback) {
-    message = message || '';
-    if (callback) this._pingCallbacks[message] = callback;
-    return this.frame(message, 'ping');
-  },
-
-  close: function(reason, code) {
-    reason = reason || '';
-    code   = code   || this.ERRORS.normal_closure;
-
-    if (this.readyState === 0) {
-      this.readyState = 3;
-      this._dispatch('onclose', new Base.CloseEvent(code, reason));
-      return true;
-    } else if (this.readyState === 1) {
-      this.frame(reason, 'close', code);
-      this.readyState = 2;
-      return true;
-    } else {
-      return false;
-    }
-  },
-
-  _handshakeResponse: function() {
-    var secKey = this._request.headers['sec-websocket-key'];
-    if (!secKey) return '';
-
-    var accept    = Hybi.generateAccept(secKey),
-        protos    = this._request.headers['sec-websocket-protocol'],
-        supported = this._protocols,
-        proto,
-
-        headers = [
-          'HTTP/1.1 101 Switching Protocols',
-          'Upgrade: websocket',
-          'Connection: Upgrade',
-          'Sec-WebSocket-Accept: ' + accept
-        ];
-
-    if (protos !== undefined && 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');
-  },
-
-  _shutdown: function(code, reason) {
-    code   = code || this.ERRORS.normal_closure;
-    reason = reason || '';
-
-    this.frame(reason, 'close', code);
-    this.readyState = 3;
-    this._dispatch('onclose', new Base.CloseEvent(code, reason));
-  },
-
-  _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._shutdown(this.ERRORS.protocol_error, null);
-
-    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._shutdown(this.ERRORS.protocol_error, null);
-
-    if (this.FRAGMENTED_OPCODES.indexOf(this._opcode) < 0 && !this._final)
-      return this._shutdown(this.ERRORS.protocol_error, null);
-
-    if (this._mode && this.OPENING_OPCODES.indexOf(this._opcode) >= 0)
-      return this._shutdown(this.ERRORS.protocol_error, null);
-
-    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;
-  },
-
-  _emitFrame: function() {
-    var payload = Hybi.mask(this._payload, this._mask),
-        opcode  = this._opcode;
-
-    if (opcode === this.OPCODES.continuation) {
-      if (!this._mode) return this._shutdown(this.ERRORS.protocol_error, null);
-      this._buffer(payload);
-      if (this._final) {
-        var message = new Buffer(this.__buffer);
-        if (this._mode === 'text') message = this._encode(message);
-        this._reset();
-        if (message !== null) this.messages.emit('data', message);
-        else this._shutdown(this.ERRORS.encoding_error, null, false);
-      }
-    }
-    else if (opcode === this.OPCODES.text) {
-      if (this._final) {
-        var message = this._encode(payload);
-        if (message !== null) this.messages.emit('data', message);
-        else this._shutdown(this.ERRORS.encoding_error, null);
-      } else {
-        this._mode = 'text';
-        this._buffer(payload);
-      }
-    }
-    else if (opcode === this.OPCODES.binary) {
-      if (this._final) {
-        this.messages.emit('data', payload);
-      } else {
-        this._mode = 'binary';
-        this._buffer(payload);
-      }
-    }
-    else if (opcode === this.OPCODES.close) {
-      var code   = (payload.length >= 2) ? 256 * payload[0] + payload[1] : null,
-          reason = (payload.length > 2) ? this._encode(payload.slice(2)) : null;
-
-      if (!(payload.length === 0) &&
-          !(code !== null && code >= 3000 && code < 5000) &&
-          this.ERROR_CODES.indexOf(code) < 0)
-        code = this.ERRORS.protocol_error;
-
-      if (payload.length > 125 || (payload.length > 2 && !reason))
-        code = this.ERRORS.protocol_error;
-
-      this._shutdown(code, (payload.length > 2) ? reason : null);
-      if (this._closingCallback)
-        this._closingCallback[0].call(this._closingCallback[1]);
-    }
-    else if (opcode === this.OPCODES.ping) {
-      if (payload.length > 125) return this._shutdown(this.ERRORS.protocol_error, null);
-      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]);
-    }
-  },
-
-  _buffer: function(fragment) {
-    for (var i = 0, n = fragment.length; i < n; i++)
-      this.__buffer.push(fragment[i]);
-  },
-
-  _reset: function() {
-    this._mode    = null;
-    this.__buffer = [];
-  },
-
-  _encode: function(buffer) {
-    try {
-      var string = buffer.toString('binary', 0, buffer.length);
-      if (!this.UTF8_MATCH.test(string)) return null;
-    } catch (e) {}
-    return buffer.toString('utf8', 0, buffer.length);
-  },
-
-  _getInteger: function(bytes) {
-    var number = 0;
-    for (var i = 0, n = bytes.length; i < n; i++)
-      number += bytes[i] << (8 * (n - 1 - i));
-    return number;
-  }
-};
-
-for (var key in instance)
-  Hybi.prototype[key] = instance[key];
-
-module.exports = Hybi;
-
@@ -1,43 +0,0 @@
-var StreamReader = function() {
-  this._queue  = [];
-  this._cursor = 0;
-};
-
-StreamReader.prototype.read = function(bytes) {
-  return this._readBuffer(bytes);
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!buffer.copy) buffer = new Buffer(buffer);
-  this._queue.push(buffer);
-};
-
-StreamReader.prototype._readBuffer = function(length) {
-  var buffer = new Buffer(length),
-      queue  = this._queue,
-      remain = length,
-      n      = queue.length,
-      i      = 0,
-      chunk, offset, size;
-
-  if (remain === 0) return buffer;
-
-  while (remain > 0 && i < n) {
-    chunk = queue[i];
-    offset = (i === 0) ? this._cursor : 0;
-    size = Math.min(remain, chunk.length - offset);
-    chunk.copy(buffer, length - remain, offset, offset + size);
-    remain -= size;
-    i += 1;
-  }
-
-  if (remain > 0) return null;
-
-  queue.splice(0, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
-
-  return buffer;
-};
-
-module.exports = StreamReader;
@@ -3,24 +3,20 @@
 , "homepage"        : "http://github.com/faye/faye-websocket-node"
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
 , "keywords"        : ["websocket", "eventsource"]
+, "license"         : "MIT"

-, "version"         : "0.4.4"
+, "version"         : "0.6.1"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/faye/websocket"
-, "devDependencies" : {"jsclass": "", "pace": ""}
+, "dependencies"    : {"websocket-driver": ">=0.2.0"}
+, "devDependencies" : {"jstest": "", "pace": ""}

-, "scripts"         : {"test": "node spec/runner.js"}
+, "scripts"         : {"test": "jstest spec/runner.js"}
+
+, "repository"      : { "type"  : "git"
+                      , "url"   : "git://github.com/faye/faye-websocket-node.git"
+                      }

 , "bugs"            : "http://github.com/faye/faye-websocket-node/issues"
-
-, "licenses"        : [ { "type"  : "MIT"
-                        , "url"   : "http://www.opensource.org/licenses/mit-license.php"
-                        }
-                      ]
-
-, "repositories"    : [ { "type"  : "git"
-                        , "url"   : "git://github.com/faye/faye-websocket-node.git"
-                        }
-                      ]
 }

@@ -1,6 +1,8 @@
-var Client = require('../../../lib/faye/websocket/client')
+var Client = require('../../../lib/faye/websocket/client'),
+    test   = require('jstest').Test,
+    fs     = require('fs')

-JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
+var WebSocketSteps = test.asyncSteps({
  server: function(port, secure, callback) {
    this._adapter = new EchoServer()
    this._adapter.listen(port, secure)
@@ -24,7 +26,9 @@ JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
                   callback()
                 }

-    this._ws = new Client(url, protocols, {verify: false})
+    this._ws = new Client(url, protocols, {
+      ca: fs.readFileSync(__dirname + '/../../server.crt')
+    })

    this._ws.onopen  = function() { resume(true)  }
    this._ws.onclose = function() { resume(false) }
@@ -77,13 +81,14 @@ JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
 })


-JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
+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"
+    this.plain_text_url  = "ws://localhost:4180/bayeux"
+    this.secure_url      = "wss://localhost:4180/bayeux"
+    this.port            = 4180
  })

  sharedBehavior("socket client", function() { with(this) {
@@ -93,11 +98,6 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
      check_protocol("echo")
    }})

-    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()
@@ -154,7 +154,7 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
      this.blocked_url = this.secure_url
    })

-    before(function() { this.server(8000, false) })
+    before(function() { this.server(4180, false) })
    after (function() { this.stop() })

    behavesLike("socket client")
@@ -166,7 +166,7 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
      this.blocked_url = this.plain_text_url
    })

-    before(function() { this.server(8000, true) })
+    before(function() { this.server(4180, true) })
    after (function() { this.stop() })

    behavesLike("socket client")
@@ -1,12 +1,11 @@
-require('jsclass')
-
 var WebSocket = require('../lib/faye/websocket'),
    fs        = require('fs'),
    http      = require('http'),
-    https     = require('https')
+    https     = require('https'),
+    test      = require('jstest').Test


-JS.ENV.EchoServer = function() {}
+EchoServer = function() {}
 EchoServer.prototype.listen = function(port, ssl) {
  var server = ssl
             ? https.createServer({
@@ -15,7 +14,7 @@ EchoServer.prototype.listen = function(port, ssl) {
               })
             : http.createServer()

-  server.addListener('upgrade', function(request, socket, head) {
+  server.on('upgrade', function(request, socket, head) {
    var ws = new WebSocket(request, socket, head, ["echo"])
    ws.pipe(ws)
  })
@@ -23,22 +22,12 @@ EchoServer.prototype.listen = function(port, ssl) {
  server.listen(port)
 }
 EchoServer.prototype.stop = function(callback, scope) {
-  this._httpServer.addListener('close', function() {
+  this._httpServer.on('close', function() {
    if (callback) callback.call(scope);
  });
  this._httpServer.close();
 }


-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);
-  })
-
-  require('./faye/websocket/client_spec')
-  JS.Test.autorun()
-})
+require('./faye/websocket/client_spec')

@@ -1,15 +1,14 @@
 -----BEGIN CERTIFICATE-----
-MIICZTCCAc4CCQDxyrJZrFA0vjANBgkqhkiG9w0BAQUFADB3MQswCQYDVQQGEwJV
-SzEPMA0GA1UECBMGTG9uZG9uMQ8wDQYDVQQHEwZMb25kb24xDTALBgNVBAoTBEZh
-eWUxFTATBgNVBAMTDEphbWVzIENvZ2xhbjEgMB4GCSqGSIb3DQEJARYRamNvZ2xh
-bkBnbWFpbC5jb20wHhcNMTEwODMwMTIzOTM2WhcNMTIwODI5MTIzOTM2WjB3MQsw
-CQYDVQQGEwJVSzEPMA0GA1UECBMGTG9uZG9uMQ8wDQYDVQQHEwZMb25kb24xDTAL
-BgNVBAoTBEZheWUxFTATBgNVBAMTDEphbWVzIENvZ2xhbjEgMB4GCSqGSIb3DQEJ
-ARYRamNvZ2xhbkBnbWFpbC5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
-AMDjU5fAK7fvUCZIYHcGXDZD/m9bY+B/UcwGcowk0hMQGYNlLKrpiK7xXBmZpDb6
-r8n+7L/epBeSumbRIm4TDzeNHhuQGYLIeGQy7JNLoPBr6GxubjuJhKOOBnCqcupR
-CLGG7Zw5oL4UvtZVH6kL9XnjyokQQbxxeoV9DqtqOaHHAgMBAAEwDQYJKoZIhvcN
-AQEFBQADgYEAvQjSpzE1ahaeH1CmbLwckTxvWMZfxcZOrxTruK1po3cNnDOjGqFQ
-KEkNj3K5WfwTBD4QgUdYDykhDX2m6HaMz4JEbgrwQv8M8FiswIA3dyGsbOifOk8H
-r3GPNKMzm4o6vrn6RGOpt9q6bsWUBUHfNpP93uU2C9QEwDua3cFjDA0=
+MIICKTCCAZICCQDtAJo/efrTvjANBgkqhkiG9w0BAQUFADBZMQswCQYDVQQGEwJV
+SzETMBEGA1UECBMKU29tZS1TdGF0ZTEPMA0GA1UEBxMGTG9uZG9uMRAwDgYDVQQK
+EwdqY29nbGFuMRIwEAYDVQQDEwlsb2NhbGhvc3QwHhcNMTMwNjE5MDcwNzQ1WhcN
+MTQwNjE5MDcwNzQ1WjBZMQswCQYDVQQGEwJVSzETMBEGA1UECBMKU29tZS1TdGF0
+ZTEPMA0GA1UEBxMGTG9uZG9uMRAwDgYDVQQKEwdqY29nbGFuMRIwEAYDVQQDEwls
+b2NhbGhvc3QwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALhPVRbctfcjCJEC
+DsZfgtTMVYMsvV/miLxc7veumuuApe5y3DFuG8Tlz3/0wrvRm3dCSUOfIBK8ktor
+VoY6QGHwrhYK2MhnJQOUTYC+FCyUp4zAYjRgJWd4uTii+uqRbLCPOF8jEx7VunTT
+Lj9hu82IdRgT3OtqzPUoTmYXCXSZAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAcARo
+TO7LTbII0HIsB7PePspFkwiuYQtvFqYm10I+4yuIdfPBdH0/OBhKvNC1O7tc7dmy
+NPd8e5FXrt6qHDgCVh0kpg37sMJp42jUCn4lguWKN5dZPkzGrRFUfXvcx1qwdF2T
+0CgyULvKWl9wt3Wp5feG8dNn1UZOGlZBZ+0GNyk=
 -----END CERTIFICATE-----
@@ -1,15 +1,15 @@
 -----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=
+MIICXAIBAAKBgQC4T1UW3LX3IwiRAg7GX4LUzFWDLL1f5oi8XO73rprrgKXuctwx
+bhvE5c9/9MK70Zt3QklDnyASvJLaK1aGOkBh8K4WCtjIZyUDlE2AvhQslKeMwGI0
+YCVneLk4ovrqkWywjzhfIxMe1bp00y4/YbvNiHUYE9zrasz1KE5mFwl0mQIDAQAB
+AoGAfcTc6oHnxeHpKZJ+5I0uaOmafK2d+IAG1IqSIv/KBWQ/VoyYhz58woqTYtxx
+udqZvPLFrdg6+a4mg6vJGkVLwp/PFi7r57/vqUR/P8SnuV0iTJZ7BczZHSffdzgT
+9v2XUDFZ3ZSjIi+XkCMirHc7G8BVYImqjCGy80NX3YB5RRECQQDuX+udSSZi2I0C
+gT/LnoVsb8JkanNALZH/U/XQog50I9aNf2GAAboUVsGuETL3I9f12Ku0A+xK5biv
+s4P4g01FAkEAxfALp1Yzud+ooNmbbtSTE6hrUwjFeG1skEW4GvocB5ZiQqXwv59v
+AmWedup7St2kamb5vNtcpewHGd2kUpatRQJARDwg7f0qh9EFTFpDML5H4yp6stPl
+dERoc0e6IH7MTOxDwAPoNzdr0TGXFWACU6xWyaSwAz/btEjdOgmNtUfIQJAFrWO
+sLksIBQwBZxRv+p1oVi+T31/Imzzeq31DGtLkfdH+LuPHn0NQGomPyBx2soJFggQ
+eQF15LdqrSYHt04APQJBAO2SPMC7MxDKdhryf6PDcaL/lTKSxRttQ72jZmDU9ujp
+dcvFPgrQTa3iNLm4SWvARFXXZrrGEeDgKX7jVJygfI4=
 -----END RSA PRIVATE KEY-----
Author	SHA1	Message	Date
James Coglan	067df9aaf4	Bump version to 0.6.1.	2013-07-05 15:18:10 +01:00
James Coglan	c6b40aefbb	Older Nodes don't support chained pipe().	2013-07-05 11:15:36 +01:00
James Coglan	a68ff2c035	Start the driver asynchronously on the server to allow onopen hooks to be registered.	2013-07-04 21:55:30 +01:00
James Coglan	da424b7d71	Modernize package.json.	2013-07-01 02:21:41 +01:00
James Coglan	f2c08de98f	Migrate to jstest.	2013-07-01 02:20:52 +01:00
James Coglan	bbdbf1cb46	Correct package.json formatting.	2013-06-23 01:13:50 +01:00
James Coglan	d5d4d9e009	Merge pull request #22 from cezor/master Use singular repository to avoid warning	2013-06-22 17:12:14 -07:00
James Coglan	8a8e44b283	Support the 'ca' option to client connections, and remove the verify: false option.	2013-06-19 08:09:19 +01:00
Nick Nissen	db9bbba6bc	renamed repossitories keyword	2013-06-16 22:13:53 +02:00
Nick Nissen	085d8d2b43	Use singular repository to avoid warning	2013-06-15 13:54:20 +02:00
James Coglan	ad572ca5e0	Turn the reflexive piping into a one-liner.	2013-05-29 02:21:53 +01:00
James Coglan	b861f1a779	Woops, left a console.log in.	2013-05-12 15:04:10 +01:00
James Coglan	047f87e4cd	Set status and headers on error, not just on open.	2013-05-12 14:44:57 +01:00
James Coglan	d6728e115d	Add support for custom handshake headers.	2013-05-12 14:39:30 +01:00
James Coglan	15aedb7ca3	Make mention of streams more prominent.	2013-05-05 09:54:47 +01:00
James Coglan	7e9149faff	Remove .redcar from .npmignore.	2013-05-05 01:51:52 +01:00
James Coglan	7fc369fc82	Bump version to 0.5.0.	2013-05-05 01:47:37 +01:00
James Coglan	ec4ba0eb74	Use pipe() for the Autobahn echo client.	2013-05-05 00:01:17 +01:00
James Coglan	d9475f5b07	Don't end the EventSource when piping a file into it.	2013-05-04 21:37:46 +01:00
James Coglan	c68b3fdc46	Remove the websocket-driver submodule.	2013-05-04 20:45:26 +01:00
James Coglan	827af89809	Refer to 3rd 'upgrade' argument as 'body' instead of 'head'.	2013-05-04 17:37:53 +01:00
James Coglan	0d503a31e3	Return a normal HTTP response if the request is not a WebSocket in the documentation.	2013-05-04 17:33:57 +01:00
James Coglan	99fa7a57ca	Various bits of stream-related refactoring.	2013-05-04 17:30:07 +01:00
James Coglan	b0b39b8325	websocket-protocol is now websocket-driver.	2013-05-04 16:43:03 +01:00
James Coglan	77ee71c678	A few updates to the readme.	2013-05-04 15:09:45 +01:00
James Coglan	fc759a66e9	s/this/self/ because otherwise error dispatching doesn't work.	2013-05-02 01:26:16 +01:00
James Coglan	459499d6d6	Expose parser error events to the user.	2013-05-02 00:12:56 +01:00
James Coglan	30d3eda575	Don't return anything from EventTarget methods.	2013-05-01 09:07:55 +01:00
James Coglan	699c023286	Turn EventTarget into a proxy to EventEmitter since classes are now Streams.	2013-05-01 08:57:53 +01:00
James Coglan	9ff5d28799	Implement EventSource as a writable stream.	2013-05-01 08:50:27 +01:00
James Coglan	43bd4dceb3	Change port used for tests.	2013-05-01 01:14:51 +01:00
James Coglan	971968be85	Rename supportedProtos to protocols.	2013-05-01 01:03:27 +01:00
James Coglan	2a2b7dfb11	Bump websocket-protocol.	2013-05-01 01:00:14 +01:00
James Coglan	83925f68d3	The protocol library now uses a version property instead of a getVersion() method.	2013-05-01 00:56:23 +01:00
James Coglan	ee3212fada	Implement the read/write stream interface on the API class.	2013-05-01 00:32:14 +01:00
James Coglan	789759bf07	Move most WebSocket logic into the API class so that the server and client classes just deal with getting a parser and setting up an IO stream.	2013-05-01 00:14:05 +01:00
James Coglan	3baa12600a	Write the request body to the IO stream before piping the request socket in.	2013-04-30 23:48:11 +01:00
James Coglan	339cc7ad1c	Bump websocket-protocol module and support legacy stream interface.	2013-04-30 23:36:54 +01:00
James Coglan	fdd5cc6db2	Migrate to new protocol event API.	2013-04-30 09:07:06 +01:00
James Coglan	36d4e053d8	Bump the websocket-protocol submodule.	2013-04-29 22:35:28 +01:00
James Coglan	347e5df9a2	Bump the websocket-protocol submodule.	2013-04-29 21:51:58 +01:00
James Coglan	96d31cf694	Remove the hixie protocol handlers, they're now in websocket-protocol.	2013-04-29 21:45:03 +01:00
James Coglan	4ccd6f5a59	Bump the websocket-protocol submodule.	2013-04-29 21:36:46 +01:00
James Coglan	56f9b8ec4d	Write the head to the handler so that draft-76 works.	2013-04-29 20:47:03 +01:00
James Coglan	217b32c383	Bump the websocket-protocol submodule.	2013-04-29 20:28:05 +01:00
James Coglan	6571e070a0	Remove some unneeded test code.	2013-04-29 19:08:38 +01:00
James Coglan	7e5d85278d	Fix TCP error-catching. We should probably fix this in websocket-protocol instead, maybe.	2013-04-29 00:59:42 +01:00
James Coglan	178b2eebde	Reinstate the exported Client.	2013-04-29 00:46:16 +01:00
James Coglan	e6dd7b0749	Remove old Hybi parsers and update websocket-protocol submodule.	2013-04-29 00:20:01 +01:00
James Coglan	ad4ca36a8c	Move protocol handlers into a submodule.	2013-04-28 19:08:10 +01:00