Bump version to 0.9.0 and document how to add extensions.

Revert 29d07c5; see https://github.com/faye/faye-websocket-node/pull/34
Merge pull request #34 from lpinca/fix/close-on-handshake
2014-12-13 14:03:37 +00:00 · 2014-12-13 01:25:33 +00:00 · 2014-12-13 00:15:22 +00:00 · 2014-12-06 10:51:18 +00:00 · 2014-11-26 16:08:05 +01:00 · 2014-11-24 22:05:56 +00:00
36 changed files with 1096 additions and 2092 deletions
@@ -1,6 +1,6 @@
 .git
 .gitignore
 .npmignore
-.redcar
 .travis.yml
 node_modules
+spec
@@ -1,8 +1,6 @@
 language: node_js

 node_js:
-  - "0.6"
  - "0.8"
  - "0.10"
  - "0.11"
-
@@ -0,0 +1,115 @@
+### 0.9.0 / 2014-12-13
+
+* Allow protocol extensions to be passed into websocket-extensions
+
+
+### 0.8.1 / 2014-11-12
+
+* Send the correct hostname when upgrading a connection to TLS
+
+
+### 0.8.0 / 2014-11-08
+
+* Support connections via HTTP proxies
+* Close the connection cleanly if we're still waiting for a handshake response
+
+
+### 0.7.3 / 2014-10-04
+
+* Allow sockets to be closed when they are in any state other than `CLOSED`
+
+
+### 0.7.2 / 2013-12-29
+
+* Make sure the `close` event is emitted by clients on Node v0.10
+
+
+### 0.7.1 / 2013-12-03
+
+* Support the `maxLength` websocket-driver option
+* Make the client emit `error` events on network errors
+
+
+### 0.7.0 / 2013-09-09
+
+* Allow the server to send custom headers with EventSource responses
+
+
+### 0.6.1 / 2013-07-05
+
+* Add `ca` option to the client for specifying certificate authorities
+* Start the server driver asynchronously so that `onopen` handlers can be added
+
+
+### 0.6.0 / 2013-05-12
+
+* Add support for custom headers
+
+
+### 0.5.0 / 2013-05-05
+
+* Extract the protocol handlers into the `websocket-driver` library
+* Support the Node streaming API
+
+
+### 0.4.4 / 2013-02-14
+
+* Emit the `close` event if TCP is closed before CLOSE frame is acked
+
+
+### 0.4.3 / 2012-07-09
+
+* Add `Connection: close` to EventSource response
+* Handle situations where `request.socket` is undefined
+
+
+### 0.4.2 / 2012-04-06
+
+* Add WebSocket error code `1011`.
+* Handle URLs with no path correctly by sending `GET /`
+
+
+### 0.4.1 / 2012-02-26
+
+* Treat anything other than a `Buffer` as a string when calling `send()`
+
+
+### 0.4.0 / 2012-02-13
+
+* Add `ping()` method to server-side `WebSocket` and `EventSource`
+* Buffer `send()` calls until the draft-76 handshake is complete
+* Fix HTTPS problems on Node 0.7
+
+
+### 0.3.1 / 2012-01-16
+
+* Call `setNoDelay(true)` on `net.Socket` objects to reduce latency
+
+
+### 0.3.0 / 2012-01-13
+
+* Add support for `EventSource` connections
+
+
+### 0.2.0 / 2011-12-21
+
+* Add support for `Sec-WebSocket-Protocol` negotiation
+* Support `hixie-76` close frames and 75/76 ignored segments
+* Improve performance of HyBi parsing/framing functions
+* Decouple parsers from TCP and reduce write volume
+
+
+### 0.1.2 / 2011-12-05
+
+* Detect closed sockets on the server side when TCP connection breaks
+* Make `hixie-76` sockets work through HAProxy
+
+
+### 0.1.1 / 2011-11-30
+
+* Fix `addEventListener()` interface methods
+
+
+### 0.1.0 / 2011-11-27
+
+* Initial release, based on WebSocket components from Faye
@@ -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,338 @@
+# faye-websocket
+
+* Travis CI build: [![Build
+  status](https://secure.travis-ci.org/faye/faye-websocket-node.svg)](http://travis-ci.org/faye/faye-websocket-node)
+* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/),
+  [client](http://faye.jcoglan.com/autobahn/clients/)
+
+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.
+
+To connect via a proxy, set the `proxy` option to the HTTP origin of the proxy,
+including any authorization information, custom headers and TLS config you
+require. Only the `origin` setting is required.
+
+```js
+var ws = new WebSocket.Client('ws://www.example.com/', null, {
+  proxy: {
+    origin:  'http://username:password@proxy.example.com',
+    headers: {'User-Agent': 'node'},
+    tls:     {cert: fs.readFileSync('client.crt')}
+  }
+});
+```
+
+The `tls` value is a Node 'TLS options' object that will be passed to
+[`tls.connect()`](http://nodejs.org/api/tls.html#tls_tls_connect_options_callback).
+
+
+## Subprotocol negotiation
+
+The WebSocket protocol allows peers to select and identify the application
+protocol to use over the connection. On the client side, you can set which
+protocols the client accepts by passing a list of protocol names when you
+construct the socket:
+
+```js
+var ws = new WebSocket.Client('ws://www.example.com/', ['irc', 'amqp']);
+```
+
+On the server side, you can likewise pass in the list of protocols the server
+supports after the other constructor arguments:
+
+```js
+var ws = new WebSocket(request, socket, body, ['irc', 'amqp']);
+```
+
+If the client and server agree on a protocol, both the client- and server-side
+socket objects expose the selected protocol through the `ws.protocol` property.
+
+
+## Protocol extensions
+
+faye-websocket is based on the
+[websocket-extensions](https://github.com/faye/websocket-extensions-node)
+framework that allows extensions to be negotiated via the
+`Sec-WebSocket-Extensions` header. To add extensions to a connection, pass an
+array of extensions to the `:extensions` option. For example, to add
+[permessage-deflate](https://github.com/faye/permessage-deflate-node):
+
+```js
+var deflate = require('permessage-deflate');
+
+var ws = new WebSocket(request, null, {extensions: [deflate]});
+```
+
+
+## Initialization options
+
+Both the server- and client-side classes allow an options object to be passed
+in at initialization time, for example:
+
+```js
+var ws = new WebSocket(request, socket, body, protocols, options);
+var ws = new WebSocket.Client(url, protocols, options);
+```
+
+`protocols` is an array of subprotocols as described above, or `null`.
+`options` is an optional object containing any of these fields:
+
+* `extensions` - an array of
+  [websocket-extensions](https://github.com/faye/websocket-extensions-node)
+  compatible extensions, as described above
+* `headers` - an object containing key-value pairs representing HTTP headers to
+  be sent during the handshake process
+* `maxLength` - the maximum allowed size of incoming message frames, in bytes.
+  The default value is `2^26 - 1`, or 1 byte short of 64 MiB.
+* `ping` - an integer that sets how often the WebSocket should send ping
+  frames, measured in seconds
+
+The client accepts some additional options:
+
+* `proxy` - settings for a proxy as described above
+* `tls` - a Node 'TLS options' object containing TLS settings for the origin
+  server, this will be passed to
+  [`tls.connect()`](http://nodejs.org/api/tls.html#tls_tls_connect_options_callback)
+* `ca` - (legacy) a shorthand for passing `{tls: {ca: value}}`
+
+
+## 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>`headers`</b> is an object containing custom headers to be set on the
+  EventSource response.
+* <b>`retry`</b> is a number that tells the client how long (in seconds) it
+  should wait after a dropped connection before attempting to reconnect.
+* <b>`ping`</b> is a number that tells the server how often (in seconds) to
+  send 'ping' packets to the client to keep the connection open, to defeat
+  timeouts set by proxies. The client will ignore these messages.
+
+For example, this creates a connection that allows access from any origin, pings
+every 15 seconds and is retryable every 10 seconds if the connection is broken:
+
+```js
+var es = new EventSource(request, response, {
+  headers: {'Access-Control-Allow-Origin': '*'},
+  ping:    15,
+  retry:   10
+});
+```
+
+You can send a ping message at any time by calling `es.ping()`. Unlike
+WebSocket, the client does not send a response to this; it is merely to send
+some data over the wire to keep the connection alive.
+
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2010-2014 James Coglan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the 'Software'), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
@@ -1,13 +1,14 @@
 var WebSocket = require('../lib/faye/websocket'),
+    deflate   = require('permessage-deflate'),
    pace      = require('pace');

-var host  = 'ws://localhost:9001',
-    agent = 'Node ' + process.version,
-    cases = 0,
-    skip  = [];
+var host    = 'ws://localhost:9001',
+    agent   = encodeURIComponent('node-' + process.version),
+    cases   = 0,
+    options = {extensions: [deflate]};

 var socket = new WebSocket.Client(host + '/getCaseCount'),
-    progress;
+    url, progress;

 socket.onmessage = function(event) {
  console.log('Total cases to run: ' + event.data);
@@ -15,30 +16,24 @@ socket.onmessage = function(event) {
  progress = pace(cases);
 };

-socket.onclose = function() {
-  var runCase = function(n) {
+var runCase = function(n) {
+  if (n > cases) {
+    url = host + '/updateReports?agent=' + agent;
+    socket = new WebSocket.Client(url);
+    socket.onclose = process.exit;
+    return;
+  }
+
+  url = host + '/runCase?case=' + n + '&agent=' + agent;
+  socket = new WebSocket.Client(url, null, options);
+  socket.pipe(socket);
+
+  socket.on('close', function() {
    progress.op();
-
-    if (n > cases) {
-      socket = new WebSocket.Client(host + '/updateReports?agent=' + encodeURIComponent(agent));
-      socket.onclose = process.exit;
-
-    } else if (skip.indexOf(n) >= 0) {
-      runCase(n + 1);
-
-    } else {
-      socket = new WebSocket.Client(host + '/runCase?case=' + n + '&agent=' + encodeURIComponent(agent));
-
-      socket.onmessage = function(event) {
-        socket.send(event.data);
-      };
-
-      socket.onclose = function() {
-        runCase(n + 1);
-      };
-    }
-  };
-
-  runCase(1);
+    runCase(n + 1);
+  });
 };

+socket.onclose = function() {
+  runCase(1);
+};
@@ -1,22 +1,25 @@
 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 + '/');
+    fs = require('fs');

-console.log('Connecting to ' + ws.url);
+var url     = process.argv[2],
+    headers = {Origin: 'http://faye.jcoglan.com'},
+    ca      = fs.readFileSync(__dirname + '/../spec/server.crt'),
+    proxy   = {origin: process.argv[3], headers: {'User-Agent': 'Echo'}, tls: {ca: ca}},
+    ws      = new WebSocket.Client(url, null, {headers: headers, proxy: proxy, tls: {ca: ca}});

-ws.onopen = function(event) {
-  console.log('open');
-  ws.send('Hello, WebSocket!');
+ws.onopen = function() {
+  console.log('[open]', ws.headers);
+  ws.send('mic check');
 };

-ws.onmessage = function(event) {
-  console.log('message', event.data);
-  // ws.close(1002, 'Going away');
+ws.onclose = function(close) {
+  console.log('[close]', close.code, close.reason);
 };

-ws.onclose = function(event) {
-  console.log('close', event.code, event.reason);
+ws.onerror = function(error) {
+  console.log('[error]', error.message);
 };

+ws.onmessage = function(message) {
+  console.log('[message]', message.data);
+};
@@ -18,4 +18,3 @@ backend sockets
   balance uri depth 2
   timeout server  120s
   server socket1 127.0.0.1:7000
-
@@ -0,0 +1,7 @@
+var ProxyServer = require('../spec/proxy_server');
+
+var port   = process.argv[2],
+    secure = process.argv[3] === 'tls',
+    proxy  = new ProxyServer({debug: true, tls: secure});
+
+proxy.listen(port);
@@ -1,19 +1,21 @@
 var WebSocket = require('../lib/faye/websocket'),
+    deflate   = require('permessage-deflate'),
    fs        = require('fs'),
    http      = require('http'),
    https     = require('https');

-var port   = process.argv[2] || 7000,
-    secure = process.argv[3] === 'ssl';
+var port    = process.argv[2] || 7000,
+    secure  = process.argv[3] === 'tls',
+    options = {extensions: [deflate], ping: 5};

 var upgradeHandler = function(request, socket, head) {
-  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], {ping: 5});
-  console.log('open', ws.url, ws.version, ws.protocol);
+  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp'], options);
+  console.log('[open]', ws.url, ws.version, ws.protocol, request.headers);

  ws.pipe(ws);

  ws.onclose = function(event) {
-    console.log('close', event.code, event.reason);
+    console.log('[close]', event.code, event.reason);
    ws = null;
  };
 };
@@ -25,7 +27,7 @@ var requestHandler = function(request, response) {
  var es   = new WebSocket.EventSource(request, response),
      time = parseInt(es.lastEventId, 10) || 0;

-  console.log('open', es.url, es.lastEventId);
+  console.log('[open]', es.url, es.lastEventId);

  var loop = setInterval(function() {
    time += 1;
@@ -35,11 +37,11 @@ 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);
-    console.log('close', es.url);
+    console.log('[close]', es.url);
    es = null;
  };
 };
@@ -62,7 +64,6 @@ var server = secure
             })
           : http.createServer();

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

  </body>
 </html>
-
@@ -41,4 +41,3 @@

  </body>
 </html>
-
@@ -1,59 +1,60 @@
-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'),
+    Headers     = require('websocket-driver/lib/websocket/driver/headers'),
+    API         = require('./websocket/api'),
+    EventTarget = require('./websocket/api/event_target'),
+    Event       = require('./websocket/api/event');

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

-  this._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 = [];
+  var headers = new Headers(),
+      self    = this;
+
+  if (options.headers) {
+    for (var key in options.headers) headers.set(key, options.headers[key]);
+  }
+
+  if (!this._stream || !this._stream.writable) return;
  process.nextTick(function() { self._open() });

+  this._stream.setTimeout(0);
+  this._stream.setNoDelay(true);
+
  var handshake = 'HTTP/1.1 200 OK\r\n' +
                  'Content-Type: text/event-stream\r\n' +
                  'Cache-Control: no-cache, no-store\r\n' +
                  'Connection: close\r\n' +
-                  '\r\n\r\n' +
+                  headers.toString() +
+                  '\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 +63,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 +102,30 @@ 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];
-module.exports = EventSource;
+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,41 @@
-// 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;
+var WebSocket = function(request, socket, body, protocols, options) {
+  options = options || {};

-  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;
+  this._stream = socket;
+  this._driver = driver.http(request, {maxLength: options.maxLength, 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;
+  if (!this._stream.readable) return this._stream.end();

  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._driver.io.write(body);
+  API.call(this, options);

-  this._stream.addListener('end', function() { self._finalize('', 1006) });
-  this._parser.start();
+  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;

+module.exports        = WebSocket;
@@ -1,24 +1,134 @@
-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]);
+  }
+
+  var extensions = options.extensions;
+  if (extensions) {
+    [].concat(extensions).forEach(this._driver.addExtension, this._driver);
+  }
+
+  this._ping          = options.ping;
+  this._pingId        = 0;
+  this.readyState     = API.CONNECTING;
+  this.bufferedAmount = 0;
+  this.protocol       = '';
+  this.url            = this._driver.url;
+  this.version        = this._driver.version;
+
+  var self = this;
+
+  this._driver.on('open',    function(e) { self._open() });
+  this._driver.on('message', function(e) { self._receiveMessage(e.data) });
+  this._driver.on('close',   function(e) { self._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);
+    self._finalize('', 1006);
+  });
+  this.on('error', function() {});
+
+  this._driver.messages.on('drain', function() {
+    self.emit('drain');
+  });
+
+  if (this._ping)
+    this._pingTimer = setInterval(function() {
+      self._pingId += 1;
+      self.ping(self._pingId.toString());
+    }, this._ping * 1000);
+
+  this._configureStream();
+
+  if (!this._proxy) {
+    this._stream.pipe(this._driver.io);
+    this._driver.io.pipe(this._stream);
+  }
+};
+util.inherits(API, Stream);
+
+API.CONNECTING = 0;
+API.OPEN       = 1;
+API.CLOSING    = 2;
+API.CLOSED     = 3;
+
+var instance = {
+  write: function(data) {
+    return this.send(data);
+  },
+
+  end: function(data) {
+    if (data !== undefined) this.send(data);
+    this.close();
+  },
+
+  pause: function() {
+    return this._driver.messages.pause();
+  },
+
+  resume: function() {
+    return this._driver.messages.resume();
+  },
+
+  send: function(data) {
+    if (this.readyState > API.OPEN) return false;
+    if (!(data instanceof Buffer)) data = String(data);
+    return this._driver.messages.write(data);
+  },
+
+  ping: function(message, callback) {
+    if (this.readyState > API.OPEN) return false;
+    return this._driver.ping(message, callback);
+  },
+
+  close: function() {
+    if (this.readyState !== API.CLOSED) this.readyState = API.CLOSING;
+    this._driver.close();
+  },
+
+  _configureStream: function() {
+    var self = this;
+
+    this._stream.setTimeout(0);
+    this._stream.setNoDelay(true);
+
+    ['close', 'end'].forEach(function(event) {
+      this._stream.on(event, function() { self._finalize('', 1006) });
+    }, this);
+
+    this._stream.on('error', function(error) {
+      self._driver.emit('error', new Error('Network error: ' + self.url + ': ' + error.message));
+    });
+  },
+
+ _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);
@@ -27,39 +137,20 @@ 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;
+
    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;
-
@@ -18,4 +18,3 @@ Event.AT_TARGET       = 2;
 Event.BUBBLING_PHASE  = 3;

 module.exports = Event;
-
@@ -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,13 +21,8 @@ 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);
  }
 };

 module.exports = EventTarget;
-
@@ -1,52 +1,84 @@
-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'),
+    crypto = require('crypto'),
+    url    = require('url'),
+    driver = require('websocket-driver'),
+    API    = require('./api'),
+    Event  = require('./api/event');

-var Client = function(url, protocols, options) {
-  this.url  = url;
-  this._uri = require('url').parse(url);
+var DEFAULT_PORTS    = {'http:': 80, 'https:': 443, 'ws:':80, 'wss:': 443},
+    SECURE_PROTOCOLS = ['https:', 'wss:'];

-  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) });
+var Client = function(_url, protocols, options) {
+  options = options || {};

-  this.readyState = API.CONNECTING;
-  this.bufferedAmount = 0;
+  this.url     = _url;
+  this._driver = driver.client(this.url, {maxLength: options.maxLength, protocols: protocols});

-  var secure     = (this._uri.protocol === 'wss:'),
-      onConnect  = function() { self._onConnect() },
-      tlsOptions = {};
+  ['open', 'error'].forEach(function(event) {
+    this._driver.on(event, function() {
+      self.headers    = self._driver.headers;
+      self.statusCode = self._driver.statusCode;
+    });
+  }, this);

-  if (options && options.verify === false) tlsOptions.rejectUnauthorized = false;
+  var proxy     = options.proxy || {},
+      endpoint  = url.parse(proxy.origin || this.url),
+      port      = endpoint.port || DEFAULT_PORTS[endpoint.protocol],
+      secure    = SECURE_PROTOCOLS.indexOf(endpoint.protocol) >= 0,
+      onConnect = function() { self._onConnect() },
+      originTLS = options.tls || {},
+      socketTLS = proxy.origin ? (proxy.tls || {}) : originTLS,
+      self      = this;

-  var connection = secure
-                 ? tls.connect(this._uri.port || 443, this._uri.hostname, tlsOptions, onConnect)
-                 : net.createConnection(this._uri.port || 80, this._uri.hostname);
+  originTLS.ca = originTLS.ca || options.ca;

-  this._stream = connection;
-  this._stream.setTimeout(0);
-  this._stream.setNoDelay(true);
+  this._stream = secure
+               ? tls.connect(port, endpoint.hostname, socketTLS, onConnect)
+               : net.connect(port, endpoint.hostname, onConnect);

-  if (!secure) this._stream.addListener('connect', onConnect);
+  if (proxy.origin) this._configureProxy(proxy, originTLS);

-  this._stream.pipe(this._parser.io);
-  this._parser.io.pipe(this._stream);
-
-  this._stream.addListener('close', function() { self._finalize('', 1006) });
+  API.call(this, options);
 };
-util.inherits(Client, Stream);
+util.inherits(Client, API);

 Client.prototype._onConnect = function() {
-  this._parser.start();
+  var worker = this._proxy || this._driver;
+  worker.start();
 };

-for (var key in API) Client.prototype[key] = API[key];
+Client.prototype._configureProxy = function(proxy, originTLS) {
+  var uri    = url.parse(this.url),
+      secure = SECURE_PROTOCOLS.indexOf(uri.protocol) >= 0,
+      self   = this,
+      name;
+
+  this._proxy = this._driver.proxy(proxy.origin);
+
+  if (proxy.headers) {
+    for (name in proxy.headers) this._proxy.setHeader(name, proxy.headers[name]);
+  }
+
+  this._proxy.pipe(this._stream, {end: false});
+  this._stream.pipe(this._proxy);
+
+  this._proxy.on('connect', function() {
+    if (secure) {
+      var options = {socket: self._stream, servername: uri.hostname};
+      for (name in originTLS) options[name] = originTLS[name];
+      self._stream = tls.connect(options);
+      self._configureStream();
+    }
+    self._driver.io.pipe(self._stream);
+    self._stream.pipe(self._driver.io);
+    self._driver.start();
+  });
+
+  this._proxy.on('error', function(error) {
+    self._driver.emit('error', error);
+  });
+};

 module.exports = Client;
-
@@ -1,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,19 @@
 , "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.9.0"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/faye/websocket"
-, "devDependencies" : {"jsclass": "", "pace": ""}
+, "dependencies"    : {"websocket-driver": ">=0.5.0"}
+, "devDependencies" : {"jstest": "", "pace": "", "permessage-deflate": ""}

-, "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"
-                        }
-                      ]
 }
-
@@ -0,0 +1,31 @@
+var fs    = require('fs'),
+    http  = require('http'),
+    https = require('https');
+
+var WebSocket = require('../lib/faye/websocket');
+
+var EchoServer = function(secure) {
+  var server = secure
+             ? https.createServer({
+                 key:  fs.readFileSync(__dirname + '/server.key'),
+                 cert: fs.readFileSync(__dirname + '/server.crt')
+               })
+             : http.createServer();
+
+  server.on('upgrade', function(request, socket, head) {
+    var ws = new WebSocket(request, socket, head, ["echo"]);
+    ws.pipe(ws);
+  });
+
+  this._httpServer = server;
+};
+
+EchoServer.prototype.listen = function(port) {
+  this._httpServer.listen(port);
+};
+
+EchoServer.prototype.stop = function() {
+  this._httpServer.close();
+};
+
+module.exports = EchoServer;
@@ -1,22 +1,38 @@
-var Client = require('../../../lib/faye/websocket/client')
+var Client      = require('../../../lib/faye/websocket/client'),
+    EchoServer  = require('../../echo_server'),
+    ProxyServer = require('../../proxy_server'),
+    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)
-    this._port = port
-    setTimeout(callback, 100)
+    this._echoServer = new EchoServer(secure)
+    this._echoServer.listen(port)
+    process.nextTick(callback)
  },

  stop: function(callback) {
-    this._adapter.stop()
-    setTimeout(callback, 100)
+    this._echoServer.stop()
+    process.nextTick(callback)
+  },
+
+  proxy: function(port, secure, callback) {
+    this._proxyServer = new ProxyServer({tls: secure})
+    this._proxyServer.listen(port)
+    process.nextTick(callback)
+  },
+
+  stop_proxy: function(callback) {
+    this._proxyServer.stop()
+    process.nextTick(callback)
  },

  open_socket: function(url, protocols, callback) {
    var done = false,
        self = this,

+        tlsOptions = { ca: fs.readFileSync(__dirname + '/../../server.crt') },
+
        resume = function(open) {
                   if (done) return
                   done = true
@@ -24,12 +40,30 @@ JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
                   callback()
                 }

-    this._ws = new Client(url, protocols, {verify: false})
+    this._ws = new Client(url, protocols, {
+      proxy: { origin: this.proxy_url, tls: tlsOptions },
+      tls:   tlsOptions
+    })

    this._ws.onopen  = function() { resume(true)  }
    this._ws.onclose = function() { resume(false) }
  },

+  open_socket_and_close_it_fast: function(url, protocols, callback) {
+    var self = this
+
+    this._ws = new Client(url, protocols, {
+      ca: fs.readFileSync(__dirname + '/../../server.crt')
+    })
+
+    this._ws.onopen  = function() { self._open = self._ever_opened = true  }
+    this._ws.onclose = function() { self._open = false }
+
+    this._ws.close()
+
+    callback()
+  },
+
  close_socket: function(callback) {
    var self = this
    this._ws.onclose = function() {
@@ -49,20 +83,41 @@ JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
    callback()
  },

+  check_never_opened: function(callback) {
+    this.assert( !this._ever_opened )
+    callback()
+  },
+
+  check_readable: function(callback) {
+    this.assert( this._ws.readable )
+    callback()
+  },
+
+  check_not_readable: function(callback) {
+    this.assert( ! this._ws.readable )
+    callback()
+  },
+
  check_protocol: function(protocol, callback) {
    this.assertEqual( protocol, this._ws.protocol )
    callback()
  },

  listen_for_message: function(callback) {
-    var self = this
+    var time = new Date().getTime(), self = this
    this._ws.addEventListener('message', function(message) { self._message = message.data })
-    callback()
+    var timer = setInterval(function() {
+      if (self._message || new Date().getTime() - time > 3000) {
+        clearInterval(timer)
+        callback()
+      }
+    }, 100)
  },

  send_message: function(message, callback) {
-    this._ws.send(message)
-    setTimeout(callback, 100)
+    var ws = this._ws
+    setTimeout(function() { ws.send(message) }, 500)
+    process.nextTick(callback)
  },

  check_response: function(message, callback) {
@@ -73,17 +128,27 @@ JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
  check_no_response: function(callback) {
    this.assert( !this._message )
    callback()
+  },
+
+  wait: function (ms, callback) {
+    setTimeout(callback, ms)
  }
 })


-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.protocols             = ["foo", "echo"]
+
+    this.plain_text_url        = "ws://localhost:4180/bayeux"
+    this.secure_url            = "wss://localhost:4180/bayeux"
+    this.port                  = 4180
+
+    this.plain_text_proxy_url  = "http://localhost:4181"
+    this.secure_text_proxy_url = "https://localhost:4181"
+    this.proxy_port            = 4181
  })

  sharedBehavior("socket client", function() { with(this) {
@@ -93,15 +158,12 @@ 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)
+      check_readable()
      close_socket()
      check_closed()
+      check_not_readable()
    }})

    describe("in the OPEN state", function() { with(this) {
@@ -110,26 +172,26 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
      }})

      it("can send and receive messages", function() { with(this) {
-        listen_for_message()
        send_message("I expect this to be echoed")
+        listen_for_message()
        check_response("I expect this to be echoed")
      }})

      it("sends numbers as strings", function() { with(this) {
-        listen_for_message()
        send_message(13)
+        listen_for_message()
        check_response("13")
      }})

      it("sends booleans as strings", function() { with(this) {
-        listen_for_message()
        send_message(false)
+        listen_for_message()
        check_response("false")
      }})

      it("sends arrays as strings", function() { with(this) {
-        listen_for_message()
        send_message([13,14,15])
+        listen_for_message()
        check_response("13,14,15")
      }})
    }})
@@ -141,35 +203,70 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
      }})

      it("cannot send and receive messages", function() { with(this) {
-        listen_for_message()
        send_message("I expect this to be echoed")
+        listen_for_message()
        check_no_response()
      }})
    }})
+
+    it("can be closed before connecting", function() { with(this) {
+      open_socket_and_close_it_fast(socket_url, protocols)
+      wait(10)
+      check_closed()
+      check_never_opened()
+      check_not_readable()
+    }})
  }})

-  describe("with a plain-text server", function() { with(this) {
-    before(function() {
-      this.socket_url  = this.plain_text_url
-      this.blocked_url = this.secure_url
-    })
+  sharedBehavior("socket server", function() { with(this) {
+    describe("with a plain-text server", function() { with(this) {
+      before(function() {
+        this.socket_url  = this.plain_text_url
+        this.blocked_url = this.secure_url
+      })

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

-    behavesLike("socket client")
+      behavesLike("socket client")
+    }})
+
+    describe("with a secure server", function() { with(this) {
+      before(function() {
+        this.socket_url  = this.secure_url
+        this.blocked_url = this.plain_text_url
+      })
+
+      before(function() { this.server(this.port, true) })
+      after (function() { this.stop() })
+
+      behavesLike("socket client")
+    }})
  }})

-  describe("with a secure server", function() { with(this) {
+  describe("with no proxy", function() { with(this) {
+    behavesLike("socket server")
+  }})
+
+  describe("with a proxy", function() { with(this) {
    before(function() {
-      this.socket_url  = this.secure_url
-      this.blocked_url = this.plain_text_url
+      this.proxy_url = this.plain_text_proxy_url
    })

-    before(function() { this.server(8000, true) })
-    after (function() { this.stop() })
+    before(function() { this.proxy(this.proxy_port, false) })
+    after (function() { this.stop_proxy() })

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