Bump version to 0.5.0.

.npmignore

@@ -4,3 +4,4 @@
 .redcar
 .travis.yml
 node_modules
+spec

CHANGELOG.md

@@ -0,0 +1,68 @@
+### 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
+

CHANGELOG.txt

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

README.md

@@ -1,26 +1,30 @@
 # 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/)
+* Travis CI build: [![Build
+  status](https://secure.travis-ci.org/faye/faye-websocket-node.png)](http://travis-ci.org/faye/faye-websocket-node)
+* Autobahn tests: [server](http://faye.jcoglan.com/autobahn/servers/),
+  [client](http://faye.jcoglan.com/autobahn/clients/)
 
-This is a 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/).
+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.
+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.
+
+## Installation
+
+```
+$ npm install faye-websocket
+```
 
 
 ## Handling WebSocket connections in Node
@@ -36,17 +40,20 @@ var WebSocket = require('faye-websocket'),
 
 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.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);
@@ -64,9 +71,10 @@ If you need to detect when the WebSocket handshake is complete, you can use the
 
 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`.
+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() {
@@ -79,25 +87,25 @@ ws.ping('Mic check, one, two', function() {
 
 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.
+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) {
+ws.on('open', function(event) {
   console.log('open');
   ws.send('Hello, world!');
-};
+});
 
-ws.onmessage = function(event) {
+ws.on('message', function(event) {
   console.log('message', event.data);
-};
+});
 
-ws.onclose = function(event) {
+ws.on('close', function(event) {
   console.log('close', event.code, event.reason);
   ws = null;
-};
+});
 ```
 
 
@@ -116,35 +124,40 @@ 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']);
+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.
-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.
+Both server- and client-side `WebSocket` objects support the following API.
+They are both readable and writable streams, so for example you can write an
+echo server using `socket.pipe(socket)`.
 
-* <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
+* <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.
 
 
@@ -162,7 +175,7 @@ var WebSocket   = require('faye-websocket'),
 
 var server = http.createServer();
 
-server.addListener('request', function(request, response) {
+server.on('request', function(request, response) {
   if (EventSource.isEventSource(request)) {
     var es = new EventSource(request, response);
     console.log('open', es.url, es.lastEventId);
@@ -170,16 +183,15 @@ server.addListener('request', function(request, response) {
     // Periodically send messages
     var loop = setInterval(function() { es.send('Hello') }, 1000);
     
-    es.onclose = function() {
+    es.on('close', function() {
       clearInterval(loop);
       es = null;
-    };
+    });
   
   } else {
     // Normal HTTP request
     response.writeHead(200, {'Content-Type': 'text/plain'});
-    response.write('Hello');
-    response.end();
+    response.end('Hello');
   }
 });
 
@@ -196,19 +208,19 @@ 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.
+* <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><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
+* <b>`retry`</b> is a number that tells the client how long (in seconds) it
+  should wait after a dropped connection before attempting to reconnect.
+* <b>`ping`</b> is a number that tells the server how often (in seconds) to
+  send 'ping' packets to the client to keep the connection open, to defeat
   timeouts set by proxies. The client will ignore these messages.
 
 For example, this creates a connection that pings every 15 seconds and is
@@ -218,31 +230,32 @@ retryable every 10 seconds if the connection is broken:
 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.
+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
+Copyright (c) 2010-2013 James Coglan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the 'Software'), to deal in
-the Software without restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
-Software, and to permit persons to whom the Software is furnished to do so,
-subject to the following conditions:
+the 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.
+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.
 

examples/autobahn_client.js

@@ -28,14 +28,8 @@ socket.onclose = function() {
 
     } else {
       socket = new WebSocket.Client(host + '/runCase?case=' + n + '&agent=' + encodeURIComponent(agent));
-
-      socket.onmessage = function(event) {
-        socket.send(event.data);
-      };
-
-      socket.onclose = function() {
-        runCase(n + 1);
-      };
+      socket.pipe(socket);
+      socket.on('close', function() { runCase(n + 1) });
     }
   };
 

examples/server.js

@@ -35,7 +35,7 @@ var requestHandler = function(request, response) {
     }, 1000);
   }, 2000);
 
-  es.send('Welcome!\n\nThis is an EventSource server.');
+  fs.createReadStream(__dirname + '/haproxy.conf').pipe(es, {end: false});
 
   es.onclose = function() {
     clearInterval(loop);
@@ -62,7 +62,7 @@ var server = secure
              })
            : http.createServer();
 
-server.addListener('request', requestHandler);
-server.addListener('upgrade', upgradeHandler);
+server.on('request', requestHandler);
+server.on('upgrade', upgradeHandler);
 server.listen(port);
 

lib/faye/eventsource.js

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

lib/faye/websocket.js

@@ -1,59 +1,46 @@
-// API and protocol references:
+// API references:
 // 
 // * http://dev.w3.org/html5/websockets/
 // * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-eventtarget
 // * http://dvcs.w3.org/hg/domcore/raw-file/tip/Overview.html#interface-event
-// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
-// * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
-// * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
 
-var Stream   = require('stream'),
-    util     = require('util'),
-    protocol = require('../websocket/protocol'),
-    API      = require('./websocket/api'),
-    Event    = require('./websocket/api/event');
+var util   = require('util'),
+    driver = require('websocket-driver'),
+    API    = require('./websocket/api');
 
-var WebSocket = function(request, socket, head, supportedProtos, options) {
-  this.readable = this.writable = true;
-
-  this._request = request;
-  this._stream  = request.socket;
+var WebSocket = function(request, socket, body, protocols, options) {
+  this._stream  = 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._driver  = driver.http(request, {protocols: protocols});
 
   var self = this;
-  this._parser.onopen   (function(e) { self._open() });
-  this._parser.onmessage(function(e) { self._receiveMessage(e.data) });
-  this._parser.onclose  (function(e) { self._finalize(e.reason, e.code) });
-
-  if (this._ping)
-    this._pingTimer = setInterval(function() {
-      self._pingId += 1;
-      self.ping(self._pingId.toString());
-    }, this._ping * 1000);
+  if (!this._stream || !this._stream.writable) return;
 
   var catchup = function() { self._stream.removeListener('data', catchup) };
-  this._stream.addListener('data', catchup);
+  this._stream.on('data', catchup);
 
   this._stream.setTimeout(0);
   this._stream.setNoDelay(true);
-  this._stream.pipe(this._parser.io);
-  this._parser.io.pipe(this._stream);
 
-  this._stream.addListener('end', function() { self._finalize('', 1006) });
-  this._parser.start();
+  this._driver.io.write(body);
+  API.call(this);
+
+  ['error', 'end'].forEach(function(event) {
+    this._stream.on(event, function() { self._finalize('', 1006) });
+  }, this);
+
+  this._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;
 

lib/faye/websocket/api.js

@@ -1,24 +1,100 @@
-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() {
+  this.readable = this.writable = true;
 
-  _open: function() {
+  this.readyState     = API.CONNECTING;
+  this.bufferedAmount = 0;
+  this.protocol       = '';
+  this.url            = this._driver.url;
+  this.version        = this._driver.version;
+
+  var self = this;
+
+  this._driver.on('open',    function(e) { self._open() });
+  this._driver.on('message', function(e) { self._receiveMessage(e.data) });
+  this._driver.on('close',   function(e) { self._finalize(e.reason, e.code) });
+
+  this._driver.on('error', function(error) {
+    var event = new Event('error', {message: error.message});
+    event.initEvent('error', false, false);
+    self.dispatchEvent(event);
+  });
+  this.on('error', function() {});
+
+  this._driver.messages.on('drain', function() {
+    self.emit('drain');
+  });
+
+  if (this._ping)
+    this._pingTimer = setInterval(function() {
+      self._pingId += 1;
+      self.ping(self._pingId.toString());
+    }, this._ping * 1000);
+
+  this._stream.pipe(this._driver.io);
+  this._driver.io.pipe(this._stream);
+};
+util.inherits(API, Stream);
+
+API.CONNECTING = 0;
+API.OPEN       = 1;
+API.CLOSING    = 2;
+API.CLOSED     = 3;
+
+var instance = {
+  write: function(data) {
+    return this.send(data);
+  },
+
+  end: function(data) {
+    if (data !== undefined) this.send(data);
+    this.close();
+  },
+
+  pause: function() {
+    return this._driver.messages.pause();
+  },
+
+  resume: function() {
+    return this._driver.messages.resume();
+  },
+
+  send: function(data) {
+    if (this.readyState > API.OPEN) return false;
+    if (!(data instanceof Buffer)) data = String(data);
+    return this._driver.messages.write(data);
+  },
+
+  ping: function(message, callback) {
+    if (this.readyState > API.OPEN) return false;
+    return this._driver.ping(message, callback);
+  },
+
+  close: function() {
+    if (this.readyState === API.OPEN) this.readyState = API.CLOSING;
+    this._driver.close();
+  },
+
+ _open: function() {
     if (this.readyState !== API.CONNECTING) return;
+
     this.readyState = API.OPEN;
-    this.protocol = this._parser.protocol || '';
+    this.protocol = this._driver.protocol || '';
+
     var event = new Event('open');
     event.initEvent('open', false, false);
     this.dispatchEvent(event);
   },
 
   _receiveMessage: function(data) {
-    if (this.readyState !== API.OPEN) return false;
-    this.emit('data', data);
+    if (this.readyState > API.OPEN) return false;
+
+    if (this.readable) this.emit('data', data);
+
     var event = new Event('message', {data: data});
     event.initEvent('message', false, false);
     this.dispatchEvent(event);
@@ -26,40 +102,22 @@ var API = {
 
   _finalize: function(reason, code) {
     if (this.readyState === API.CLOSED) return;
-    this.readyState = API.CLOSED;
+
     if (this._pingTimer) clearInterval(this._pingTimer);
     if (this._stream) this._stream.end();
+
+    if (this.readable) this.emit('end');
+    this.readable = this.writable = false;
+
+    this.readyState = API.CLOSED;
     var event = new Event('close', {code: code || 1000, reason: reason || ''});
     event.initEvent('close', false, false);
     this.dispatchEvent(event);
-  },
-
-  write: function(data) {
-    if (this.readyState > API.OPEN) return false;
-    if (!(data instanceof Buffer)) data = String(data);
-
-    if (data instanceof Buffer)
-      return this._parser.binary(data);
-    else
-      return this._parser.text(data);
-  },
-
-  send: function(data) {
-    return this.write(data);
-  },
-
-  ping: function(message, callback) {
-    if (this.readyState > API.OPEN) return false;
-    return this._parser.ping(message, callback);
-  },
-
-  close: function() {
-    if (this.readyState === API.OPEN) this.readyState = API.CLOSING;
-    this._parser.close();
   }
 };
 
-for (var key in EventTarget) API[key] = EventTarget[key];
+for (var method in instance) API.prototype[method] = instance[method];
+for (var key in EventTarget) API.prototype[key] = EventTarget[key];
 
 module.exports = API;
 

lib/faye/websocket/api/event_target.js

@@ -7,25 +7,11 @@ var EventTarget = {
   onclose:    null,
 
   addEventListener: function(eventType, listener, useCapture) {
-    this._listeners = this._listeners || {};
-    var list = this._listeners[eventType] = this._listeners[eventType] || [];
-    list.push(listener);
+    this.on(eventType, listener);
   },
 
   removeEventListener: function(eventType, listener, useCapture) {
-    if (!this._listeners || !this._listeners[eventType]) return;
-
-    if (!listener) {
-      delete this._listeners[eventType];
-      return;
-    }
-    var list = this._listeners[eventType],
-        i    = list.length;
-
-    while (i--) {
-      if (listener !== list[i]) continue;
-      list.splice(i,1);
-    }
+    this.removeListener(eventType, listener);
   },
 
   dispatchEvent: function(event) {
@@ -35,11 +21,7 @@ var EventTarget = {
     if (this['on' + event.type])
       this['on' + event.type](event);
 
-    if (!this._listeners || !this._listeners[event.type]) return;
-
-    this._listeners[event.type].forEach(function(listener) {
-      listener(event);
-    }, this);
+    this.emit(event.type, event);
   }
 };
 

lib/faye/websocket/client.js

@@ -1,27 +1,20 @@
-var Stream   = require('stream'),
-    util     = require('util'),
-    net      = require('net'),
-    tls      = require('tls'),
-    protocol = require('../../websocket/protocol'),
-    API      = require('./api'),
-    Event    = require('./api/event');
+var util   = require('util'),
+    net    = require('net'),
+    tls    = require('tls'),
+    driver = require('websocket-driver'),
+    API    = require('./api');
 
 var Client = function(url, protocols, options) {
-  this.url  = url;
-  this._uri = require('url').parse(url);
-
-  this._parser = protocol.client(url, {protocols: protocols});
-  var self = this;
-  this._parser.onopen   (function(e) { self._open() });
-  this._parser.onmessage(function(e) { self._receiveMessage(e.data) });
-  this._parser.onclose  (function(e) { self._finalize(e.reason, e.code) });
-
-  this.readyState = API.CONNECTING;
-  this.bufferedAmount = 0;
+  this.url     = url;
+  this._uri    = require('url').parse(url);
+  this._ping   = options && options.ping;
+  this._pingId = 0;
+  this._driver = driver.client(url, {protocols: protocols});
 
   var secure     = (this._uri.protocol === 'wss:'),
-      onConnect  = function() { self._onConnect() },
-      tlsOptions = {};
+      onConnect  = function() { self._driver.start() },
+      tlsOptions = {},
+      self       = this;
 
   if (options && options.verify === false) tlsOptions.rejectUnauthorized = false;
 
@@ -33,20 +26,15 @@ var Client = function(url, protocols, options) {
   this._stream.setTimeout(0);
   this._stream.setNoDelay(true);
 
-  if (!secure) this._stream.addListener('connect', onConnect);
+  if (!secure) this._stream.on('connect', onConnect);
 
-  this._stream.pipe(this._parser.io);
-  this._parser.io.pipe(this._stream);
+  API.call(this);
 
-  this._stream.addListener('close', function() { self._finalize('', 1006) });
+  ['error', 'end'].forEach(function(event) {
+    this._stream.on(event, function() { self._finalize('', 1006) });
+  }, this);
 };
-util.inherits(Client, Stream);
-
-Client.prototype._onConnect = function() {
-  this._parser.start();
-};
-
-for (var key in API) Client.prototype[key] = API[key];
+util.inherits(Client, API);
 
 module.exports = Client;
 

lib/faye/websocket/draft75_parser.js

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

lib/faye/websocket/draft76_parser.js

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

lib/faye/websocket/hybi_parser.js

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

lib/faye/websocket/hybi_parser/handshake.js

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

lib/faye/websocket/hybi_parser/stream_reader.js

@@ -1,43 +0,0 @@
-var StreamReader = function() {
-  this._queue  = [];
-  this._cursor = 0;
-};
-
-StreamReader.prototype.read = function(bytes) {
-  return this._readBuffer(bytes);
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!buffer.copy) buffer = new Buffer(buffer);
-  this._queue.push(buffer);
-};
-
-StreamReader.prototype._readBuffer = function(length) {
-  var buffer = new Buffer(length),
-      queue  = this._queue,
-      remain = length,
-      n      = queue.length,
-      i      = 0,
-      chunk, offset, size;
-
-  if (remain === 0) return buffer;
-
-  while (remain > 0 && i < n) {
-    chunk = queue[i];
-    offset = (i === 0) ? this._cursor : 0;
-    size = Math.min(remain, chunk.length - offset);
-    chunk.copy(buffer, length - remain, offset, offset + size);
-    remain -= size;
-    i += 1;
-  }
-
-  if (remain > 0) return null;
-
-  queue.splice(0, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
-
-  return buffer;
-};
-
-module.exports = StreamReader;

lib/websocket/protocol.js

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

lib/websocket/protocol/base.js

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

lib/websocket/protocol/client.js

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

lib/websocket/protocol/hybi.js

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

lib/websocket/protocol/hybi/stream_reader.js

@@ -1,43 +0,0 @@
-var StreamReader = function() {
-  this._queue  = [];
-  this._cursor = 0;
-};
-
-StreamReader.prototype.read = function(bytes) {
-  return this._readBuffer(bytes);
-};
-
-StreamReader.prototype.put = function(buffer) {
-  if (!buffer || buffer.length === 0) return;
-  if (!buffer.copy) buffer = new Buffer(buffer);
-  this._queue.push(buffer);
-};
-
-StreamReader.prototype._readBuffer = function(length) {
-  var buffer = new Buffer(length),
-      queue  = this._queue,
-      remain = length,
-      n      = queue.length,
-      i      = 0,
-      chunk, offset, size;
-
-  if (remain === 0) return buffer;
-
-  while (remain > 0 && i < n) {
-    chunk = queue[i];
-    offset = (i === 0) ? this._cursor : 0;
-    size = Math.min(remain, chunk.length - offset);
-    chunk.copy(buffer, length - remain, offset, offset + size);
-    remain -= size;
-    i += 1;
-  }
-
-  if (remain > 0) return null;
-
-  queue.splice(0, i-1);
-  this._cursor = (i === 1 ? this._cursor : 0) + size;
-
-  return buffer;
-};
-
-module.exports = StreamReader;

package.json

@@ -4,9 +4,10 @@
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
 , "keywords"        : ["websocket", "eventsource"]
 
-, "version"         : "0.4.4"
+, "version"         : "0.5.0"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/faye/websocket"
+, "dependencies"    : {"websocket-driver": ""}
 , "devDependencies" : {"jsclass": "", "pace": ""}
 
 , "scripts"         : {"test": "node spec/runner.js"}

spec/faye/websocket/client_spec.js

@@ -82,8 +82,9 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
 
   before(function() {
     this.protocols       = ["foo", "echo"]
-    this.plain_text_url  = "ws://localhost:8000/bayeux"
-    this.secure_url      = "wss://localhost:8000/bayeux"
+    this.plain_text_url  = "ws://localhost:4180/bayeux"
+    this.secure_url      = "wss://localhost:4180/bayeux"
+    this.port            = 4180
   })
 
   sharedBehavior("socket client", function() { with(this) {
@@ -93,11 +94,6 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
       check_protocol("echo")
     }})
 
-    it("cannot open a connection with unacceptable protocols", function() { with(this) {
-      open_socket(socket_url, ["foo"])
-      check_closed()
-    }})
-
     it("can close the connection", function() { with(this) {
       open_socket(socket_url, protocols)
       close_socket()
@@ -154,7 +150,7 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
       this.blocked_url = this.secure_url
     })
 
-    before(function() { this.server(8000, false) })
+    before(function() { this.server(4180, false) })
     after (function() { this.stop() })
 
     behavesLike("socket client")
@@ -166,7 +162,7 @@ JS.ENV.ClientSpec = JS.Test.describe("Client", function() { with(this) {
       this.blocked_url = this.plain_text_url
     })
 
-    before(function() { this.server(8000, true) })
+    before(function() { this.server(4180, true) })
     after (function() { this.stop() })
 
     behavesLike("socket client")

spec/runner.js

@@ -15,7 +15,7 @@ EchoServer.prototype.listen = function(port, ssl) {
                })
              : http.createServer()
 
-  server.addListener('upgrade', function(request, socket, head) {
+  server.on('upgrade', function(request, socket, head) {
     var ws = new WebSocket(request, socket, head, ["echo"])
     ws.pipe(ws)
   })
@@ -23,7 +23,7 @@ EchoServer.prototype.listen = function(port, ssl) {
   server.listen(port)
 }
 EchoServer.prototype.stop = function(callback, scope) {
-  this._httpServer.addListener('close', function() {
+  this._httpServer.on('close', function() {
     if (callback) callback.call(scope);
   });
   this._httpServer.close();
@@ -31,13 +31,6 @@ EchoServer.prototype.stop = function(callback, scope) {
 
 
 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()
 })