Correct EventSource error handler.

CHANGELOG.txt

@@ -0,0 +1,23 @@
+=== 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.markdown

@@ -7,6 +7,11 @@ 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)
@@ -15,7 +20,7 @@ supports both `text` and `binary` messages, and transparently handles `ping`,
 `pong`, `close` and fragmented messages.
 
 
-## Accepting WebSocket connections in Node
+## 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
@@ -49,8 +54,7 @@ server.listen(8000);
 
 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, though it's compatible
-with servers speaking later versions of the protocol.
+browser. On the wire it identifies itself as hybi-13.
 
 ```js
 var WebSocket = require('faye-websocket'),
@@ -115,15 +119,86 @@ messages.
   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 or `null` identifying the subprotocol the
-  socket is using.
+* <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});
+```
 
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2009-2011 James Coglan
+Copyright (c) 2009-2012 James Coglan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the 'Software'), to deal in

examples/server.js

@@ -6,6 +6,46 @@ var WebSocket = require('../lib/faye/websocket'),
 var port   = process.argv[2] || 7000,
     secure = process.argv[3] === 'ssl';
 
+var upgradeHandler = function(request, socket, head) {
+  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp']);
+  console.log('open', ws.url, ws.version, ws.protocol);
+  
+  ws.onmessage = function(event) {
+    ws.send(event.data);
+  };
+  
+  ws.onclose = function(event) {
+    console.log('close', event.code, event.reason);
+    ws = null;
+  };
+};
+
+var requestHandler = function(request, response) {
+  if (!WebSocket.EventSource.isEventSource(request))
+    return staticHandler(request, response);
+  
+  var es   = new WebSocket.EventSource(request, response),
+      time = parseInt(es.lastEventId, 10) || 0;
+  
+  console.log('open', es.url, es.lastEventId);
+  
+  var loop = setInterval(function() {
+    time += 1;
+    es.send('Time: ' + time);
+    setTimeout(function() {
+      if (es) es.send('Update!!', {event: 'update', id: time});
+    }, 1000);
+  }, 2000);
+  
+  es.send('Welcome!\n\nThis is an EventSource server.');
+  
+  es.onclose = function() {
+    clearInterval(loop);
+    console.log('close', es.url);
+    es = null;
+  };
+};
+
 var staticHandler = function(request, response) {
   var path = request.url;
   
@@ -22,20 +62,9 @@ var server = secure
                key:  fs.readFileSync(__dirname + '/../spec/server.key'),
                cert: fs.readFileSync(__dirname + '/../spec/server.crt')
              })
-           : http.createServer(staticHandler);
-
-server.addListener('upgrade', function(request, socket, head) {
-  var ws = new WebSocket(request, socket, head, ['irc', 'xmpp']);
-  console.log('open', ws.url, ws.version, ws.protocol);
-  
-  ws.onmessage = function(event) {
-    ws.send(event.data);
-  };
-  
-  ws.onclose = function(event) {
-    console.log('close', event.code, event.reason);
-    ws = null;
-  };
-});
+           : http.createServer();
 
+server.addListener('request', requestHandler);
+server.addListener('upgrade', upgradeHandler);
 server.listen(port);
+

examples/sse.html

@@ -0,0 +1,39 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>EventSource test</title>
+  </head>
+  <body>
+    
+    <h1>EventSource test</h1>
+    <ul></ul>
+    
+    <script type="text/javascript">
+      var logger = document.getElementsByTagName('ul')[0],
+          socket = new EventSource('/');
+      
+      var log = function(text) {
+        logger.innerHTML += '<li>' + text + '</li>';
+      };
+      
+      socket.onopen = function() {
+        log('OPEN');
+      };
+      
+      socket.onmessage = function(event) {
+        log('MESSAGE: ' + event.data);
+      };
+      
+      socket.addEventListener('update', function(event) {
+        log('UPDATE(' + event.lastEventId + '): ' + event.data);
+      });
+      
+      socket.onerror = function(event) {
+        log('ERROR: ' + event.message);
+      };
+    </script>
+    
+  </body>
+</html>
+

examples/ws.html

@@ -16,22 +16,26 @@
           socket = new Socket('ws://' + location.hostname + ':' + location.port + '/', protos),
           index  = 0;
       
-      socket.onopen = function() {
-        logger.innerHTML += '<li>OPEN: ' + socket.protocol + '</li>';
+      var log = function(text) {
+        logger.innerHTML += '<li>' + text + '</li>';
+      };
+      
+      socket.addEventListener('open', function() {
+        log('OPEN: ' + socket.protocol);
         socket.send('Hello, world');
-      };
-      
-      socket.onerror = function(event) {
-        logger.innerHTML += '<li>ERROR: ' + error.message + '</li>';
-      };
-      
-      socket.addEventListener('message', function(event) {
-        logger.innerHTML += '<li>MESSAGE: ' + event.data + '</li>';
-        setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
       });
       
+      socket.onerror = function(event) {
+        log('ERROR: ' + event.message);
+      };
+      
+      socket.onmessage = function(event) {
+        log('MESSAGE: ' + event.data);
+        setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
+      };
+      
       socket.onclose = function(event) {
-        logger.innerHTML += '<li>CLOSE: ' + event.code + ', ' + event.reason + '</li>';
+        log('CLOSE: ' + event.code + ', ' + event.reason);
       };
     </script>
     

lib/faye/eventsource.js

@@ -0,0 +1,92 @@
+var API   = require('./websocket/api'),
+    Event = require('./websocket/api/event');
+
+var isSecureConnection = function(request) {
+  if (request.headers['x-forwarded-proto']) {
+    return request.headers['x-forwarded-proto'] === 'https';
+  } else {
+    return (request.connection && request.connection.authorized !== undefined) ||
+           (request.socket && request.socket.secure);
+  }
+};
+
+var EventSource = function(request, response, options) {
+  options = options || {};
+  
+  this._request  = request;
+  this._response = response;
+  this._stream   = response.socket;
+  this._ping     = options.ping  || this.DEFAULT_PING;
+  this._retry    = options.retry || this.DEFAULT_RETRY;
+  
+  var scheme = isSecureConnection(request) ? 'https:' : 'http:';
+  this.url = scheme + '//' + request.headers.host + request.url;
+  
+  this.lastEventId = request.headers['last-event-id'] || '';
+  this.readyState  = API.OPEN;
+  
+  var event = new Event('open');
+  event.initEvent('open', false, false);
+  this.dispatchEvent(event);
+  
+  var self = this;
+  this._pingLoop = setInterval(function() {
+    try { this._stream.write(':\r\n\r\n') } catch (e) {}
+  }, this._ping * 1000);
+  
+  ['close', 'end', 'error'].forEach(function(event) {
+    self._stream.addListener(event, function() { self.close() });
+  });
+  
+  var handshake = 'HTTP/1.1 200 OK\r\n' +
+                  'Content-Type: text/event-stream\r\n' +
+                  'Cache-Control: no-cache, no-store\r\n' +
+                  '\r\n\r\n' +
+                  'retry: ' + Math.floor(this._retry * 1000) + '\r\n\r\n';
+  
+  try {
+    this._stream.write(handshake, 'utf8');
+  } catch (e) {}
+};
+
+EventSource.isEventSource = function(request) {
+  var accept = (request.headers.accept || '').split(/\s*,\s*/);
+  return accept.indexOf('text/event-stream') >= 0;
+};
+
+var instance = {
+  DEFAULT_PING:   10,
+  DEFAULT_RETRY:  5,
+  
+  send: function(message, options) {
+    message = message.replace(/(\r\n|\r|\n)/g, '$1data: ');
+    options = options || {};
+    
+    var frame = '';
+    if (options.event) frame += 'event: ' + options.event + '\r\n';
+    if (options.id)    frame += 'id: '    + options.id    + '\r\n';
+    frame += 'data: ' + message + '\r\n\r\n';
+    
+    try {
+      this._stream.write(frame, 'utf8');
+    } catch (e) {}
+  },
+  
+  close: function() {
+    if (this.readyState === API.CLOSING || this.readyState === API.CLOSED)
+      return;
+    
+    this.readyState = API.CLOSED;
+    clearInterval(this._pingLoop);
+    this._response.end();
+    
+    var event = new Event('close');
+    event.initEvent('close', false, false);
+    this.dispatchEvent(event);
+  }
+};
+
+for (var key in API) EventSource.prototype[key] = API[key];
+for (var key in instance) EventSource.prototype[key] = instance[key];
+module.exports = EventSource;
+

lib/faye/websocket.js

@@ -7,15 +7,16 @@
 // * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
 // * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
 
-var Draft75Parser   = require('./websocket/draft75_parser'),
-    Draft76Parser   = require('./websocket/draft76_parser'),
-    Protocol8Parser = require('./websocket/protocol8_parser'),
-    API             = require('./websocket/api');
+var Draft75Parser = require('./websocket/draft75_parser'),
+    Draft76Parser = require('./websocket/draft76_parser'),
+    HybiParser    = require('./websocket/hybi_parser'),
+    API           = require('./websocket/api'),
+    Event         = require('./websocket/api/event');
 
 var getParser = function(request) {
   var headers = request.headers;
   return headers['sec-websocket-version']
-       ? Protocol8Parser
+       ? HybiParser
        : (headers['sec-websocket-key1'] && headers['sec-websocket-key2'])
        ? Draft76Parser
        : Draft75Parser;
@@ -35,7 +36,7 @@ var WebSocket = function(request, socket, head, supportedProtos) {
   this._stream = request.socket;
   
   var scheme = isSecureConnection(request) ? 'wss:' : 'ws:';
-  this.url = scheme + '//' + request.headers.host + request.url;    
+  this.url = scheme + '//' + request.headers.host + request.url;
   this.readyState = API.CONNECTING;
   this.bufferedAmount = 0;
   
@@ -45,11 +46,11 @@ var WebSocket = function(request, socket, head, supportedProtos) {
   var handshake = this._parser.handshakeResponse(head);
   try { this._stream.write(handshake, 'binary') } catch (e) {}
   
-  this.protocol = this._parser.protocol;
+  this.protocol = this._parser.protocol || '';
   this.readyState = API.OPEN;
   this.version = this._parser.getVersion();
   
-  var event = new API.Event('open');
+  var event = new Event('open');
   event.initEvent('open', false, false);
   this.dispatchEvent(event);
   
@@ -65,9 +66,10 @@ var WebSocket = function(request, socket, head, supportedProtos) {
   });
 };
 
-var API = require('./websocket/api');
 for (var key in API) WebSocket.prototype[key] = API[key];
 
-WebSocket.Client = require('./websocket/client');
-module.exports   = WebSocket;
+WebSocket.WebSocket   = WebSocket;
+WebSocket.Client      = require('./websocket/client');
+WebSocket.EventSource = require('./eventsource');
+module.exports        = WebSocket;
 

lib/faye/websocket/api.js

@@ -1,18 +1,15 @@
+var EventTarget = require('./api/event_target'),
+    Event       = require('./api/event');
+
 var API = {
   CONNECTING:   0,
   OPEN:         1,
   CLOSING:      2,
   CLOSED:       3,
   
-  onopen:     null,
-  onmessage:  null,
-  onerror:    null,
-  onclose:    null,
-  protocol:   null,
-  
   receive: function(data) {
     if (this.readyState !== API.OPEN) return false;
-    var event = new API.Event('message');
+    var event = new Event('message');
     event.initEvent('message', false, false);
     event.data = data;
     this.dispatchEvent(event);
@@ -38,7 +35,7 @@ var API = {
     var close = function() {
       this.readyState = API.CLOSED;
       this._stream.end();
-      var event = new API.Event('close', {code: code || 1000, reason: reason || ''});
+      var event = new Event('close', {code: code || 1000, reason: reason || ''});
       event.initEvent('close', false, false);
       this.dispatchEvent(event);
     };
@@ -50,66 +47,10 @@ var API = {
       if (this._parser.close) this._parser.close(code, reason);
       close.call(this);
     }
-  },
-  
-  addEventListener: function(eventType, listener, useCapture) {
-    this._listeners = this._listeners || {};
-    var list = this._listeners[eventType] = this._listeners[eventType] || [];
-    list.push(listener);
-  },
-  
-  removeEventListener: function(eventType, listener, useCapture) {
-    if (!this._listeners || !this._listeners[eventType]) return;
-    
-    if (!listener) {
-      delete this._listeners[eventType];
-      return;
-    }
-    var list = this._listeners[eventType],
-        i    = list.length;
-    
-    while (i--) {
-      if (listener !== list[i]) continue;
-      list.splice(i,1);
-    }
-  },
-  
-  dispatchEvent: function(event) {
-    event.target = event.currentTarget = this;
-    event.eventPhase = API.Event.AT_TARGET;
-    
-    if (this['on' + event.type])
-      this['on' + event.type](event);
-    
-    if (!this._listeners || !this._listeners[event.type]) return;
-    
-    this._listeners[event.type].forEach(function(listener) {
-      listener(event);
-    }, this);
   }
 };
 
-
-var Event = function(eventType, options) {
-  this.type = eventType;
-  for (var key in options)
-    this[key] = options[key];
-};
-    
-Event.prototype.initEvent = function(eventType, canBubble, cancelable) {
-  this.type       = eventType;
-  this.bubbles    = canBubble;
-  this.cancelable = cancelable;
-};
-
-Event.prototype.stopPropagation = function() {};
-Event.prototype.preventDefault  = function() {};
-    
-Event.CAPTURING_PHASE = 1;
-Event.AT_TARGET       = 2;
-Event.BUBBLING_PHASE  = 3;
-
-API.Event = Event;
+for (var key in EventTarget) API[key] = EventTarget[key];
 
 module.exports = API;
 

lib/faye/websocket/api/event.js

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

lib/faye/websocket/api/event_target.js

@@ -0,0 +1,47 @@
+var Event = require('./event');
+
+var EventTarget = {
+  onopen:     null,
+  onmessage:  null,
+  onerror:    null,
+  onclose:    null,
+  
+  addEventListener: function(eventType, listener, useCapture) {
+    this._listeners = this._listeners || {};
+    var list = this._listeners[eventType] = this._listeners[eventType] || [];
+    list.push(listener);
+  },
+  
+  removeEventListener: function(eventType, listener, useCapture) {
+    if (!this._listeners || !this._listeners[eventType]) return;
+    
+    if (!listener) {
+      delete this._listeners[eventType];
+      return;
+    }
+    var list = this._listeners[eventType],
+        i    = list.length;
+    
+    while (i--) {
+      if (listener !== list[i]) continue;
+      list.splice(i,1);
+    }
+  },
+  
+  dispatchEvent: function(event) {
+    event.target = event.currentTarget = this;
+    event.eventPhase = Event.AT_TARGET;
+    
+    if (this['on' + event.type])
+      this['on' + event.type](event);
+    
+    if (!this._listeners || !this._listeners[event.type]) return;
+    
+    this._listeners[event.type].forEach(function(listener) {
+      listener(event);
+    }, this);
+  }
+};
+
+module.exports = EventTarget;
+

lib/faye/websocket/client.js

@@ -1,13 +1,15 @@
-var API = require('./api'),
-    net = require('net'),
+var net = require('net'),
     tls = require('tls');
 
-var Protocol8Parser = require('./protocol8_parser');
+var HybiParser = require('./hybi_parser'),
+    API        = require('./api'),
+    Event      = require('./api/event');
 
 var Client = function(url, protocols) {
   this.url  = url;
   this._uri = require('url').parse(url);
   
+  this.protocol = '';
   this.readyState = API.CONNECTING;
   this.bufferedAmount = 0;
   
@@ -19,7 +21,7 @@ var Client = function(url, protocols) {
                  ? tls.connect(this._uri.port || 443, this._uri.hostname, onConnect)
                  : net.createConnection(this._uri.port || 80, this._uri.hostname);
   
-  this._parser = new Protocol8Parser(this, {masking: true, protocols: protocols});
+  this._parser = new HybiParser(this, {masking: true, protocols: protocols});
   this._stream = connection;
   
   if (!secure) connection.addListener('connect', onConnect);
@@ -51,9 +53,9 @@ Client.prototype._onData = function(data) {
       if (!this._handshake.isComplete()) return;
       
       if (this._handshake.isValid()) {
-        this.protocol = this._handshake.protocol;
+        this.protocol = this._handshake.protocol || '';
         this.readyState = API.OPEN;
-        var event = new API.Event('open');
+        var event = new Event('open');
         event.initEvent('open', false, false);
         this.dispatchEvent(event);
         
@@ -61,7 +63,7 @@ Client.prototype._onData = function(data) {
         
       } else {
         this.readyState = API.CLOSED;
-        var event = new API.Event('close', {code: 1006, reason: ''});
+        var event = new Event('close', {code: 1006, reason: ''});
         event.initEvent('close', false, false);
         this.dispatchEvent(event);
       }

lib/faye/websocket/draft75_parser.js

@@ -1,15 +1,11 @@
 var Draft75Parser = function(webSocket) {
-  this._socket    = webSocket;
-  this._buffer    = [];
-  this._buffering = false;
+  this._socket = webSocket;
+  this._stage  = 0;
 };
 
 var instance = {
-  FRAME_START : new Buffer([0x00]),
-  FRAME_END   : new Buffer([0xFF]),
-  
   getVersion: function() {
-    return 'draft-75';
+    return 'hixie-75';
   },
   
   handshakeResponse: function() {
@@ -21,33 +17,71 @@ var instance = {
                       'utf8');
   },
   
-  parse: function(data) {
-    for (var i = 0, n = data.length; i < n; i++) {
-      switch (data[i]) {
-        case 0x00:
-          this._buffering = 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 0xFF:
-          this._buffer = new Buffer(this._buffer);
-          this._socket.receive(this._buffer.toString('utf8', 0, this._buffer.length));
-          this._buffer = [];
-          this._buffering = false;
+          
+        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;
-        
-        default:
-          if (this._buffering) this._buffer.push(data[i]);
       }
     }
   },
   
+  _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);
     
-    this.FRAME_START.copy(frame, 0);
+    frame[0] = 0x00;
+    frame[buffer.length + 1] = 0xFF;
     buffer.copy(frame, 1);
-    this.FRAME_END.copy(frame, buffer.length + 1);
     
     return frame;
   }

lib/faye/websocket/draft76_parser.js

@@ -23,7 +23,7 @@ var bigEndian = function(number) {
 };
 
 Draft76Parser.prototype.getVersion = function() {
-  return 'draft-76';
+  return 'hixie-76';
 };
   
 Draft76Parser.prototype.handshakeResponse = function(head) {
@@ -75,5 +75,21 @@ Draft76Parser.prototype.parse = function(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,8 +1,8 @@
 var crypto    = require('crypto'),
-    Handshake = require('./protocol8_parser/handshake'),
-    Reader    = require('./protocol8_parser/stream_reader');
+    Handshake = require('./hybi_parser/handshake'),
+    Reader    = require('./hybi_parser/stream_reader');
 
-var Protocol8Parser = function(webSocket, options) {
+var HybiParser = function(webSocket, options) {
   this._reset();
   this._socket    = webSocket;
   this._reader    = new Reader();
@@ -14,7 +14,7 @@ var Protocol8Parser = function(webSocket, options) {
     this._protocols = this._protocols.split(/\s*,\s*/);
 };
 
-Protocol8Parser.mask = function(payload, mask, offset) {
+HybiParser.mask = function(payload, mask, offset) {
   if (mask.length === 0) return payload;
   offset = offset || 0;
   
@@ -63,7 +63,7 @@ var instance = {
   
   getVersion: function() {
     var version = this._socket.request.headers['sec-websocket-version'];
-    return 'protocol-' + version;
+    return 'hybi-' + version;
   },
   
   handshakeResponse: function() {
@@ -230,9 +230,10 @@ var instance = {
     buffer.copy(frame, offset + insert);
     
     if (this._masking) {
-      mask = new Buffer([1,2,3,4].map(function() { return Math.floor(Math.random() * 256) }));
-      mask.copy(frame, header);
-      Protocol8Parser.mask(frame, mask, offset);
+      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;
@@ -251,7 +252,7 @@ var instance = {
   },
   
   _emitFrame: function() {
-    var payload = Protocol8Parser.mask(this._payload, this._mask),
+    var payload = HybiParser.mask(this._payload, this._mask),
         opcode  = this._opcode;
     
     if (opcode === this.OPCODES.continuation) {
@@ -327,7 +328,7 @@ var instance = {
 };
 
 for (var key in instance)
-  Protocol8Parser.prototype[key] = instance[key];
+  HybiParser.prototype[key] = instance[key];
 
-module.exports = Protocol8Parser;
+module.exports = HybiParser;
 

package.json

@@ -1,15 +1,15 @@
 { "name"            : "faye-websocket"
 , "description"     : "Standards-compliant WebSocket server and client"
-, "homepage"        : "http://github.com/jcoglan/faye-websocket-node"
+, "homepage"        : "http://github.com/faye/faye-websocket-node"
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
 , "keywords"        : ["websocket"]
 
-, "version"         : "0.1.2"
+, "version"         : "0.2.0"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/faye/websocket"
-, "devDependencies" : {"jsclass": ">=3.0.4"}
+, "devDependencies" : {"jsclass": ""}
 
-, "bugs"            : "http://github.com/jcoglan/faye-websocket-node/issues"
+, "bugs"            : "http://github.com/faye/faye-websocket-node/issues"
 
 , "licenses"        : [ { "type"    : "MIT"
                         , "url"     : "http://www.opensource.org/licenses/mit-license.php"
@@ -17,7 +17,7 @@
                       ]
 
 , "repositories"    : [ { "type"    : "git"
-                        , "url"     : "git://github.com/jcoglan/faye-websocket-node.git"
+                        , "url"     : "git://github.com/faye/faye-websocket-node.git"
                         }
                       ]
 }

spec/faye/websocket/draft75parser_spec.js

@@ -7,20 +7,56 @@ JS.ENV.Draft75ParserSpec = JS.Test.describe("Draft75Parser", function() { with(t
   }})
   
   describe("parse", function() { with(this) {
-    it("parses text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Hello")
-      parser.parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+    sharedBehavior("draft-75 parser", function() { with(this) {
+      it("parses text frames", function() { with(this) {
+        expect(webSocket, "receive").given("Hello")
+        parser.parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+      }})
+      
+      it("parses multiple frames from the same packet", function() { with(this) {
+        expect(webSocket, "receive").given("Hello").exactly(2)
+        parser.parse([0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+      }})
+      
+      it("parses text frames beginning 0x00-0x7F", function() { with(this) {
+        expect(webSocket, "receive").given("Hello")
+        parser.parse([0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+      }})
+      
+      it("ignores frames with a length header", function() { with(this) {
+        expect(webSocket, "receive").exactly(0)
+        parser.parse([0x80, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+      }})
+      
+      it("parses text following an ignored block", function() { with(this) {
+        expect(webSocket, "receive").given("Hello")
+        parser.parse([0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff])
+      }})
+      
+      it("parses multibyte text frames", function() { with(this) {
+        expect(webSocket, "receive").given("Apple = ")
+        parser.parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
+      }})
+      
+      it("parses frames received in several packets", function() { with(this) {
+        expect(webSocket, "receive").given("Apple = ")
+        parser.parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65])
+        parser.parse([0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
+      }})
+      
+      it("parses fragmented frames", function() { with(this) {
+        expect(webSocket, "receive").given("Hello")
+        parser.parse([0x00, 0x48, 0x65, 0x6c])
+        parser.parse([0x6c, 0x6f, 0xff])
+      }})
     }})
     
-    it("parses multibyte text frames", function() { with(this) {
-      expect(webSocket, "receive").given("Apple = ")
-      parser.parse([0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff])
-    }})
+    behavesLike("draft-75 parser")
     
-    it("parses fragmented frames", function() { with(this) {
-      expect(webSocket, "receive").given("Hello")
-      parser.parse([0x00, 0x48, 0x65, 0x6c])
-      parser.parse([0x6c, 0x6f, 0xff])
+    it("does not close the socket if a 76 close frame is received", function() { with(this) {
+      expect(webSocket, "close").exactly(0)
+      expect(webSocket, "receive").given("")
+      parser.parse([0xFF, 0x00])
     }})
   }})
   

spec/faye/websocket/draft76parser_spec.js

@@ -0,0 +1,28 @@
+var Draft76Parser = require('../../../lib/faye/websocket/draft76_parser')
+
+JS.ENV.Draft76ParserSpec = JS.Test.describe("Draft76Parser", function() { with(this) {
+  before(function() { with(this) {
+    this.webSocket = {dispatchEvent: function() {}}
+    this.parser = new Draft76Parser(webSocket)
+    parser._handshakeComplete = true
+  }})
+  
+  describe("parse", function() { with(this) {
+    behavesLike("draft-75 parser")
+    
+    it("closes the socket if a close frame is received", function() { with(this) {
+      expect(webSocket, "close")
+      parser.parse([0xFF, 0x00])
+    }})
+  }})
+  
+  describe("frame", function() { with(this) {
+    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
+      assertBufferEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], parser.frame("Hello") )
+    }})
+    
+    it("encodes multibyte characters correctly", function() { with(this) {
+      assertBufferEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], parser.frame("Apple = ") )
+    }})
+  }})
+}})

spec/faye/websocket/hybi_parser_spec.js

@@ -1,9 +1,9 @@
-var Protocol8Parser = require('../../../lib/faye/websocket/protocol8_parser')
+var HybiParser = require('../../../lib/faye/websocket/hybi_parser')
 
-JS.ENV.Protocol8ParserSpec = JS.Test.describe("Protocol8Parser", function() { with(this) {
+JS.ENV.HybiParserSpec = JS.Test.describe("HybiParser", function() { with(this) {
   before(function() { with(this) {
     this.webSocket = {dispatchEvent: function() {}}
-    this.parser = new Protocol8Parser(webSocket)
+    this.parser = new HybiParser(webSocket)
   }})
   
   define("parse", function() {
@@ -38,6 +38,11 @@ JS.ENV.Protocol8ParserSpec = JS.Test.describe("Protocol8Parser", function() { wi
       parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
     }})
     
+    it("parses multiple frames from the same packet", function() { with(this) {
+      expect(webSocket, "receive").given("Hello").exactly(2)
+      parse([0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f])
+    }})
+    
     it("parses empty text frames", function() { with(this) {
       expect(webSocket, "receive").given("")
       parse([0x81, 0x00])
@@ -80,6 +85,12 @@ JS.ENV.Protocol8ParserSpec = JS.Test.describe("Protocol8Parser", function() { wi
       parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
     }})
     
+    it("parses frames received in several packets", function() { with(this) {
+      expect(webSocket, "receive").given("Apple = ")
+      parse([0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c])
+      parse([0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf])
+    }})
+    
     it("parses fragmented multibyte text frames", function() { with(this) {
       expect(webSocket, "receive").given("Apple = ")
       parse([0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3])

spec/runner.js

@@ -47,7 +47,8 @@ JS.require('JS.Test', function() {
   
   JS.require( 'ClientSpec',
               'Draft75ParserSpec',
-              'Protocol8ParserSpec',
+              'Draft76ParserSpec',
+              'HybiParserSpec',
               JS.Test.method('autorun'))
 })