Don't skip any Autobahn tests since they run fast enough now.

Prevent stack overflows while parsing.
Refactor Protocol8 parser to read in chunks rather than one byte at a time.
2011-12-17 15:13:28 +00:00 · 2011-12-17 15:13:09 +00:00 · 2011-12-17 14:34:22 +00:00 · 2011-12-17 13:30:05 +00:00 · 2011-12-17 03:06:40 +00:00 · 2011-12-17 01:41:34 +00:00
17 changed files with 389 additions and 279 deletions
@@ -3,8 +3,7 @@ var WebSocket = require('../lib/faye/websocket');
 var host  = 'ws://localhost:9001',
    agent = 'Faye (Node ' + process.version + ')',
    cases = 0,
-    skip  = [247,248,249,250,251,252,253,254,255,
-             256,257,258,259,260,261,262,263,264];
+    skip  = [];

 var socket = new WebSocket.Client(host + '/getCaseCount');

@@ -0,0 +1,41 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+    <title>WebSocket benchmarks</title>
+  </head>
+  <body>
+    
+    <div id="out"></div>
+    
+    <script type="text/javascript">
+      var Socket = window.MozWebSocket || window.WebSocket,
+          socket = new Socket('ws://' + location.hostname + ':' + location.port + '/'),
+          out    = document.getElementById('out');
+      
+      var msg = '', n = 64000;
+      while (n--) msg += 'X';
+      
+      var start = new Date().getTime();
+      
+      function ping(event) {
+        var data = (event && event.data) || '0',
+            id   = parseInt(data.split(':')[0]) + 1;
+        
+        out.innerHTML = id;
+        
+        if (id === 1000) {
+          var time = new Date().getTime() - start;
+          out.innerHTML = 'Time: ' + time;
+        } else {
+          socket.send(id + ':' + msg);
+        }
+      };
+      
+      socket.onopen = ping;
+      socket.onmessage = ping;
+    </script>
+    
+  </body>
+</html>
+
@@ -0,0 +1,21 @@
+defaults
+   mode http
+   timeout client  5s
+   timeout connect 5s
+   timeout server  5s
+
+frontend all 0.0.0.0:3000
+   mode http
+   timeout client 120s
+
+   option forwardfor
+   option http-server-close
+   option http-pretend-keepalive
+
+   default_backend sockets
+
+backend sockets
+   balance uri depth 2
+   timeout server  120s
+   server socket1 127.0.0.1:7000
+
@@ -20,10 +20,10 @@
        socket.send('Hello, world');
      };
      
-      socket.onmessage = function(event) {
+      socket.addEventListener('message', function(event) {
        logger.innerHTML += '<li>MESSAGE: ' + event.data + '</li>';
        setTimeout(function() { socket.send(++index + ' ' + event.data) }, 2000);
-      };
+      });
      
      socket.onclose = function(event) {
        logger.innerHTML += '<li>CLOSE: ' + event.code + ', ' + event.reason + '</li>';
@@ -40,8 +40,10 @@ var WebSocket = function(request, socket, head) {
  this.bufferedAmount = 0;
  
  var Parser = getParser(request);
-  this._parser = new Parser(this, this._stream);
-  this._parser.handshakeResponse(head);
+  this._parser = new Parser(this);
+  
+  var handshake = this._parser.handshakeResponse(head);
+  try { this._stream.write(handshake, 'binary') } catch (e) {}
  
  this.readyState = API.OPEN;
  this.version = this._parser.getVersion();
@@ -53,12 +55,13 @@ var WebSocket = function(request, socket, head) {
  var self = this;
  
  this._stream.addListener('data', function(data) {
-    self._parser.parse(data);
+    var response = self._parser.parse(data);
+    if (!response) return;
+    try { self._stream.write(response, 'binary') } catch (e) {}
  });
-  this._stream.addListener('close', function() {
-    self.close(1006, '', false);
+  ['close', 'end', 'error'].forEach(function(event) {
+    self._stream.addListener(event, function() { self.close(1006, '', false) });
  });
-  this._stream.addListener('error', function() {});
 };

 var API = require('./websocket/api');
@@ -19,7 +19,13 @@ var API = {
  
  send: function(data, type, errorType) {
    if (this.readyState === API.CLOSED) return false;
-    return this._parser.frame(data, type, errorType);
+    var frame = this._parser.frame(data, type, errorType);
+    try {
+      this._stream.write(frame, 'binary');
+      return true;
+    } catch (e) {
+      return false;
+    }
  },
  
  close: function(code, reason, ack) {
@@ -45,13 +51,13 @@ var API = {
    }
  },
  
-  addEventListener: function(type, listener, useCapture) {
+  addEventListener: function(eventType, listener, useCapture) {
    this._listeners = this._listeners || {};
    var list = this._listeners[eventType] = this._listeners[eventType] || [];
    list.push(listener);
  },
  
-  removeEventListener: function(type, listener, useCapture) {
+  removeEventListener: function(eventType, listener, useCapture) {
    if (!this._listeners || !this._listeners[eventType]) return;
    
    if (!listener) {
@@ -74,13 +80,10 @@ var API = {
    if (this['on' + event.type])
      this['on' + event.type](event);
    
-    var args = Array.prototype.slice.call(arguments),
-        eventType = args.shift();
+    if (!this._listeners || !this._listeners[event.type]) return;
    
-    if (!this._listeners || !this._listeners[eventType]) return;
-    
-    this._listeners[eventType].forEach(function(listener) {
-      listener.apply(this, args);
+    this._listeners[event.type].forEach(function(listener) {
+      listener(event);
    }, this);
  }
 };
@@ -5,21 +5,21 @@ var API = require('./api'),
 var Protocol8Parser = require('./protocol8_parser');

 var Client = function(url) {
-  this.url = url;
-  this.uri = require('url').parse(url);
+  this.url  = url;
+  this._uri = require('url').parse(url);
  
  this.readyState = API.CONNECTING;
  this.bufferedAmount = 0;
  
-  var secure     = (this.uri.protocol === 'wss:'),
+  var secure     = (this._uri.protocol === 'wss:'),
      self       = this,
      onConnect  = function() { self._onConnect() },
      
      connection = secure
-                 ? tls.connect(this.uri.port || 443, this.uri.hostname, onConnect)
-                 : net.createConnection(this.uri.port || 80, this.uri.hostname);
+                 ? tls.connect(this._uri.port || 443, this._uri.hostname, onConnect)
+                 : net.createConnection(this._uri.port || 80, this._uri.hostname);
  
-  this._parser = new Protocol8Parser(this, connection, {masking: true});
+  this._parser = new Protocol8Parser(this, {masking: true});
  this._stream = connection;
  
  if (!secure) connection.addListener('connect', onConnect);
@@ -34,9 +34,11 @@ var Client = function(url) {
 };
  
 Client.prototype._onConnect = function() {
-  this._handshake = this._parser.createHandshake(this.uri);
+  this._handshake = this._parser.createHandshake(this._uri, this._stream);
  this._message = [];
-  this._handshake.requestData();
+  try {
+    this._stream.write(this._handshake.requestData(), 'binary');
+  } catch (e) {}
 };

 Client.prototype._onData = function(data) {
@@ -1,6 +1,5 @@
-var Draft75Parser = function(webSocket, stream) {
+var Draft75Parser = function(webSocket) {
  this._socket    = webSocket;
-  this._stream    = stream;
  this._buffer    = [];
  this._buffering = false;
 };
@@ -14,17 +13,12 @@ var instance = {
  },
  
  handshakeResponse: function() {
-    var stream = this._stream;
-    try {
-      stream.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n');
-      stream.write('Upgrade: WebSocket\r\n');
-      stream.write('Connection: Upgrade\r\n');
-      stream.write('WebSocket-Origin: ' + this._socket.request.headers.origin + '\r\n');
-      stream.write('WebSocket-Location: ' + this._socket.url + '\r\n\r\n');
-    } catch (e) {
-      // socket closed while writing
-      // no handshake sent; client will stop using WebSocket
-    }
+    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');
  },
  
  parse: function(data) {
@@ -33,15 +27,14 @@ var instance = {
  },
  
  frame: function(data) {
-    var stream = this._stream;
-    try {
-      stream.write(this.FRAME_START, 'binary');
-      stream.write(new Buffer(data), 'utf8');
-      stream.write(this.FRAME_END, 'binary');
-      return true;
-    } catch (e) {
-      return false;
-    }
+    var buffer = new Buffer(data, 'utf8'),
+        frame  = new Buffer(buffer.length + 2);
+    
+    this.FRAME_START.copy(frame, 0);
+    buffer.copy(frame, 1);
+    this.FRAME_END.copy(frame, buffer.length + 1);
+    
+    return frame;
  },
  
  _handleChar: function(data) {
@@ -27,8 +27,31 @@ Draft76Parser.prototype.getVersion = function() {
 };
  
 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.handshakeSignature = function(head) {
+  if (head.length === 0) return null;
+  this._handshakeComplete = true;
+  
  var request = this._socket.request,
-      stream  = this._stream,
      
      key1    = request.headers['sec-websocket-key1'],
      value1  = numberFromKey(key1) / spacesInKey(key1),
@@ -42,17 +65,14 @@ Draft76Parser.prototype.handshakeResponse = function(head) {
  MD5.update(bigEndian(value2));
  MD5.update(head.toString('binary'));
  
-  try {
-    stream.write('HTTP/1.1 101 Web Socket Protocol Handshake\r\n', 'binary');
-    stream.write('Upgrade: WebSocket\r\n', 'binary');
-    stream.write('Connection: Upgrade\r\n', 'binary');
-    stream.write('Sec-WebSocket-Origin: ' + request.headers.origin + '\r\n', 'binary');
-    stream.write('Sec-WebSocket-Location: ' + this._socket.url + '\r\n\r\n', 'binary');
-    stream.write(MD5.digest('binary'), 'binary');
-  } catch (e) {
-    // socket closed while writing
-    // no handshake sent; client will stop using WebSocket
-  }
+  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);
 };

 module.exports = Draft76Parser;
@@ -1,84 +1,11 @@
-var crypto = require('crypto');
+var crypto    = require('crypto'),
+    Handshake = require('./protocol8_parser/handshake'),
+    Reader    = require('./protocol8_parser/stream_reader');

-var Handshake = function(uri, stream) {
-  this._uri    = uri;
-  this._stream = stream;
-  
-  var buffer = new Buffer(16), i = 16;
-  while (i--) buffer[i] = Math.floor(Math.random() * 254);
-  this._key = buffer.toString('base64');
-  
-  var SHA1 = crypto.createHash('sha1');
-  SHA1.update(this._key + Protocol8Parser.prototype.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.prototype.requestData = function() {
-  var stream = this._stream, u = this._uri;
-  try {
-    stream.write('GET ' + u.pathname + (u.search || '') + ' HTTP/1.1\r\n');
-    stream.write('Host: ' + u.hostname + (u.port ? ':' + u.port : '') + '\r\n');
-    stream.write('Upgrade: websocket\r\n');
-    stream.write('Connection: Upgrade\r\n');
-    stream.write('Sec-WebSocket-Key: ' + this._key + '\r\n');
-    stream.write('Sec-WebSocket-Version: 8\r\n');
-    stream.write('\r\n');
-  } catch (e) {}
-};
-
-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;
-  
-  return upgrade && /^websocket$/i.test(upgrade) &&
-         connection && connection.split(/\s*,\s*/).indexOf('Upgrade') >= 0 &&
-         this._headers['Sec-WebSocket-Accept'] === this._accept;
-};
-
-var Protocol8Parser = function(webSocket, stream, options) {
+var Protocol8Parser = function(webSocket, options) {
  this._reset();
  this._socket  = webSocket;
-  this._stream  = stream;
+  this._reader  = new Reader();
  this._stage   = 0;
  this._masking = options && options.masking;
 };
@@ -92,8 +19,6 @@ var instance = {
  OPCODE: 15,
  LENGTH: 127,
  
-  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
-  
  OPCODES: {
    continuation: 0,
    text:         1,
@@ -131,102 +56,58 @@ var instance = {
    if (!secKey) return;
    
    var SHA1 = crypto.createHash('sha1');
-    SHA1.update(secKey + this.GUID);
+    SHA1.update(secKey + Handshake.GUID);
    var accept = SHA1.digest('base64');
    
-    var stream = this._stream;
-    try {
-      stream.write('HTTP/1.1 101 Switching Protocols\r\n');
-      stream.write('Upgrade: websocket\r\n');
-      stream.write('Connection: Upgrade\r\n');
-      stream.write('Sec-WebSocket-Accept: ' + accept + '\r\n\r\n');
-    } catch (e) {
-      // socket closed while writing
-      // no handshake sent; client will stop using WebSocket
-    }
+    return new Buffer('HTTP/1.1 101 Switching Protocols\r\n' +
+                      'Upgrade: websocket\r\n' +
+                      'Connection: Upgrade\r\n' +
+                      'Sec-WebSocket-Accept: ' + accept + '\r\n\r\n',
+                      'utf8');
  },
  
-  createHandshake: function() {
-    return new Handshake(this._socket.uri, this._stream);
+  createHandshake: function(uri) {
+    return new Handshake(uri);
  },
  
  parse: function(data) {
-    for (var i = 0, n = data.length; i < n; i++) {
+    this._reader.put(data);
+    var buffer = true;
+    while (buffer) {
      switch (this._stage) {
-        case 0: this._parseOpcode(data[i]);         break;
-        case 1: this._parseLength(data[i]);         break;
-        case 2: this._parseExtendedLength(data[i]); break;
-        case 3: this._parseMask(data[i]);           break;
-        case 4: this._parsePayload(data[i]);        break;
-      }
-      if (this._stage === 4 && this._length === 0)
-        this._emitFrame();
-    }
-  },
-  
-  frame: function(data, type, code) {
-    if (this._closed) return;
-    
-    var opcode = this.OPCODES[type || (typeof data === 'string' ? 'text' : 'binary')],
-        buffer = new Buffer(data),
-        insert = code ? 2 : 0,
-        length = buffer.length + insert,
-        masked = this._masking ? this.MASK : 0,
-        stream = this._stream,
-        frame, factor, mask, i, n;
-    
-    data = new Buffer(length);
-    if (code) {
-      data[0] = Math.floor(code / 256);
-      data[1] = code & 255;
-    }
-    for (i = 0, n = buffer.length; i < n; i++)
-      data[insert + i] = buffer[i];
-    
-    if (length <= 125) {
-      frame = new Buffer(2);
-      frame[1] = masked | length;
-    } else if (length >= 126 && length <= 65535) {
-      frame = new Buffer(4);
-      frame[1] = masked | 126;
-      frame[2] = Math.floor(length / 256);
-      frame[3] = length & 255;
-    } else {
-      frame = new Buffer(10);
-      frame[1] = masked | 127;
-      for (var i = 0; i < 8; i++) {
-        factor = Math.pow(2, 8 * (8 - 1 - i));
-        frame[2+i] = Math.floor(length / factor) & 255;
+        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[0] = this.FIN | opcode;
-    
-    if (this._masking) {
-      mask = [1,2,3,4].map(function() { return Math.floor(Math.random() * 255) });
-      for (i = 0, n = data.length; i < n; i++)
-        data[i] = data[i] ^ mask[i % 4];
-    }
-    
-    try {
-      stream.write(frame, 'binary');
-      if (mask) stream.write(new Buffer(mask), 'binary');
-      if (data.length > 0) stream.write(data, 'utf8');
-      return true;
-    } catch (e) {
-      return false;
-    }
-  },
-  
-  close: function(code, reason, callback, context) {
-    if (this._closed) return;
-    if (callback) this._closingCallback = [callback, context];
-    this.frame(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]);
  },
  
  _parseOpcode: function(data) {
@@ -271,23 +152,71 @@ var instance = {
    }
  },
  
-  _parseExtendedLength: function(data) {
-    this._lengthBuffer.push(data);
-    if (this._lengthBuffer.length < this._lengthSize) return;
-    this._length = this._getInteger(this._lengthBuffer);
+  _parseExtendedLength: function(buffer) {
+    this._length = this._getInteger(buffer);
    this._stage  = this._masked ? 3 : 4;
  },
  
-  _parseMask: function(data) {
-    this._mask.push(data);
-    if (this._mask.length < 4) return;
-    this._stage = 4;
+  frame: function(data, type, code) {
+    if (this._closed) return;
+    
+    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),
+        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 & 255;
+    } else {
+      frame[1] = masked | 127;
+      frame[2] = Math.floor(length / Math.pow(2,56)) & 255;
+      frame[3] = Math.floor(length / Math.pow(2,48)) & 255;
+      frame[4] = Math.floor(length / Math.pow(2,40)) & 255;
+      frame[5] = Math.floor(length / Math.pow(2,32)) & 255;
+      frame[6] = Math.floor(length / Math.pow(2,24)) & 255;
+      frame[7] = Math.floor(length / Math.pow(2,16)) & 255;
+      frame[8] = Math.floor(length / Math.pow(2,8))  & 255;
+      frame[9] = length & 255;
+    }
+    
+    if (code) {
+      frame[offset]   = Math.floor(code / 256);
+      frame[offset+1] = code & 255;
+    }
+    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);
+      for (i = 0; i < length; i++)
+        frame[offset + i] = frame[offset + i] ^ mask[i % 4];
+    }
+    
+    return frame;
  },
  
-  _parsePayload: function(data) {
-    this._payload.push(data);
-    if (this._payload.length < this._length) return;
-    this._emitFrame();
+  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() {
@@ -343,7 +272,6 @@ var instance = {
      if (payload.length > 125) return this._socket.close(this.ERRORS.protocol_error, null, false);
      this._socket.send(payload, 'pong');
    }
-    this._stage = 0;
  },
  
  _reset: function() {
@@ -0,0 +1,77 @@
+var crypto = require('crypto');
+
+var Handshake = function(uri) {
+  this._uri = uri;
+  
+  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;
+  return new Buffer('GET ' + u.pathname + (u.search || '') + ' HTTP/1.1\r\n' +
+                    'Host: ' + u.hostname + (u.port ? ':' + u.port : '') + '\r\n' +
+                    'Upgrade: websocket\r\n' +
+                    'Connection: Upgrade\r\n' +
+                    'Sec-WebSocket-Key: ' + this._key + '\r\n' +
+                    'Sec-WebSocket-Version: 8\r\n\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;
+  
+  return upgrade && /^websocket$/i.test(upgrade) &&
+         connection && connection.split(/\s*,\s*/).indexOf('Upgrade') >= 0 &&
+         this._headers['Sec-WebSocket-Accept'] === this._accept;
+};
+
+module.exports = Handshake;
@@ -0,0 +1,43 @@
+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;
@@ -4,7 +4,7 @@
 , "author"          : "James Coglan <jcoglan@gmail.com> (http://jcoglan.com/)"
 , "keywords"        : ["websocket"]

-, "version"         : "0.1.0"
+, "version"         : "0.1.2"
 , "engines"         : {"node": ">=0.4.0"}
 , "main"            : "./lib/faye/websocket"
 , "devDependencies" : {"jsclass": ">=3.0.4"}
@@ -51,7 +51,7 @@ JS.ENV.WebSocketSteps = JS.Test.asyncSteps({
  
  listen_for_message: function(callback) {
    var self = this
-    this._ws.onmessage = function(message) { self._message = message.data }
+    this._ws.addEventListener('message', function(message) { self._message = message.data })
    callback()
  },
  
@@ -3,8 +3,7 @@ var Draft75Parser = require('../../../lib/faye/websocket/draft75_parser')
 JS.ENV.Draft75ParserSpec = JS.Test.describe("Draft75Parser", function() { with(this) {
  before(function() { with(this) {
    this.webSocket = {dispatchEvent: function() {}}
-    this.socket = new FakeSocket
-    this.parser = new Draft75Parser(webSocket, socket)
+    this.parser = new Draft75Parser(webSocket)
  }})
  
  describe("parse", function() { with(this) {
@@ -27,13 +26,11 @@ JS.ENV.Draft75ParserSpec = JS.Test.describe("Draft75Parser", function() { with(t
  
  describe("frame", function() { with(this) {
    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
-      parser.frame("Hello")
-      assertEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], socket.read() )
+      assertBufferEqual( [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff], parser.frame("Hello") )
    }})
    
    it("encodes multibyte characters correctly", function() { with(this) {
-      parser.frame("Apple = ")
-      assertEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], socket.read() )
+      assertBufferEqual( [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff], parser.frame("Apple = ") )
    }})
  }})
 }})
@@ -3,8 +3,7 @@ var Protocol8Parser = require('../../../lib/faye/websocket/protocol8_parser')
 JS.ENV.Protocol8ParserSpec = JS.Test.describe("Protocol8Parser", function() { with(this) {
  before(function() { with(this) {
    this.webSocket = {dispatchEvent: function() {}}
-    this.socket = new FakeSocket
-    this.parser = new Protocol8Parser(webSocket, socket)
+    this.parser = new Protocol8Parser(webSocket)
  }})
  
  define("parse", function() {
@@ -116,18 +115,15 @@ JS.ENV.Protocol8ParserSpec = JS.Test.describe("Protocol8Parser", function() { wi
  
  describe("frame", function() { with(this) {
    it("returns the given string formatted as a WebSocket frame", function() { with(this) {
-      parser.frame("Hello")
-      assertEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], socket.read() )
+      assertBufferEqual( [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f], parser.frame("Hello") )
    }})
    
    it("encodes multibyte characters correctly", function() { with(this) {
-      parser.frame("Apple = ")
-      assertEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], socket.read() )
+      assertBufferEqual( [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf], parser.frame("Apple = ") )
    }})
    
    it("encodes medium-length strings using extra length bytes", function() { with(this) {
-      parser.frame("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello")
-      assertEqual( [129, 126, 0, 200, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111], socket.read() )
+      assertBufferEqual( [129, 126, 0, 200, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111, 72, 101, 108, 108, 111], parser.frame("HelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHelloHello") )
    }})
    
    it("encodes long strings using extra length bytes", function() { with(this) {
@@ -136,18 +132,15 @@ JS.ENV.Protocol8ParserSpec = JS.Test.describe("Protocol8Parser", function() { wi
        message += "Hello"
        output = output.concat([0x48, 0x65, 0x6c, 0x6c, 0x6f])
      }
-      parser.frame(message)
-      assertEqual( output, socket.read() )
+      assertBufferEqual( output, parser.frame(message) )
    }})
    
    it("encodes close frames with an error code", function() { with(this) {
-      parser.frame("Hello", "close", 1002)
-      assertEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], socket.read() )
+      assertBufferEqual( [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f], parser.frame("Hello", "close", 1002) )
    }})
    
    it("encodes pong frames", function() { with(this) {
-      parser.frame("", "pong")
-      assertEqual( [0x8a, 0x00], socket.read() )
+      assertBufferEqual( [0x8a, 0x00], parser.frame("", "pong") )
    }})
  }})
 }})
@@ -6,23 +6,6 @@ var WebSocket = require('../lib/faye/websocket'),
    https     = require('https')


-JS.ENV.FakeSocket = function() {
-  this._fragments = []
-}
-FakeSocket.prototype.write = function(buffer, encoding) {
-  this._fragments.push([buffer, encoding])
-}
-FakeSocket.prototype.read = function() {
-  var output = []
-  this._fragments.forEach(function(buffer, i) {
-    for (var j = 0, n = buffer[0].length; j < n; j++)
-    output.push(buffer[0][j])
-  })
-  return output
-}
-FakeSocket.prototype.addListener = function() {}
-
-
 JS.ENV.EchoServer = function() {}
 EchoServer.prototype.listen = function(port, ssl) {
  var server = ssl
@@ -55,6 +38,13 @@ JS.Packages(function() { with(this) {


 JS.require('JS.Test', function() {
+  JS.Test.Unit.Assertions.define("assertBufferEqual", function(array, buffer) {
+    this.assertEqual(array.length, buffer.length);
+    var ary = [], n = buffer.length;
+    while (n--) ary[n] = buffer[n];
+    this.assertEqual(array, ary);
+  })
+  
  JS.require( 'ClientSpec',
              'Draft75ParserSpec',
              'Protocol8ParserSpec',
Author	SHA1	Message	Date
James Coglan	5635baf3a7	Don't skip any Autobahn tests since they run fast enough now.	2011-12-17 15:13:28 +00:00
James Coglan	2fa34ef097	Prevent stack overflows while parsing.	2011-12-17 15:13:09 +00:00
James Coglan	06f4c51a5b	Refactor Protocol8 parser to read in chunks rather than one byte at a time.	2011-12-17 14:34:22 +00:00
James Coglan	3fa6e43ca9	Move Protocol8Parser.Handshake into its own file.	2011-12-17 13:30:05 +00:00
James Coglan	a138004ec3	Don't pass TCP socket in when constructing a parser.	2011-12-17 03:06:40 +00:00
James Coglan	d295047393	Decouple TCP sockets from parsers.	2011-12-17 01:41:34 +00:00
James Coglan	6f1bc69cc0	Remove an unneeded local var.	2011-12-16 23:04:23 +00:00
James Coglan	c2ad20e226	Make Protocol8's frame() method much faster.	2011-12-16 23:03:23 +00:00
James Coglan	880398ff29	Merge remote branch 'majek/issue7'	2011-12-16 21:12:51 +00:00
James Coglan	0ea03585f9	Add benchmarking page.	2011-12-16 21:11:23 +00:00
James Coglan	918f86f58d	Inline some parsing methods to improve performance.	2011-12-16 16:45:27 +00:00
Marek Majkowski	2f4f1cdc8f	Fix #7 - random values should be 0...255 inclusive.	2011-12-16 15:07:20 +00:00
James Coglan	19da8de414	Bump version to 0.1.2.	2011-12-05 09:39:40 +00:00
James Coglan	85ddb3f3dc	Remove some comments.	2011-12-05 09:38:10 +00:00
James Coglan	7e2461e153	Fix draft-76 sockets when running behind HAProxy.	2011-12-04 21:15:24 +00:00
James Coglan	ca3571f103	Don't do so many writes.	2011-12-03 21:37:38 +00:00
James Coglan	27f8f9a0f2	Detect closed sockets on the server side.	2011-12-02 10:00:25 +00:00
James Coglan	b1ead4947e	Bump version to 0.1.1.	2011-11-30 00:57:00 +00:00
James Coglan	8f1739e41c	Change example back to using onmessage.	2011-11-29 21:08:37 +00:00
James Coglan	b5a3de9112	Use addEventListener in the tests.	2011-11-29 21:01:27 +00:00
James Coglan	642532f928	Use addEventListener to listen for messages in examples.	2011-11-29 13:08:22 +00:00
James Coglan	85a11d58d9	Fix broken EventTarget interface.	2011-11-29 12:47:28 +00:00