Release 0.8.5

Expose socket.transport

History.md

@@ -1,4 +1,60 @@
 
+0.8.5 / 2011-10-07
+==================
+
+  * Added websocket draft HyBi-16 support. [einaros]
+  * Fixed websocket continuation bugs. [einaros]
+  * Fixed flashsocket transport name.
+  * Fixed websocket tests.
+  * Ensured `parser#decodePayload` doesn't choke.
+  * Added http referrer verification to manager verifyOrigin.
+  * Added access control for cross domain xhr handshakes [3rd-Eden]
+  * Added support for automatic generation of socket.io files [3rd-Eden]
+  * Added websocket binary support [einaros]
+  * Added gzip support for socket.io.js [3rd-Eden]
+  * Expose socket.transport [3rd-Eden]
+  * Updated client.
+
+0.8.4 / 2011-09-06
+==================
+
+  * Client build
+
+0.8.3 / 2011-09-03
+==================
+
+  * Fixed `\n` parsing for non-JSON packets (fixes #479).
+  * Fixed parsing of certain unicode characters (fixes #451).
+  * Fixed transport message packet logging.
+  * Fixed emission of `error` event resulting in an uncaught exception if unhandled (fixes #476).
+  * Fixed; allow for falsy values as the configuration value of `log level` (fixes #491).
+  * Fixed repository URI in `package.json`. Fixes #504.
+  * Added text/plain content-type to handshake responses [einaros]
+  * Improved single byte writes [einaros]
+  * Updated socket.io-flashsocket default port from 843 to 10843 [3rd-Eden]
+  * Updated client.
+
+0.8.2 / 2011-08-29
+==================
+
+  * Updated client.
+
+0.8.1 / 2011-08-29
+==================
+
+  * Fixed utf8 bug in send framing in websocket [einaros]
+  * Fixed typo in docs [Znarkus]
+  * Fixed bug in send framing for over 64kB of data in websocket [einaros]
+  * Corrected ping handling in websocket transport [einaros]
+
+0.8.0 / 2011-08-28
+==================
+
+  * Updated to work with two-level websocket versioning. [einaros]
+  * Added hybi07 support. [einaros]
+  * Added hybi10 support. [einaros]
+  * Added http referrer verification to manager.js verifyOrigin. [einaors]
+
 0.7.11 / 2011-08-27
 ===================
 

Readme.md

@@ -60,7 +60,7 @@ Besides `connect`, `message` and `disconnect`, you can emit custom events:
 var io = require('socket.io').listen(80);
 
 io.sockets.on('connection', function (socket) {
-  io.sockets.emit('this', { will: 'be received by everyone');
+  io.sockets.emit('this', { will: 'be received by everyone' });
 
   socket.on('private message', function (from, msg) {
     console.log('I received a private message by ', from, ' saying ', msg);
@@ -222,7 +222,7 @@ io.sockets.on('connection', function (socket) {
 ```html
 <script>
   var socket = io.connect(); // TIP: .connect with no args does auto-discovery
-  socket.on('connection', function () {
+  socket.on('connect', function () { // TIP: you can avoid listening on `connect` and listen on events directly too!
     socket.emit('ferret', 'tobi', function (data) {
       console.log(data); // data will be 'woot'
     });

lib/manager.js

@@ -18,6 +18,7 @@ var fs = require('fs')
   , Socket = require('./socket')
   , MemoryStore = require('./stores/memory')
   , SocketNamespace = require('./namespace')
+  , Static = require('./static')
   , EventEmitter = process.EventEmitter;
 
 /**
@@ -61,6 +62,7 @@ function Manager (server, options) {
     , log: true
     , store: new MemoryStore
     , logger: new Logger
+    , static: new Static(this)
     , heartbeats: true
     , resource: '/socket.io'
     , transports: defaultTransports
@@ -71,11 +73,13 @@ function Manager (server, options) {
     , 'heartbeat interval': 20
     , 'polling duration': 20
     , 'flash policy server': true
-    , 'flash policy port': 843
+    , 'flash policy port': 10843
     , 'destroy upgrade': true
     , 'browser client': true
+    , 'browser client cache': true
     , 'browser client minification': false
     , 'browser client etag': false
+    , 'browser client gzip': false
     , 'browser client handler': false
     , 'client store expiration': 15
   };
@@ -84,14 +88,18 @@ function Manager (server, options) {
     this.settings[i] = options[i];
   }
 
+  var self = this;
+
   this.initStore();
 
+  this.on('set:store', function() {
+    self.initStore();
+  });
+
   // reset listeners
   this.oldListeners = server.listeners('request');
   server.removeAllListeners('request');
 
-  var self = this;
-
   server.on('request', function (req, res) {
     self.handleRequest(req, res);
   });
@@ -141,11 +149,21 @@ Manager.prototype.__defineGetter__('log', function () {
   if (this.disabled('log')) return;
 
   var logger = this.get('logger');
-  logger.level = this.get('log level');
+  logger.level = this.get('log level') || -1;
 
   return logger;
 });
 
+/**
+ * Static accessor.
+ *
+ * @api public
+ */
+
+Manager.prototype.__defineGetter__('static', function () {
+  return this.get('static');
+});
+
 /**
  * Get settings.
  *
@@ -516,7 +534,7 @@ Manager.prototype.handleRequest = function (req, res) {
 
   if (data.static || !data.transport && !data.protocol) {
     if (data.static && this.enabled('browser client')) {
-      this.handleClientRequest(req, res, data);
+      this.static.write(data.path, req, res);
     } else {
       res.writeHead(200);
       res.end('Welcome to socket.io.');
@@ -652,104 +670,6 @@ Manager.prototype.handleClient = function (data, req) {
   }
 };
 
-/**
- * Dictionary for static file serving
- *
- * @api public
- */
-
-Manager.static = {
-    cache: {}
-  , paths: {
-        '/static/flashsocket/WebSocketMain.swf': client.dist + '/WebSocketMain.swf'
-      , '/static/flashsocket/WebSocketMainInsecure.swf':
-          client.dist + '/WebSocketMainInsecure.swf'
-      , '/socket.io.js':  client.dist + '/socket.io.js'
-      , '/socket.io.js.min': client.dist + '/socket.io.min.js'
-    }
-  , mime: {
-        'js': {
-            contentType: 'application/javascript'
-          , encoding: 'utf8'
-        }
-      , 'swf': {
-            contentType: 'application/x-shockwave-flash'
-          , encoding: 'binary'
-        }
-    }
-};
-
-/**
- * Serves the client.
- *
- * @api private
- */
-
-Manager.prototype.handleClientRequest = function (req, res, data) {
-  var static = Manager.static
-    , extension = data.path.split('.').pop()
-    , file = data.path + (this.enabled('browser client minification')
-        && extension == 'js' ? '.min' : '')
-    , location = static.paths[file]
-    , cache = static.cache[file];
-
-  var self = this;
-
-  /**
-   * Writes a response, safely
-   *
-   * @api private
-   */
-
-  function write (status, headers, content, encoding) {
-    try {
-      res.writeHead(status, headers || null);
-      res.end(content || '', encoding || null);
-    } catch (e) {}
-  }
-
-  function serve () {
-    if (req.headers['if-none-match'] === cache.Etag) {
-      return write(304);
-    }
-
-    var mime = static.mime[extension]
-      , headers = {
-      'Content-Type': mime.contentType
-    , 'Content-Length': cache.length
-    };
-
-    if (self.enabled('browser client etag') && cache.Etag) {
-      headers.Etag = cache.Etag;
-    }
-
-    write(200, headers, cache.content, mime.encoding);
-    self.log.debug('served static ' + data.path);
-  }
-
-  if (this.get('browser client handler')) {
-    this.get('browser client handler').call(this, req, res);
-  } else if (!cache) {
-    fs.readFile(location, function (err, data) {
-      if (err) {
-        write(500, null, 'Error serving static ' + data.path);
-        self.log.warn('Can\'t cache '+ data.path +', ' + err.message);
-        return;
-      }
-
-      cache = Manager.static.cache[file] = {
-        content: data
-      , length: data.length
-      , Etag: client.version
-      };
-
-      serve();
-    });
-  } else {
-    serve();
-  }
-};
-
 /**
  * Generates a session id.
  *
@@ -768,14 +688,18 @@ Manager.prototype.generateId = function () {
  */
 
 Manager.prototype.handleHandshake = function (data, req, res) {
-  var self = this;
+  var self = this
+    , origin = req.headers.origin
+    , headers = {
+        'Content-Type': 'text/plain'
+    };
 
   function writeErr (status, message) {
     if (data.query.jsonp) {
       res.writeHead(200, { 'Content-Type': 'application/javascript' });
       res.end('io.j[' + data.query.jsonp + '](new Error("' + message + '"));');
     } else {
-      res.writeHead(status);
+      res.writeHead(status, headers);
       res.end(message);
     }
   };
@@ -792,6 +716,15 @@ Manager.prototype.handleHandshake = function (data, req, res) {
 
   var handshakeData = this.handshakeData(data);
 
+  if (origin) {
+    // https://developer.mozilla.org/En/HTTP_Access_Control
+    headers['Access-Control-Allow-Origin'] = '*';
+
+    if (req.headers.cookie) {
+      headers['Access-Control-Allow-Credentials'] = 'true';
+    }
+  }
+
   this.authorize(handshakeData, function (err, authorized, newData) {
     if (err) return error(err);
 
@@ -808,7 +741,7 @@ Manager.prototype.handleHandshake = function (data, req, res) {
         hs = 'io.j[' + data.query.jsonp + '](' + JSON.stringify(hs) + ');';
         res.writeHead(200, { 'Content-Type': 'application/javascript' });
       } else {
-        res.writeHead(200);
+        res.writeHead(200, headers);
       }
 
       res.end(hs);
@@ -866,7 +799,7 @@ Manager.prototype.handshakeData = function (data) {
  */
 
 Manager.prototype.verifyOrigin = function (request) {
-  var origin = request.headers.origin
+  var origin = request.headers.origin || request.headers.referer
     , origins = this.get('origins');
 
   if (origin === 'null') origin = '*';
@@ -878,14 +811,19 @@ Manager.prototype.verifyOrigin = function (request) {
   if (origin) {
     try {
       var parts = url.parse(origin);
-
-      return
-        ~origins.indexOf(parts.host + ':' + parts.port) ||
-        ~origins.indexOf(parts.host + ':*') ||
+      var ok =
+        ~origins.indexOf(parts.hostname + ':' + parts.port) ||
+        ~origins.indexOf(parts.hostname + ':*') ||
         ~origins.indexOf('*:' + parts.port);
-    } catch (ex) {}
+      if (!ok) this.log.warn('illegal origin: ' + origin);
+      return ok;
+    } catch (ex) {
+      this.log.warn('error parsing origin');
+    }
+  }
+  else {
+    this.log.warn('origin missing from handshake, yet required by config');        
   }
-
   return false;
 };
 
@@ -974,7 +912,7 @@ Manager.prototype.checkRequest = function (req) {
       data.protocol = Number(pieces[1]);
       data.transport = pieces[2];
       data.id = pieces[3];
-      data.static = !!Manager.static.paths[path];
+      data.static = !!this.static.has(path);
     };
 
     return data;

lib/namespace.js

@@ -324,8 +324,9 @@ SocketNamespace.prototype.handlePacket = function (sessid, packet) {
     case 'event':
       var params = [packet.name].concat(packet.args);
 
-      if (dataAck)
+      if (dataAck) {
         params.push(ack);
+      }
 
       socket.$emit.apply(socket, params);
       break;

lib/parser.js

@@ -138,7 +138,7 @@ exports.encodePayload = function (packets) {
  * @api private
  */
 
-var regexp = /^([^:]+):([0-9]+)?(\+)?:([^:]+)?:?(.*)?$/;
+var regexp = /([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/;
 
 exports.decodePacket = function (data) {
   var pieces = data.match(regexp);
@@ -223,6 +223,10 @@ exports.decodePacket = function (data) {
  */
 
 exports.decodePayload = function (data) {
+  if (undefined == data || null == data) {
+    return [];
+  }
+
   if (data[0] == '\ufffd') {
     var ret = [];
 

lib/socket.io.js

@@ -15,7 +15,7 @@ var client = require('socket.io-client');
  * Version.
  */
 
-exports.version = '0.7.11';
+exports.version = '0.8.5';
 
 /**
  * Supported protocol version.
@@ -95,6 +95,14 @@ exports.Transport = require('./transport');
 
 exports.Socket = require('./socket');
 
+/**
+ * Static constructor.
+ *
+ * @api public
+ */
+
+exports.Static = require('./static');
+
 /**
  * Store constructor.
  *

lib/socket.js

@@ -11,7 +11,7 @@
 
 var parser = require('./parser')
   , util = require('./util')
-  , EventEmitter = process.EventEmitter;
+  , EventEmitter = process.EventEmitter
 
 /**
  * Export the constructor.
@@ -19,6 +19,12 @@ var parser = require('./parser')
 
 exports = module.exports = Socket;
 
+/**
+ * Default error event listener to prevent uncaught exceptions.
+ */
+
+var defaultError = function () {};
+
 /**
  * Socket constructor.
  *
@@ -39,6 +45,7 @@ function Socket (manager, id, nsp, readable) {
   this.setFlags();
   this.readable = readable;
   this.store = this.manager.store.client(this.id);
+  this.on('error', defaultError);
 };
 
 /**
@@ -57,6 +64,16 @@ Socket.prototype.__defineGetter__('handshake', function () {
   return this.manager.handshaken[this.id];
 });
 
+/**
+ * Accessor shortcut for the transport type
+ *
+ * @api private
+ */
+
+Socket.prototype.__defineGetter__('transport', function () {
+  return this.manager.transports[this.id].name;
+});
+
 /**
  * Accessor shortcut for the logger.
  *
@@ -160,7 +177,7 @@ Socket.prototype.join = function (name, fn) {
 };
 
 /**
- * Joins a user to a room.
+ * Un-joins a user from a room.
  *
  * @api public
  */

lib/static.js

@@ -0,0 +1,374 @@
+
+/*!
+* socket.io-node
+* Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+* MIT Licensed
+*/
+
+/**
+ * Module dependencies.
+ */
+
+var client = require('socket.io-client')
+  , cp = require('child_process')
+  , fs = require('fs')
+  , util = require('./util');
+
+/**
+ * File type details.
+ *
+ * @api private
+ */
+
+var mime = {
+    js: {
+        type: 'application/javascript'
+      , encoding: 'utf8'
+      , gzip: true
+    }
+  , swf: {
+        type: 'application/x-shockwave-flash'
+      , encoding: 'binary'
+      , gzip: false
+    }
+};
+
+/**
+ * Regexp for matching custom transport patterns. Users can configure their own
+ * socket.io bundle based on the url structure. Different transport names are
+ * concatinated using the `+` char. /socket.io/socket.io+websocket.js should
+ * create a bundle that only contains support for the websocket.
+ *
+ * @api private
+ */
+
+var bundle = /\+((?:\+)?[\w\-]+)*(?:\.js)$/g;
+
+/**
+ * Export the constructor
+ */
+
+exports = module.exports = Static;
+
+/**
+ * Static constructor
+ *
+ * @api public
+ */
+
+function Static (manager) {
+  this.manager = manager;
+  this.cache = {};
+  this.paths = {};
+
+  this.init();
+}
+
+/**
+ * Initialize the Static by adding default file paths.
+ *
+ * @api public
+ */
+
+Static.prototype.init = function () {
+  /**
+   * Generates a unique id based the supplied transports array
+   *
+   * @param {Array} transports The array with transport types
+   * @api private
+   */
+  function id (transports) {
+    var id = transports.join('').split('').map(function (char) {
+      return ('' + char.charCodeAt(0)).split('').pop();
+    }).reduce(function (char, id) {
+      return char +id;
+    });
+
+    return client.version + ':' + id;
+  }
+
+  /**
+   * Generates a socket.io-client file based on the supplied transports.
+   *
+   * @param {Array} transports The array with transport types
+   * @param {Function} callback Callback for the static.write
+   * @api private
+   */
+
+  function build (transports, callback) {
+    client.builder(transports, {
+          minify: self.manager.enabled('browser client minification')
+      }, function (err, content) {
+        callback(err, content ? new Buffer(content) : null, id(transports));
+      }
+    );
+  }
+
+  var self = this;
+
+  // add our default static files
+  this.add('/static/flashsocket/WebSocketMain.swf', {
+      file: client.dist + '/WebSocketMain.swf'
+  });
+
+  this.add('/static/flashsocket/WebSocketMainInsecure.swf', {
+      file: client.dist + '/WebSocketMainInsecure.swf'
+  });
+
+  // generates dedicated build based on the available transports
+  this.add('/socket.io.js', function (path, callback) {
+    build(self.manager.get('transports'), callback);
+  });
+
+  // allow custom builds based on url paths
+  this.add('/socket.io+', { mime: mime.js }, function (path, callback) {
+    var available = self.manager.get('transports')
+      , matches = bundle.exec(path)
+      , transports = [];
+
+    if (!matches) return callback('No valid transports');
+
+    // make sure they valid transports
+    matches[0].split('.')[0].split('+').slice(1).forEach(function (transport) {
+      if (!!~available.indexOf(transport)) {
+        transports.push(transport);
+      }
+    });
+
+    if (!transports.length) return callback('No valid transports');
+    build(transports, callback);
+  });
+
+  // clear cache when transports change
+  this.manager.on('set:transports', function (key, value) {
+    delete self.cache['/socket.io.js'];
+    Object.keys(self.cache).forEach(function (key) {
+      if (bundle.test(key)) {
+        delete self.cache[key];
+      }
+    });
+  });
+};
+
+/**
+ * Gzip compress buffers.
+ *
+ * @param {Buffer} data The buffer that needs gzip compression
+ * @param {Function} callback
+ * @api public
+ */
+
+Static.prototype.gzip = function (data, callback) {
+  var gzip = cp.spawn('gzip', ['-9', '-c', '-f', '-n'])
+    , encoding = Buffer.isBuffer(data) ? 'binary' : 'utf8'
+    , buffer = []
+    , err;
+
+  gzip.stdout.on('data', function (data) {
+    buffer.push(data);
+  });
+
+  gzip.stderr.on('data', function (data) {
+    err = data +'';
+    buffer.length = 0;
+  });
+
+  gzip.on('exit', function () {
+    if (err) return callback(err);
+
+    var size = 0
+      , index = 0
+      , i = buffer.length
+      , content;
+
+    while (i--) {
+      size += buffer[i].length;
+    }
+
+    content = new Buffer(size);
+    i = buffer.length;
+
+    buffer.forEach(function (buffer) {
+      var length = buffer.length;
+
+      buffer.copy(content, index, 0, length);
+      index += length;
+    });
+
+    buffer.length = 0;
+    callback(null, content);
+  });
+
+  gzip.stdin.end(data, encoding);
+};
+
+/**
+ * Is the path a static file?
+ *
+ * @param {String} path The path that needs to be checked
+ * @api public
+ */
+
+Static.prototype.has = function (path) {
+  // fast case
+  if (this.paths[path]) return this.paths[path];
+
+  var keys = Object.keys(this.paths)
+    , i = keys.length;
+ 
+  while (i--) {
+    if (!!~path.indexOf(keys[i])) return this.paths[keys[i]];
+  }
+
+  return false;
+};
+
+/**
+ * Add new paths new paths that can be served using the static provider.
+ *
+ * @param {String} path The path to respond to
+ * @param {Options} options Options for writing out the response
+ * @param {Function} [callback] Optional callback if no options.file is
+ * supplied this would be called instead.
+ * @api public
+ */
+
+Static.prototype.add = function (path, options, callback) {
+  var extension = /(?:\.(\w{1,4}))$/.exec(path);
+
+  if (!callback && typeof options == 'function') {
+    callback = options;
+    options = {};
+  }
+
+  options.mime = options.mime || (extension ? mime[extension[1]] : false);
+
+  if (callback) options.callback = callback;
+  if (!(options.file || options.callback) || !options.mime) return false;
+
+  this.paths[path] = options;
+
+  return true;
+};
+
+/**
+ * Writes a static response.
+ *
+ * @param {String} path The path for the static content
+ * @param {HTTPRequest} req The request object
+ * @param {HTTPResponse} res The response object
+ * @api public
+ */
+
+Static.prototype.write = function (path, req, res) {
+  /**
+   * Write a response without throwing errors because can throw error if the
+   * response is no longer writable etc.
+   *
+   * @api private
+   */
+
+  function write (status, headers, content, encoding) {
+    try {
+      res.writeHead(status, headers || undefined);
+      res.end(content || '', encoding || undefined);
+    } catch (e) {}
+  }
+
+  /**
+   * Answers requests depending on the request properties and the reply object.
+   *
+   * @param {Object} reply The details and content to reply the response with
+   * @api private
+   */
+
+  function answer (reply) {
+    var cached = req.headers['if-none-match'] === reply.etag;
+    if (cached && self.manager.enabled('browser client etag')) {
+      return write(304);
+    }
+
+    var accept = req.headers['accept-encoding'] || ''
+      , gzip = !!~accept.toLowerCase().indexOf('gzip')
+      , mime = reply.mime
+      , headers = {
+          'Content-Type': mime.type
+      };
+
+    // check if we can add a etag
+    if (self.manager.enabled('browser client etag') && reply.etag) {
+      headers['Etag'] = reply.etag;
+    }
+
+    // check if we can send gzip data
+    if (gzip && reply.gzip) {
+      headers['Content-Length'] = reply.gzip.length;
+      headers['Content-Encoding'] = 'gzip';
+      write(200, headers, reply.gzip.content, mime.encoding);
+    } else {
+      headers['Content-Length'] = reply.length;
+      write(200, headers, reply.content, mime.encoding);
+    }
+
+    self.manager.log.debug('served static content ' + path);
+  }
+
+  var self = this
+    , details;
+
+  // most common case first
+  if (this.manager.enabled('browser client cache') && this.cache[path]) {
+    return answer(this.cache[path]);
+  } else if (this.manager.get('browser client handler')) {
+    return this.manager.get('browser client handler').call(this, req, res);
+  } else if ((details = this.has(path))) {
+    /**
+     * A small helper function that will let us deal with fs and dynamic files
+     *
+     * @param {Object} err Optional error
+     * @param {Buffer} content The data
+     * @api private
+     */
+
+    function ready (err, content, etag) {
+      if (err) {
+        self.manager.log.warn('Unable to serve file. ' + (err.message || err));
+        return write(500, null, 'Error serving static ' + path);
+      }
+
+      // store the result in the cache
+      var reply = self.cache[path] = {
+            content: content
+          , length: content.length
+          , mime: details.mime
+          , etag: etag || client.version
+        };
+
+      // check if gzip is enabled
+      if (details.mime.gzip && self.manager.enabled('browser client gzip')) {
+        self.gzip(content, function (err, content) {
+          if (!err) {
+            reply.gzip = {
+                content: content
+              , length: content.length
+            }
+          }
+
+          answer(reply);
+        });
+      } else {
+        answer(reply);
+      }
+    }
+
+    if (details.file) {
+      fs.readFile(details.file, ready);
+    } else if(details.callback) {
+      details.callback.call(this, path, ready);
+    } else {
+      write(404, null, 'File handle not found');
+    }
+  } else {
+    write(404, null, 'File not found');
+  }
+};

lib/stores/redis.js

@@ -60,12 +60,28 @@ function Redis (opts) {
     }
   }
 
-  var redis = opts.redis || require('redis');
+  var redis = opts.redis || require('redis')
+    , RedisClient = redis.RedisClient;
 
   // initialize a pubsub client and a regular client
-  this.pub = redis.createClient(opts.redisPub);
-  this.sub = redis.createClient(opts.redisSub);
-  this.cmd = redis.createClient(opts.redisClient);
+  if (opts.redisPub instanceof RedisClient) {
+    this.pub = opts.redisPub;
+  } else {
+    opts.redisPub || (opts.redisPub = {});
+    this.pub = redis.createClient(opts.redisPub.port, opts.redisPub.host, opts.redisPub);
+  }
+  if (opts.redisSub instanceof RedisClient) {
+    this.sub = opts.redisSub;
+  } else {
+    opts.redisSub || (opts.redisSub = {});
+    this.sub = redis.createClient(opts.redisSub.port, opts.redisSub.host, opts.redisSub);
+  }
+  if (opts.redisClient instanceof RedisClient) {
+    this.cmd = opts.redisClient;
+  } else {
+    opts.redisClient || (opts.redisClient = {});
+    this.cmd = redis.createClient(opts.redisClient.port, opts.redisClient.host, opts.redisClient);
+  }
 
   Store.call(this, opts);
 };
@@ -118,7 +134,7 @@ Redis.prototype.subscribe = function (name, consumer, fn) {
         self.on('unsubscribe', function unsubscribe (ch) {
           if (name == ch) {
             self.sub.removeListener('message', message);
-            self.removeEvent('unsubscribe', unsubscribe);
+            self.removeListener('unsubscribe', unsubscribe);
           }
         });
 

lib/transports/flashsocket.js

@@ -24,7 +24,7 @@ exports = module.exports = FlashSocket;
  */
  
 function FlashSocket (mng, data, req) {
-  WebSocket.call(this, mng, data, req);
+  return WebSocket.call(this, mng, data, req);
 }
 
 /**

lib/transports/http.js

@@ -56,7 +56,7 @@ HTTPTransport.prototype.handleRequest = function (req) {
     req.on('end', function () {
       res.writeHead(200, headers);
       res.end('1');
-      
+
       self.onData(self.postEncoded ? qs.parse(buffer).d : buffer);
     });
 
@@ -83,9 +83,9 @@ HTTPTransport.prototype.handleRequest = function (req) {
 
 HTTPTransport.prototype.onData = function (data) {
   var messages = parser.decodePayload(data);
+  this.log.debug(this.name + ' received data packet', data);
 
   for (var i = 0, l = messages.length; i < l; i++) {
-    this.log.debug(this.name + ' received data packet', data);
     this.onMessage(messages[i]);
   }
 };

lib/transports/websocket.js

@@ -9,10 +9,7 @@
  * Module requirements.
  */
 
-var Transport = require('../transport')
-  , EventEmitter = process.EventEmitter
-  , crypto = require('crypto')
-  , parser = require('../parser');
+var protocolVersions = require('./websocket/');
 
 /**
  * Export the constructor.
@@ -28,323 +25,12 @@ exports = module.exports = WebSocket;
  */
 
 function WebSocket (mng, data, req) {
-  // parser
-  var self = this;
-
-  this.parser = new Parser();
-  this.parser.on('data', function (packet) {
-    self.log.debug(self.name + ' received data packet', packet);
-    self.onMessage(parser.decodePacket(packet));
-  });
-  this.parser.on('close', function () {
-    self.end();
-  });
-  this.parser.on('error', function () {
-    self.end();
-  });
-
-  Transport.call(this, mng, data, req);
-};
-
-/**
- * Inherits from Transport.
- */
-
-WebSocket.prototype.__proto__ = Transport.prototype;
-
-/**
- * Transport name
- *
- * @api public
- */
-
-WebSocket.prototype.name = 'websocket';
-
-/**
- * Called when the socket connects.
- *
- * @api private
- */
-
-WebSocket.prototype.onSocketConnect = function () {
-  var self = this;
-
-  this.socket.setNoDelay(true);
-
-  this.buffer = true;
-  this.buffered = [];
-
-  if (this.req.headers.upgrade !== 'WebSocket') {
-    this.log.warn(this.name + ' connection invalid');
-    this.end();
-    return;
+  var transport
+    , version = req.headers['sec-websocket-version'];
+  if (typeof version !== 'undefined' && typeof protocolVersions[version] !== 'undefined') {
+    transport = new protocolVersions[version](mng, data, req);
   }
-
-  var origin = this.req.headers.origin
-    , location = (this.socket.encrypted ? 'wss' : 'ws')
-               + '://' + this.req.headers.host + this.req.url
-    , waitingForNonce = false;
-
-  if (this.req.headers['sec-websocket-key1']) {
-    // If we don't have the nonce yet, wait for it (HAProxy compatibility).
-    if (! (this.req.head && this.req.head.length >= 8)) {
-      waitingForNonce = true;
-    }
-
-    var headers = [
-        'HTTP/1.1 101 WebSocket Protocol Handshake'
-      , 'Upgrade: WebSocket'
-      , 'Connection: Upgrade'
-      , 'Sec-WebSocket-Origin: ' + origin
-      , 'Sec-WebSocket-Location: ' + location
-    ];
-
-    if (this.req.headers['sec-websocket-protocol']){
-      headers.push('Sec-WebSocket-Protocol: '
-          + this.req.headers['sec-websocket-protocol']);
-    }
-  } else {
-    var headers = [
-        'HTTP/1.1 101 Web Socket Protocol Handshake'
-      , 'Upgrade: WebSocket'
-      , 'Connection: Upgrade'
-      , 'WebSocket-Origin: ' + origin
-      , 'WebSocket-Location: ' + location
-    ];
-  }
-
-  try {
-    this.socket.write(headers.concat('', '').join('\r\n'));
-    this.socket.setTimeout(0);
-    this.socket.setNoDelay(true);
-    this.socket.setEncoding('utf8');
-  } catch (e) {
-    this.end();
-    return;
-  }
-
-  if (waitingForNonce) {
-    this.socket.setEncoding('binary');
-  } else if (this.proveReception(headers)) {
-    self.flush();
-  }
-
-  var headBuffer = '';
-
-  this.socket.on('data', function (data) {
-    if (waitingForNonce) {
-      headBuffer += data;
-
-      if (headBuffer.length < 8) {
-        return;
-      }
-
-      // Restore the connection to utf8 encoding after receiving the nonce
-      self.socket.setEncoding('utf8');
-      waitingForNonce = false;
-
-      // Stuff the nonce into the location where it's expected to be
-      self.req.head = headBuffer.substr(0, 8);
-      headBuffer = '';
-
-      if (self.proveReception(headers)) {
-        self.flush();
-      }
-
-      return;
-    }
-
-    self.parser.add(data);
-  });
-};
-
-/**
- * Writes to the socket.
- *
- * @api private
- */
-
-WebSocket.prototype.write = function (data) {
-  if (this.open) {
-    this.drained = false;
-
-    if (this.buffer) {
-      this.buffered.push(data);
-      return this;
-    }
-
-    var length = Buffer.byteLength(data)
-      , buffer = new Buffer(2 + length);
-
-    buffer.write('\u0000', 'binary');
-    buffer.write(data, 1, 'utf8');
-    buffer.write('\uffff', 1 + length, 'binary');
-
-    try {
-      if (this.socket.write(buffer)) {
-        this.drained = true;
-      }
-    } catch (e) {
-      this.end();
-    }
-
-    this.log.debug(this.name + ' writing', data);
-  }
-};
-
-/**
- * Flushes the internal buffer
- *
- * @api private
- */
-
-WebSocket.prototype.flush = function () {
-  this.buffer = false;
-
-  for (var i = 0, l = this.buffered.length; i < l; i++) {
-    this.write(this.buffered.splice(0, 1)[0]);
-  }
-};
-
-/**
- * Finishes the handshake.
- *
- * @api private
- */
-
-WebSocket.prototype.proveReception = function (headers) {
-  var self = this
-    , k1 = this.req.headers['sec-websocket-key1']
-    , k2 = this.req.headers['sec-websocket-key2'];
-
-  if (k1 && k2){
-    var md5 = crypto.createHash('md5');
-
-    [k1, k2].forEach(function (k) {
-      var n = parseInt(k.replace(/[^\d]/g, ''))
-        , spaces = k.replace(/[^ ]/g, '').length;
-
-      if (spaces === 0 || n % spaces !== 0){
-        self.log.warn('Invalid ' + self.name + ' key: "' + k + '".');
-        self.end();
-        return false;
-      }
-
-      n /= spaces;
-
-      md5.update(String.fromCharCode(
-        n >> 24 & 0xFF,
-        n >> 16 & 0xFF,
-        n >> 8  & 0xFF,
-        n       & 0xFF));
-    });
-
-    md5.update(this.req.head.toString('binary'));
-
-    try {
-      this.socket.write(md5.digest('binary'), 'binary');
-    } catch (e) {
-      this.end();
-    }
-  }
-
-  return true;
-};
-
-/**
- * Writes a payload.
- *
- * @api private
- */
-
-WebSocket.prototype.payload = function (msgs) {
-  for (var i = 0, l = msgs.length; i < l; i++) {
-    this.write(msgs[i]);
-  }
-
-  return this;
-};
-
-/**
- * Closes the connection.
- *
- * @api private
- */
-
-WebSocket.prototype.doClose = function () {
-  this.socket.end();
-};
-
-/**
- * WebSocket parser
- *
- * @api public
- */
-
-function Parser () {
-  this.buffer = '';
-  this.i = 0;
-};
-
-/**
- * Inherits from EventEmitter.
- */
-
-Parser.prototype.__proto__ = EventEmitter.prototype;
-
-/**
- * Adds data to the buffer.
- *
- * @api public
- */
-
-Parser.prototype.add = function (data) {
-  this.buffer += data;
-  this.parse();
-};
-
-/**
- * Parses the buffer.
- *
- * @api private
- */
-
-Parser.prototype.parse = function () {
-  for (var i = this.i, chr, l = this.buffer.length; i < l; i++){
-    chr = this.buffer[i];
-
-    if (this.buffer.length == 2 && this.buffer[1] == '\u0000') {
-      this.emit('close');
-      this.buffer = '';
-      this.i = 0;
-      return;
-    }
-
-    if (i === 0){
-      if (chr != '\u0000')
-        this.error('Bad framing. Expected null byte as first frame');
-      else
-        continue;
-    }
-
-    if (chr == '\ufffd'){
-      this.emit('data', this.buffer.substr(1, i - 1));
-      this.buffer = this.buffer.substr(i + 1);
-      this.i = 0;
-      return this.parse();
-    }
-  }
-};
-
-/**
- * Handles an error
- *
- * @api private
- */
-
-Parser.prototype.error = function (reason) {
-  this.buffer = '';
-  this.i = 0;
-  this.emit('error', reason);
-  return this;
+  else transport = new protocolVersions['default'](mng, data, req);
+  if (typeof this.name !== 'undefined') transport.name = this.name;
+  return transport;
 };

lib/transports/websocket/default.js

@@ -0,0 +1,358 @@
+
+/*!
+ * socket.io-node
+ * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module requirements.
+ */
+
+var Transport = require('../../transport')
+  , EventEmitter = process.EventEmitter
+  , crypto = require('crypto')
+  , parser = require('../../parser');
+
+/**
+ * Export the constructor.
+ */
+
+exports = module.exports = WebSocket;
+
+/**
+ * HTTP interface constructor. Interface compatible with all transports that
+ * depend on request-response cycles.
+ *
+ * @api public
+ */
+
+function WebSocket (mng, data, req) {
+  // parser
+  var self = this;
+
+  this.parser = new Parser();
+  this.parser.on('data', function (packet) {
+    self.log.debug(self.name + ' received data packet', packet);
+    self.onMessage(parser.decodePacket(packet));
+  });
+  this.parser.on('close', function () {
+    self.end();
+  });
+  this.parser.on('error', function () {
+    self.end();
+  });
+
+  Transport.call(this, mng, data, req);
+};
+
+/**
+ * Inherits from Transport.
+ */
+
+WebSocket.prototype.__proto__ = Transport.prototype;
+
+/**
+ * Transport name
+ *
+ * @api public
+ */
+
+WebSocket.prototype.name = 'websocket';
+
+/**
+ * Websocket draft version
+ *
+ * @api public
+ */
+
+WebSocket.prototype.protocolVersion = 'hixie-76';
+
+/**
+ * Called when the socket connects.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.onSocketConnect = function () {
+  var self = this;
+
+  this.socket.setNoDelay(true);
+
+  this.buffer = true;
+  this.buffered = [];
+
+  if (this.req.headers.upgrade !== 'WebSocket') {
+    this.log.warn(this.name + ' connection invalid');
+    this.end();
+    return;
+  }
+
+  var origin = this.req.headers.origin
+    , location = (this.socket.encrypted ? 'wss' : 'ws')
+               + '://' + this.req.headers.host + this.req.url
+    , waitingForNonce = false;
+
+  if (this.req.headers['sec-websocket-key1']) {
+    // If we don't have the nonce yet, wait for it (HAProxy compatibility).
+    if (! (this.req.head && this.req.head.length >= 8)) {
+      waitingForNonce = true;
+    }
+
+    var headers = [
+        'HTTP/1.1 101 WebSocket Protocol Handshake'
+      , 'Upgrade: WebSocket'
+      , 'Connection: Upgrade'
+      , 'Sec-WebSocket-Origin: ' + origin
+      , 'Sec-WebSocket-Location: ' + location
+    ];
+
+    if (this.req.headers['sec-websocket-protocol']){
+      headers.push('Sec-WebSocket-Protocol: '
+          + this.req.headers['sec-websocket-protocol']);
+    }
+  } else {
+    var headers = [
+        'HTTP/1.1 101 Web Socket Protocol Handshake'
+      , 'Upgrade: WebSocket'
+      , 'Connection: Upgrade'
+      , 'WebSocket-Origin: ' + origin
+      , 'WebSocket-Location: ' + location
+    ];
+  }
+
+  try {
+    this.socket.write(headers.concat('', '').join('\r\n'));
+    this.socket.setTimeout(0);
+    this.socket.setNoDelay(true);
+    this.socket.setEncoding('utf8');
+  } catch (e) {
+    this.end();
+    return;
+  }
+
+  if (waitingForNonce) {
+    this.socket.setEncoding('binary');
+  } else if (this.proveReception(headers)) {
+    self.flush();
+  }
+
+  var headBuffer = '';
+
+  this.socket.on('data', function (data) {
+    if (waitingForNonce) {
+      headBuffer += data;
+
+      if (headBuffer.length < 8) {
+        return;
+      }
+
+      // Restore the connection to utf8 encoding after receiving the nonce
+      self.socket.setEncoding('utf8');
+      waitingForNonce = false;
+
+      // Stuff the nonce into the location where it's expected to be
+      self.req.head = headBuffer.substr(0, 8);
+      headBuffer = '';
+
+      if (self.proveReception(headers)) {
+        self.flush();
+      }
+
+      return;
+    }
+
+    self.parser.add(data);
+  });
+};
+
+/**
+ * Writes to the socket.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.write = function (data) {
+  if (this.open) {
+    this.drained = false;
+
+    if (this.buffer) {
+      this.buffered.push(data);
+      return this;
+    }
+
+    var length = Buffer.byteLength(data)
+      , buffer = new Buffer(2 + length);
+
+    buffer.write('\x00', 'binary');
+    buffer.write(data, 1, 'utf8');
+    buffer.write('\xff', 1 + length, 'binary');
+
+    try {
+      if (this.socket.write(buffer)) {
+        this.drained = true;
+      }
+    } catch (e) {
+      this.end();
+    }
+
+    this.log.debug(this.name + ' writing', data);
+  }
+};
+
+/**
+ * Flushes the internal buffer
+ *
+ * @api private
+ */
+
+WebSocket.prototype.flush = function () {
+  this.buffer = false;
+
+  for (var i = 0, l = this.buffered.length; i < l; i++) {
+    this.write(this.buffered.splice(0, 1)[0]);
+  }
+};
+
+/**
+ * Finishes the handshake.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.proveReception = function (headers) {
+  var self = this
+    , k1 = this.req.headers['sec-websocket-key1']
+    , k2 = this.req.headers['sec-websocket-key2'];
+
+  if (k1 && k2){
+    var md5 = crypto.createHash('md5');
+
+    [k1, k2].forEach(function (k) {
+      var n = parseInt(k.replace(/[^\d]/g, ''))
+        , spaces = k.replace(/[^ ]/g, '').length;
+
+      if (spaces === 0 || n % spaces !== 0){
+        self.log.warn('Invalid ' + self.name + ' key: "' + k + '".');
+        self.end();
+        return false;
+      }
+
+      n /= spaces;
+
+      md5.update(String.fromCharCode(
+        n >> 24 & 0xFF,
+        n >> 16 & 0xFF,
+        n >> 8  & 0xFF,
+        n       & 0xFF));
+    });
+
+    md5.update(this.req.head.toString('binary'));
+
+    try {
+      this.socket.write(md5.digest('binary'), 'binary');
+    } catch (e) {
+      this.end();
+    }
+  }
+
+  return true;
+};
+
+/**
+ * Writes a payload.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.payload = function (msgs) {
+  for (var i = 0, l = msgs.length; i < l; i++) {
+    this.write(msgs[i]);
+  }
+
+  return this;
+};
+
+/**
+ * Closes the connection.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.doClose = function () {
+  this.socket.end();
+};
+
+/**
+ * WebSocket parser
+ *
+ * @api public
+ */
+
+function Parser () {
+  this.buffer = '';
+  this.i = 0;
+};
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+Parser.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Adds data to the buffer.
+ *
+ * @api public
+ */
+
+Parser.prototype.add = function (data) {
+  this.buffer += data;
+  this.parse();
+};
+
+/**
+ * Parses the buffer.
+ *
+ * @api private
+ */
+
+Parser.prototype.parse = function () {
+  for (var i = this.i, chr, l = this.buffer.length; i < l; i++){
+    chr = this.buffer[i];
+
+    if (this.buffer.length == 2 && this.buffer[1] == '\u0000') {
+      this.emit('close');
+      this.buffer = '';
+      this.i = 0;
+      return;
+    }
+
+    if (i === 0){
+      if (chr != '\u0000')
+        this.error('Bad framing. Expected null byte as first frame');
+      else
+        continue;
+    }
+
+    if (chr == '\ufffd'){
+      this.emit('data', this.buffer.substr(1, i - 1));
+      this.buffer = this.buffer.substr(i + 1);
+      this.i = 0;
+      return this.parse();
+    }
+  }
+};
+
+/**
+ * Handles an error
+ *
+ * @api private
+ */
+
+Parser.prototype.error = function (reason) {
+  this.buffer = '';
+  this.i = 0;
+  this.emit('error', reason);
+  return this;
+};

lib/transports/websocket/hybi-07-12.js

@@ -0,0 +1,604 @@
+
+/*!
+ * socket.io-node
+ * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+ 
+/**
+ * Module requirements.
+ */
+
+var Transport = require('../../transport')
+  , EventEmitter = process.EventEmitter
+  , crypto = require('crypto')
+  , url = require('url')
+  , parser = require('../../parser')
+  , util = require('../../util');
+
+/**
+ * Export the constructor.
+ */
+
+exports = module.exports = WebSocket;
+exports.Parser = Parser;
+
+/**
+ * HTTP interface constructor. Interface compatible with all transports that
+ * depend on request-response cycles.
+ *
+ * @api public
+ */
+
+function WebSocket (mng, data, req) {
+  // parser
+  var self = this;
+
+  this.manager = mng;
+  this.parser = new Parser();
+  this.parser.on('data', function (packet) {
+    self.onMessage(parser.decodePacket(packet));
+  });
+  this.parser.on('ping', function () {
+    // version 8 ping => pong
+    self.socket.write('\u008a\u0000');
+  });
+  this.parser.on('close', function () {
+    self.end();
+  });
+  this.parser.on('error', function (reason) {
+    self.log.warn(self.name + ' parser error: ' + reason);
+    self.end();
+  });
+
+  Transport.call(this, mng, data, req);
+};
+
+/**
+ * Inherits from Transport.
+ */
+
+WebSocket.prototype.__proto__ = Transport.prototype;
+
+/**
+ * Transport name
+ *
+ * @api public
+ */
+
+WebSocket.prototype.name = 'websocket';
+
+/**
+ * Websocket draft version
+ *
+ * @api public
+ */
+
+WebSocket.prototype.protocolVersion = '07-12';
+
+/**
+ * Called when the socket connects.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.onSocketConnect = function () {
+  var self = this;
+
+  if (this.req.headers.upgrade !== 'websocket') {
+    this.log.warn(this.name + ' connection invalid');
+    this.end();
+    return;
+  }
+
+  var origin = this.req.headers['sec-websocket-origin']
+    , location = (this.socket.encrypted ? 'wss' : 'ws')
+               + '://' + this.req.headers.host + this.req.url;
+  
+  if (!this.verifyOrigin(origin)) {
+    this.log.warn(this.name + ' connection invalid: origin mismatch');
+    this.end();
+    return;    
+  }
+  
+  if (!this.req.headers['sec-websocket-key']) {
+    this.log.warn(this.name + ' connection invalid: received no key');
+    this.end();
+    return;
+  }
+    
+  // calc key
+  var key = this.req.headers['sec-websocket-key'];  
+  var shasum = crypto.createHash('sha1');  
+  shasum.update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");  
+  key = shasum.digest('base64');
+
+  var headers = [
+      'HTTP/1.1 101 Switching Protocols'
+    , 'Upgrade: websocket'
+    , 'Connection: Upgrade'
+    , 'Sec-WebSocket-Accept: ' + key
+  ];
+
+  try {
+    this.socket.write(headers.concat('', '').join('\r\n'));
+    this.socket.setTimeout(0);
+    this.socket.setNoDelay(true);
+  } catch (e) {
+    this.end();
+    return;
+  }
+
+  this.socket.on('data', function (data) {
+    self.parser.add(data);
+  });
+};
+
+/**
+ * Verifies the origin of a request.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.verifyOrigin = function (origin) {
+  var origins = this.manager.get('origins');
+
+  if (origin === 'null') origin = '*';
+
+  if (origins.indexOf('*:*') !== -1) {
+    return true;
+  }
+
+  if (origin) {
+    try {
+      var parts = url.parse(origin);
+      var ok =
+        ~origins.indexOf(parts.hostname + ':' + parts.port) ||
+        ~origins.indexOf(parts.hostname + ':*') ||
+        ~origins.indexOf('*:' + parts.port);
+      if (!ok) this.log.warn('illegal origin: ' + origin);
+      return ok;
+    } catch (ex) {
+      this.log.warn('error parsing origin');
+    }
+  }
+  else {
+    this.log.warn('origin missing from websocket call, yet required by config');        
+  }
+  return false;
+};
+
+/**
+ * Writes to the socket.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.write = function (data) {
+  if (this.open) {
+    var buf = this.frame(0x81, data);
+    this.socket.write(buf, 'binary');
+    this.log.debug(this.name + ' writing', data);
+  }
+};
+
+/**
+ * Writes a payload.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.payload = function (msgs) {
+  for (var i = 0, l = msgs.length; i < l; i++) {
+    this.write(msgs[i]);
+  }
+
+  return this;
+};
+
+/**
+ * Frame server-to-client output as a text packet.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.frame = function (opcode, str) {
+  var dataBuffer = new Buffer(str)
+    , dataLength = dataBuffer.length
+    , startOffset = 2
+    , secondByte = dataLength;
+  if (dataLength > 65536) {
+    startOffset = 10;
+    secondByte = 127;
+  }
+  else if (dataLength > 125) {
+    startOffset = 4;
+    secondByte = 126;
+  }
+  var outputBuffer = new Buffer(dataLength + startOffset);
+  outputBuffer[0] = opcode;
+  outputBuffer[1] = secondByte;
+  dataBuffer.copy(outputBuffer, startOffset);
+  switch (secondByte) {
+  case 126:
+    outputBuffer[2] = dataLength >>> 8;
+    outputBuffer[3] = dataLength % 256;
+    break;
+  case 127:
+    var l = dataLength;
+    for (var i = 1; i <= 8; ++i) {
+      outputBuffer[startOffset - i] = l & 0xff;
+      l >>>= 8;
+    }
+  }
+  return outputBuffer;
+};
+
+/**
+ * Closes the connection.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.doClose = function () {
+  this.socket.end();
+};
+
+/**
+ * WebSocket parser
+ *
+ * @api public
+ */
+ 
+function Parser () {
+  this.state = {
+    activeFragmentedOperation: null,
+    lastFragment: false,
+    masked: false,
+    opcode: 0
+  };
+  this.overflow = null;
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.currentMessage = '';
+
+  var self = this;  
+  this.opcodeHandlers = {
+    // text
+    '1': function(data) {
+      var finish = function(mask, data) {
+        self.currentMessage += self.unmask(mask, data);
+        if (self.state.lastFragment) {
+          self.emit('data', self.currentMessage);
+          self.currentMessage = '';
+        }
+        self.endPacket();
+      }
+
+      var expectData = function(length) {
+        if (self.state.masked) {
+          self.expect('Mask', 4, function(data) {
+            var mask = data;
+            self.expect('Data', length, function(data) {
+              finish(mask, data);
+            });
+          });
+        }
+        else {
+          self.expect('Data', length, function(data) { 
+            finish(null, data);
+          });
+        } 
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        expectData(firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expect('Length', 2, function(data) {
+          expectData(util.unpack(data));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expect('Length', 8, function(data) {
+          if (util.unpack(data.slice(0, 4)) != 0) {
+            self.error('packets with length spanning more than 32 bit is currently not supported');
+            return;
+          }
+          var lengthBytes = data.slice(4); // note: cap to 32 bit length
+          expectData(util.unpack(data));
+        });
+      }      
+    },
+    // binary
+    '2': function(data) {
+      var finish = function(mask, data) {
+        if (typeof self.currentMessage == 'string') self.currentMessage = []; // build a buffer list
+        self.currentMessage.push(self.unmask(mask, data, true));
+        if (self.state.lastFragment) {
+          self.emit('binary', self.concatBuffers(self.currentMessage));
+          self.currentMessage = '';
+        }
+        self.endPacket();
+      }
+
+      var expectData = function(length) {
+        if (self.state.masked) {
+          self.expect('Mask', 4, function(data) {
+            var mask = data;
+            self.expect('Data', length, function(data) {
+              finish(mask, data);
+            });
+          });
+        }
+        else {
+          self.expect('Data', length, function(data) { 
+            finish(null, data);
+          });
+        } 
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        expectData(firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expect('Length', 2, function(data) {
+          expectData(util.unpack(data));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expect('Length', 8, function(data) {
+          if (util.unpack(data.slice(0, 4)) != 0) {
+            self.error('packets with length spanning more than 32 bit is currently not supported');
+            return;
+          }
+          var lengthBytes = data.slice(4); // note: cap to 32 bit length
+          expectData(util.unpack(data));
+        });
+      }      
+    },
+    // close
+    '8': function(data) {
+      self.emit('close');
+      self.reset();
+    },
+    // ping
+    '9': function(data) {
+      if (self.state.lastFragment == false) {
+        self.error('fragmented ping is not supported');
+        return;
+      }
+      
+      var finish = function(mask, data) {
+        self.emit('ping', self.unmask(mask, data));
+        self.endPacket();
+      }
+
+      var expectData = function(length) {
+        if (self.state.masked) {
+          self.expect('Mask', 4, function(data) {
+            var mask = data;
+            self.expect('Data', length, function(data) {
+              finish(mask, data);
+            });
+          });
+        }
+        else {
+          self.expect('Data', length, function(data) { 
+            finish(null, data);
+          });
+        } 
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength == 0) {
+        finish(null, null);        
+      }
+      else if (firstLength < 126) {
+        expectData(firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expect('Length', 2, function(data) {
+          expectData(util.unpack(data));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expect('Length', 8, function(data) {
+          expectData(util.unpack(data));
+        });
+      }      
+    }
+  }
+
+  this.expect('Opcode', 2, this.processPacket);  
+};
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+Parser.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Add new data to the parser.
+ *
+ * @api public
+ */
+
+Parser.prototype.add = function(data) {
+  if (this.expectBuffer == null) {
+    this.addToOverflow(data);
+    return;
+  }
+  var toRead = Math.min(data.length, this.expectBuffer.length - this.expectOffset);
+  data.copy(this.expectBuffer, this.expectOffset, 0, toRead);
+  this.expectOffset += toRead;
+  if (toRead < data.length) {
+    // at this point the overflow buffer shouldn't at all exist
+    this.overflow = new Buffer(data.length - toRead);
+    data.copy(this.overflow, 0, toRead, toRead + this.overflow.length);
+  }
+  if (this.expectOffset == this.expectBuffer.length) {
+    var bufferForHandler = this.expectBuffer;
+    this.expectBuffer = null;
+    this.expectOffset = 0;
+    this.expectHandler.call(this, bufferForHandler);
+  }
+}
+
+/**
+ * Adds a piece of data to the overflow.
+ *
+ * @api private
+ */
+
+Parser.prototype.addToOverflow = function(data) {
+  if (this.overflow == null) this.overflow = data;
+  else {
+    var prevOverflow = this.overflow;
+    this.overflow = new Buffer(this.overflow.length + data.length);
+    prevOverflow.copy(this.overflow, 0);
+    data.copy(this.overflow, prevOverflow.length);
+  }  
+}
+
+/**
+ * Waits for a certain amount of bytes to be available, then fires a callback.
+ *
+ * @api private
+ */
+
+Parser.prototype.expect = function(what, length, handler) {
+  this.expectBuffer = new Buffer(length);
+  this.expectOffset = 0;
+  this.expectHandler = handler;
+  if (this.overflow != null) {
+    var toOverflow = this.overflow;
+    this.overflow = null;
+    this.add(toOverflow);
+  }
+}
+
+/**
+ * Start processing a new packet.
+ *
+ * @api private
+ */
+
+Parser.prototype.processPacket = function (data) {
+  if ((data[0] & 0x70) != 0) this.error('reserved fields must be empty');
+  this.state.lastFragment = (data[0] & 0x80) == 0x80; 
+  this.state.masked = (data[1] & 0x80) == 0x80;
+  var opcode = data[0] & 0xf;
+  if (opcode == 0) { 
+    // continuation frame
+    this.state.opcode = this.state.activeFragmentedOperation;
+    if (!(this.state.opcode == 1 || this.state.opcode == 2)) {
+      this.error('continuation frame cannot follow current opcode')
+      return;
+    }
+  }
+  else {    
+    this.state.opcode = opcode;
+    if (this.state.lastFragment === false) {
+        this.state.activeFragmentedOperation = opcode;
+    }
+  }
+  var handler = this.opcodeHandlers[this.state.opcode];
+  if (typeof handler == 'undefined') this.error('no handler for opcode ' + this.state.opcode);
+  else handler(data);
+}
+
+/**
+ * Endprocessing a packet.
+ *
+ * @api private
+ */
+
+Parser.prototype.endPacket = function() {
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  if (this.state.lastFragment && this.state.opcode == this.state.activeFragmentedOperation) {
+    // end current fragmented operation
+    this.state.activeFragmentedOperation = null;
+  }
+  this.state.lastFragment = false;
+  this.state.opcode = this.state.activeFragmentedOperation != null ? this.state.activeFragmentedOperation : 0;
+  this.state.masked = false;
+  this.expect('Opcode', 2, this.processPacket);  
+}
+
+/**
+ * Reset the parser state.
+ *
+ * @api private
+ */
+
+Parser.prototype.reset = function() {
+  this.state = {
+    activeFragmentedOperation: null,
+    lastFragment: false,
+    masked: false,
+    opcode: 0
+  };
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.overflow = null;
+  this.currentMessage = '';
+}
+
+/**
+ * Unmask received data.
+ *
+ * @api private
+ */
+
+Parser.prototype.unmask = function (mask, buf, binary) {
+  if (mask != null) {
+    for (var i = 0, ll = buf.length; i < ll; i++) {
+      buf[i] ^= mask[i % 4];
+    }    
+  }
+  if (binary) return buf;
+  return buf != null ? buf.toString('utf8') : '';
+}
+
+/**
+ * Concatenates a list of buffers.
+ *
+ * @api private
+ */
+
+Parser.prototype.concatBuffers = function(buffers) {
+  var length = 0;
+  for (var i = 0, l = buffers.length; i < l; ++i) {
+    length += buffers[i].length;
+  }
+  var mergedBuffer = new Buffer(length);
+  var offset = 0;
+  for (var i = 0, l = buffers.length; i < l; ++i) {
+    buffers[i].copy(mergedBuffer, offset);
+    offset += buffers[i].length;
+  }
+  return mergedBuffer;
+}
+
+/**
+ * Handles an error
+ *
+ * @api private
+ */
+
+Parser.prototype.error = function (reason) {
+  this.reset();
+  this.emit('error', reason);
+  return this;
+};

lib/transports/websocket/hybi-16.js

@@ -0,0 +1,604 @@
+
+/*!
+ * socket.io-node
+ * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+ 
+/**
+ * Module requirements.
+ */
+
+var Transport = require('../../transport')
+  , EventEmitter = process.EventEmitter
+  , crypto = require('crypto')
+  , url = require('url')
+  , parser = require('../../parser')
+  , util = require('../../util');
+
+/**
+ * Export the constructor.
+ */
+
+exports = module.exports = WebSocket;
+exports.Parser = Parser;
+
+/**
+ * HTTP interface constructor. Interface compatible with all transports that
+ * depend on request-response cycles.
+ *
+ * @api public
+ */
+
+function WebSocket (mng, data, req) {
+  // parser
+  var self = this;
+
+  this.manager = mng;
+  this.parser = new Parser();
+  this.parser.on('data', function (packet) {
+    self.onMessage(parser.decodePacket(packet));
+  });
+  this.parser.on('ping', function () {
+    // version 8 ping => pong
+    self.socket.write('\u008a\u0000');
+  });
+  this.parser.on('close', function () {
+    self.end();
+  });
+  this.parser.on('error', function (reason) {
+    self.log.warn(self.name + ' parser error: ' + reason);
+    self.end();
+  });
+
+  Transport.call(this, mng, data, req);
+};
+
+/**
+ * Inherits from Transport.
+ */
+
+WebSocket.prototype.__proto__ = Transport.prototype;
+
+/**
+ * Transport name
+ *
+ * @api public
+ */
+
+WebSocket.prototype.name = 'websocket';
+
+/**
+ * Websocket draft version
+ *
+ * @api public
+ */
+
+WebSocket.prototype.protocolVersion = '16';
+
+/**
+ * Called when the socket connects.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.onSocketConnect = function () {
+  var self = this;
+
+  if (this.req.headers.upgrade !== 'websocket') {
+    this.log.warn(this.name + ' connection invalid');
+    this.end();
+    return;
+  }
+
+  var origin = this.req.headers['origin']
+    , location = (this.socket.encrypted ? 'wss' : 'ws')
+               + '://' + this.req.headers.host + this.req.url;
+  
+  if (!this.verifyOrigin(origin)) {
+    this.log.warn(this.name + ' connection invalid: origin mismatch');
+    this.end();
+    return;    
+  }
+  
+  if (!this.req.headers['sec-websocket-key']) {
+    this.log.warn(this.name + ' connection invalid: received no key');
+    this.end();
+    return;
+  }
+    
+  // calc key
+  var key = this.req.headers['sec-websocket-key'];  
+  var shasum = crypto.createHash('sha1');  
+  shasum.update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11");  
+  key = shasum.digest('base64');
+
+  var headers = [
+      'HTTP/1.1 101 Switching Protocols'
+    , 'Upgrade: websocket'
+    , 'Connection: Upgrade'
+    , 'Sec-WebSocket-Accept: ' + key
+  ];
+
+  try {
+    this.socket.write(headers.concat('', '').join('\r\n'));
+    this.socket.setTimeout(0);
+    this.socket.setNoDelay(true);
+  } catch (e) {
+    this.end();
+    return;
+  }
+
+  this.socket.on('data', function (data) {
+    self.parser.add(data);
+  });
+};
+
+/**
+ * Verifies the origin of a request.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.verifyOrigin = function (origin) {
+  var origins = this.manager.get('origins');
+
+  if (origin === 'null') origin = '*';
+
+  if (origins.indexOf('*:*') !== -1) {
+    return true;
+  }
+
+  if (origin) {
+    try {
+      var parts = url.parse(origin);
+      var ok =
+        ~origins.indexOf(parts.hostname + ':' + parts.port) ||
+        ~origins.indexOf(parts.hostname + ':*') ||
+        ~origins.indexOf('*:' + parts.port);
+      if (!ok) this.log.warn('illegal origin: ' + origin);
+      return ok;
+    } catch (ex) {
+      this.log.warn('error parsing origin');
+    }
+  }
+  else {
+    this.log.warn('origin missing from websocket call, yet required by config');        
+  }
+  return false;
+};
+
+/**
+ * Writes to the socket.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.write = function (data) {
+  if (this.open) {
+    var buf = this.frame(0x81, data);
+    this.socket.write(buf, 'binary');
+    this.log.debug(this.name + ' writing', data);
+  }
+};
+
+/**
+ * Writes a payload.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.payload = function (msgs) {
+  for (var i = 0, l = msgs.length; i < l; i++) {
+    this.write(msgs[i]);
+  }
+
+  return this;
+};
+
+/**
+ * Frame server-to-client output as a text packet.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.frame = function (opcode, str) {
+  var dataBuffer = new Buffer(str)
+    , dataLength = dataBuffer.length
+    , startOffset = 2
+    , secondByte = dataLength;
+  if (dataLength > 65536) {
+    startOffset = 10;
+    secondByte = 127;
+  }
+  else if (dataLength > 125) {
+    startOffset = 4;
+    secondByte = 126;
+  }
+  var outputBuffer = new Buffer(dataLength + startOffset);
+  outputBuffer[0] = opcode;
+  outputBuffer[1] = secondByte;
+  dataBuffer.copy(outputBuffer, startOffset);
+  switch (secondByte) {
+  case 126:
+    outputBuffer[2] = dataLength >>> 8;
+    outputBuffer[3] = dataLength % 256;
+    break;
+  case 127:
+    var l = dataLength;
+    for (var i = 1; i <= 8; ++i) {
+      outputBuffer[startOffset - i] = l & 0xff;
+      l >>>= 8;
+    }
+  }
+  return outputBuffer;
+};
+
+/**
+ * Closes the connection.
+ *
+ * @api private
+ */
+
+WebSocket.prototype.doClose = function () {
+  this.socket.end();
+};
+
+/**
+ * WebSocket parser
+ *
+ * @api public
+ */
+ 
+function Parser () {
+  this.state = {
+    activeFragmentedOperation: null,
+    lastFragment: false,
+    masked: false,
+    opcode: 0
+  };
+  this.overflow = null;
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.currentMessage = '';
+
+  var self = this;  
+  this.opcodeHandlers = {
+    // text
+    '1': function(data) {
+      var finish = function(mask, data) {
+        self.currentMessage += self.unmask(mask, data);
+        if (self.state.lastFragment) {
+          self.emit('data', self.currentMessage);
+          self.currentMessage = '';
+        }
+        self.endPacket();
+      }
+
+      var expectData = function(length) {
+        if (self.state.masked) {
+          self.expect('Mask', 4, function(data) {
+            var mask = data;
+            self.expect('Data', length, function(data) {
+              finish(mask, data);
+            });
+          });
+        }
+        else {
+          self.expect('Data', length, function(data) { 
+            finish(null, data);
+          });
+        } 
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        expectData(firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expect('Length', 2, function(data) {
+          expectData(util.unpack(data));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expect('Length', 8, function(data) {
+          if (util.unpack(data.slice(0, 4)) != 0) {
+            self.error('packets with length spanning more than 32 bit is currently not supported');
+            return;
+          }
+          var lengthBytes = data.slice(4); // note: cap to 32 bit length
+          expectData(util.unpack(data));
+        });
+      }      
+    },
+    // binary
+    '2': function(data) {
+      var finish = function(mask, data) {
+        if (typeof self.currentMessage == 'string') self.currentMessage = []; // build a buffer list
+        self.currentMessage.push(self.unmask(mask, data, true));
+        if (self.state.lastFragment) {
+          self.emit('binary', self.concatBuffers(self.currentMessage));
+          self.currentMessage = '';
+        }
+        self.endPacket();
+      }
+
+      var expectData = function(length) {
+        if (self.state.masked) {
+          self.expect('Mask', 4, function(data) {
+            var mask = data;
+            self.expect('Data', length, function(data) {
+              finish(mask, data);
+            });
+          });
+        }
+        else {
+          self.expect('Data', length, function(data) { 
+            finish(null, data);
+          });
+        } 
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength < 126) {
+        expectData(firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expect('Length', 2, function(data) {
+          expectData(util.unpack(data));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expect('Length', 8, function(data) {
+          if (util.unpack(data.slice(0, 4)) != 0) {
+            self.error('packets with length spanning more than 32 bit is currently not supported');
+            return;
+          }
+          var lengthBytes = data.slice(4); // note: cap to 32 bit length
+          expectData(util.unpack(data));
+        });
+      }      
+    },
+    // close
+    '8': function(data) {
+      self.emit('close');
+      self.reset();
+    },
+    // ping
+    '9': function(data) {
+      if (self.state.lastFragment == false) {
+        self.error('fragmented ping is not supported');
+        return;
+      }
+      
+      var finish = function(mask, data) {
+        self.emit('ping', self.unmask(mask, data));
+        self.endPacket();
+      }
+
+      var expectData = function(length) {
+        if (self.state.masked) {
+          self.expect('Mask', 4, function(data) {
+            var mask = data;
+            self.expect('Data', length, function(data) {
+              finish(mask, data);
+            });
+          });
+        }
+        else {
+          self.expect('Data', length, function(data) { 
+            finish(null, data);
+          });
+        } 
+      }
+
+      // decode length
+      var firstLength = data[1] & 0x7f;
+      if (firstLength == 0) {
+        finish(null, null);        
+      }
+      else if (firstLength < 126) {
+        expectData(firstLength);
+      }
+      else if (firstLength == 126) {
+        self.expect('Length', 2, function(data) {
+          expectData(util.unpack(data));
+        });
+      }
+      else if (firstLength == 127) {
+        self.expect('Length', 8, function(data) {
+          expectData(util.unpack(data));
+        });
+      }      
+    }
+  }
+
+  this.expect('Opcode', 2, this.processPacket);  
+};
+
+/**
+ * Inherits from EventEmitter.
+ */
+
+Parser.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Add new data to the parser.
+ *
+ * @api public
+ */
+
+Parser.prototype.add = function(data) {
+  if (this.expectBuffer == null) {
+    this.addToOverflow(data);
+    return;
+  }
+  var toRead = Math.min(data.length, this.expectBuffer.length - this.expectOffset);
+  data.copy(this.expectBuffer, this.expectOffset, 0, toRead);
+  this.expectOffset += toRead;
+  if (toRead < data.length) {
+    // at this point the overflow buffer shouldn't at all exist
+    this.overflow = new Buffer(data.length - toRead);
+    data.copy(this.overflow, 0, toRead, toRead + this.overflow.length);
+  }
+  if (this.expectOffset == this.expectBuffer.length) {
+    var bufferForHandler = this.expectBuffer;
+    this.expectBuffer = null;
+    this.expectOffset = 0;
+    this.expectHandler.call(this, bufferForHandler);
+  }
+}
+
+/**
+ * Adds a piece of data to the overflow.
+ *
+ * @api private
+ */
+
+Parser.prototype.addToOverflow = function(data) {
+  if (this.overflow == null) this.overflow = data;
+  else {
+    var prevOverflow = this.overflow;
+    this.overflow = new Buffer(this.overflow.length + data.length);
+    prevOverflow.copy(this.overflow, 0);
+    data.copy(this.overflow, prevOverflow.length);
+  }  
+}
+
+/**
+ * Waits for a certain amount of bytes to be available, then fires a callback.
+ *
+ * @api private
+ */
+
+Parser.prototype.expect = function(what, length, handler) {
+  this.expectBuffer = new Buffer(length);
+  this.expectOffset = 0;
+  this.expectHandler = handler;
+  if (this.overflow != null) {
+    var toOverflow = this.overflow;
+    this.overflow = null;
+    this.add(toOverflow);
+  }
+}
+
+/**
+ * Start processing a new packet.
+ *
+ * @api private
+ */
+
+Parser.prototype.processPacket = function (data) {
+  if ((data[0] & 0x70) != 0) this.error('reserved fields must be empty');
+  this.state.lastFragment = (data[0] & 0x80) == 0x80; 
+  this.state.masked = (data[1] & 0x80) == 0x80;
+  var opcode = data[0] & 0xf;
+  if (opcode == 0) { 
+    // continuation frame
+    this.state.opcode = this.state.activeFragmentedOperation;
+    if (!(this.state.opcode == 1 || this.state.opcode == 2)) {
+      this.error('continuation frame cannot follow current opcode')
+      return;
+    }
+  }
+  else {    
+    this.state.opcode = opcode;
+    if (this.state.lastFragment === false) {
+        this.state.activeFragmentedOperation = opcode;
+    }
+  }
+  var handler = this.opcodeHandlers[this.state.opcode];
+  if (typeof handler == 'undefined') this.error('no handler for opcode ' + this.state.opcode);
+  else handler(data);
+}
+
+/**
+ * Endprocessing a packet.
+ *
+ * @api private
+ */
+
+Parser.prototype.endPacket = function() {
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  if (this.state.lastFragment && this.state.opcode == this.state.activeFragmentedOperation) {
+    // end current fragmented operation
+    this.state.activeFragmentedOperation = null;
+  }
+  this.state.lastFragment = false;
+  this.state.opcode = this.state.activeFragmentedOperation != null ? this.state.activeFragmentedOperation : 0;
+  this.state.masked = false;
+  this.expect('Opcode', 2, this.processPacket);  
+}
+
+/**
+ * Reset the parser state.
+ *
+ * @api private
+ */
+
+Parser.prototype.reset = function() {
+  this.state = {
+    activeFragmentedOperation: null,
+    lastFragment: false,
+    masked: false,
+    opcode: 0
+  };
+  this.expectOffset = 0;
+  this.expectBuffer = null;
+  this.expectHandler = null;
+  this.overflow = null;
+  this.currentMessage = '';
+}
+
+/**
+ * Unmask received data.
+ *
+ * @api private
+ */
+
+Parser.prototype.unmask = function (mask, buf, binary) {
+  if (mask != null) {
+    for (var i = 0, ll = buf.length; i < ll; i++) {
+      buf[i] ^= mask[i % 4];
+    }    
+  }
+  if (binary) return buf;
+  return buf != null ? buf.toString('utf8') : '';
+}
+
+/**
+ * Concatenates a list of buffers.
+ *
+ * @api private
+ */
+
+Parser.prototype.concatBuffers = function(buffers) {
+  var length = 0;
+  for (var i = 0, l = buffers.length; i < l; ++i) {
+    length += buffers[i].length;
+  }
+  var mergedBuffer = new Buffer(length);
+  var offset = 0;
+  for (var i = 0, l = buffers.length; i < l; ++i) {
+    buffers[i].copy(mergedBuffer, offset);
+    offset += buffers[i].length;
+  }
+  return mergedBuffer;
+}
+
+/**
+ * Handles an error
+ *
+ * @api private
+ */
+
+Parser.prototype.error = function (reason) {
+  this.reset();
+  this.emit('error', reason);
+  return this;
+};

lib/transports/websocket/index.js

@@ -0,0 +1,11 @@
+
+/**
+ * Export websocket versions.
+ */
+
+module.exports = {
+  7: require('./hybi-07-12'),
+  8: require('./hybi-07-12'),
+  13: require('./hybi-16'),
+  default: require('./default')
+};

lib/util.js

@@ -23,3 +23,28 @@ exports.toArray = function (enu) {
 
   return arr;
 };
+
+/**
+ * Unpacks a buffer to a number.
+ *
+ * @api public
+ */
+
+exports.unpack = function (buffer) {
+  var n = 0;
+  for (var i = 0; i < buffer.length; ++i) {
+    n = (i == 0) ? buffer[i] : (n * 256) + buffer[i];
+  }
+  return n;
+}
+
+/**
+ * Left pads a string.
+ *
+ * @api public
+ */
+
+exports.padl = function (s,n,c) { 
+  return new Array(1 + n - s.length).join(c) + s;
+}
+

package.json

@@ -1,6 +1,6 @@
 {
     "name": "socket.io"
-  , "version": "0.7.11"
+  , "version": "0.8.5"
   , "description": "Real-time apps made cross-browser & easy with a WebSocket-like API"
   , "homepage": "http://socket.io"
   , "keywords": ["websocket", "socket", "realtime", "socket.io", "comet", "ajax"]
@@ -9,13 +9,14 @@
         { "name": "Guillermo Rauch", "email": "rauchg@gmail.com" }
       , { "name": "Arnout Kazemier", "email": "info@3rd-eden.com" }
       , { "name": "Vladimir Dronnikov", "email": "dronnikov@gmail.com" }
+      , { "name": "Einar Otto Stangvik", "email": "einaros@gmail.com" }
     ]
   , "repository":{
         "type": "git"
-      , "url": "https://github.com/LearnBoost/Socket.IO-node.git"
+      , "url": "https://github.com/LearnBoost/socket.io.git"
     }
   , "dependencies": {
-        "socket.io-client": "0.7.11"
+        "socket.io-client": "0.8.5"
       , "policyfile": "0.0.4"
       , "redis": "0.6.6"
     }

test/common.js

@@ -191,14 +191,14 @@ create = function (cl) {
  * @api private
  */
 
-function WSClient (port, sid) {
+function WSClient (port, sid, transport) {
   this.sid = sid;
   this.port = port;
-
+  this.transportName = transport || 'websocket';
   WebSocket.call(
       this
     , 'ws://localhost:' + port + '/socket.io/' 
-        + io.protocol + '/websocket/' + sid
+        + io.protocol + '/' + this.transportName + '/' + sid
   );
 };
 
@@ -239,6 +239,6 @@ WSClient.prototype.packet = function (pack) {
  * @api public
  */
 
-websocket = function (cl, sid) {
-  return new WSClient(cl.port, sid);
+websocket = function (cl, sid, transport) {
+  return new WSClient(cl.port, sid, transport);
 };

test/hybi-common.js

@@ -0,0 +1,99 @@
+/**
+ * Returns a Buffer from a "ff 00 ff"-type hex string.
+ */
+
+getBufferFromHexString = function(byteStr) {
+  var bytes = byteStr.split(' ');
+  var buf = new Buffer(bytes.length);
+  for (var i = 0; i < bytes.length; ++i) {
+    buf[i] = parseInt(bytes[i], 16);
+  }
+  return buf;
+}
+
+/**
+ * Returns a hex string from a Buffer.
+ */
+
+getHexStringFromBuffer = function(data) {
+  var s = '';
+  for (var i = 0; i < data.length; ++i) {
+    s += padl(data[i].toString(16), 2, '0') + ' ';
+  }
+  return s.trim();
+}
+
+/**
+ * Splits a buffer in two parts.
+ */
+
+splitBuffer = function(buffer) {
+  var b1 = new Buffer(Math.ceil(buffer.length / 2));
+  buffer.copy(b1, 0, 0, b1.length);
+  var b2 = new Buffer(Math.floor(buffer.length / 2));
+  buffer.copy(b2, 0, b1.length, b1.length + b2.length);
+  return [b1, b2];
+}
+
+/**
+ * Performs hybi07+ type masking on a hex string or buffer.
+ */
+
+mask = function(buf, maskString) {
+  if (typeof buf == 'string') buf = new Buffer(buf);
+  var mask = getBufferFromHexString(maskString || '34 83 a8 68');
+  for (var i = 0; i < buf.length; ++i) {
+    buf[i] ^= mask[i % 4];    
+  }
+  return buf;
+}
+
+/**
+ * Returns a hex string representing the length of a message
+ */
+ 
+getHybiLengthAsHexString = function(len, masked) {  
+  if (len < 126) {
+    var buf = new Buffer(1);
+    buf[0] = (masked ? 0x80 : 0) | len;
+  }
+  else if (len < 65536) {
+    var buf = new Buffer(3);
+    buf[0] = (masked ? 0x80 : 0) | 126;
+    getBufferFromHexString(pack(4, len)).copy(buf, 1);
+  }
+  else {
+    var buf = new Buffer(9);
+    buf[0] = (masked ? 0x80 : 0) | 127;
+    getBufferFromHexString(pack(16, len)).copy(buf, 1);
+  }
+  return getHexStringFromBuffer(buf);
+}
+
+/**
+ * Unpacks a Buffer into a number.
+ */
+
+unpack = function(buffer) {
+  var n = 0;
+  for (var i = 0; i < buffer.length; ++i) {
+    n = (i == 0) ? buffer[i] : (n * 256) + buffer[i];
+  }
+  return n;
+}
+
+/**
+ * Returns a hex string, representing a specific byte count 'length', from a number.
+ */
+
+pack = function(length, number) {
+  return padl(number.toString(16), length, '0').replace(/(\d\d)/g, '$1 ').trim();
+}
+
+/**
+ * Left pads the string 's' to a total length of 'n' with char 'c'.
+ */
+
+padl = function(s, n, c) { 
+  return new Array(1 + n - s.length).join(c) + s;
+}

test/manager.test.js

@@ -147,236 +147,6 @@ module.exports = {
     });
   },
 
-  'test that the client is served': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      res.headers['content-type'].should.eql('application/javascript');
-      res.headers['content-length'].should.match(/([0-9]+)/);
-      should.strictEqual(res.headers.etag, undefined);
-
-      data.should.match(/XMLHttpRequest/);
-
-      cl.end();
-      io.server.close();
-      done();
-    });
-  },
-
-  'test that the client etag is served': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    io.configure(function () {
-      io.enable('browser client etag');
-    });
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      res.headers['content-type'].should.eql('application/javascript');
-      res.headers['content-length'].should.match(/([0-9]+)/);
-      res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
-
-      data.should.match(/XMLHttpRequest/);
-
-      cl.end();
-      io.server.close();
-      done();
-    });
-  },
-
-  'test that the cached client is served': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      res.headers['content-type'].should.eql('application/javascript');
-      res.headers['content-length'].should.match(/([0-9]+)/);
-      should.strictEqual(res.headers.etag, undefined);
-
-      data.should.match(/XMLHttpRequest/);
-      var static = sio.Manager.static;
-      static.cache['/socket.io.js'].content.should.match(/XMLHttpRequest/);
-
-      cl.get('/socket.io/socket.io.js', function (res, data) {
-        res.headers['content-type'].should.eql('application/javascript');
-        res.headers['content-length'].should.match(/([0-9]+)/);
-        should.strictEqual(res.headers.etag, undefined);
-
-        data.should.match(/XMLHttpRequest/);
-
-        cl.end();
-        io.server.close();
-        done();
-      });
-    });
-  },
-
-  'test that the cached client etag is served': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    io.configure(function () {
-      io.enable('browser client etag');
-    });
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      res.headers['content-type'].should.eql('application/javascript');
-      res.headers['content-length'].should.match(/([0-9]+)/);
-      res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
-
-      data.should.match(/XMLHttpRequest/);
-      var static = sio.Manager.static
-        , cache = static.cache['/socket.io.js'];
-
-      cache.content.toString().should.match(/XMLHttpRequest/);
-      Buffer.isBuffer(cache.content).should.be.true;
-
-      cl.get('/socket.io/socket.io.js', function (res, data) {
-        res.headers['content-type'].should.eql('application/javascript');
-        res.headers['content-length'].should.match(/([0-9]+)/);
-        res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
-
-        data.should.match(/XMLHttpRequest/);
-
-        cl.end();
-        io.server.close();
-        done();
-      });
-    });
-  },
-
-  'test that the cached client sends a 304 header': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-     io.configure(function () {
-      io.enable('browser client etag');
-    });
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      cl.get('/socket.io/socket.io.js', {headers:{'if-none-match':res.headers.etag}}, function (res, data) {
-        res.statusCode.should.eql(304);
-
-        cl.end();
-        io.server.close();
-        done();
-      });
-    });
-  },
-
-  'test that client minification works': function (done) {
-    // server 1
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    // server 2
-    var port = ++ports
-      , io2 = sio.listen(port)
-      , cl2 = client(port);
-
-    io.configure(function () {
-      io.enable('browser client minification');
-    });
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      var length = data.length;
-
-      cl.end();
-      io.server.close();
-
-      cl2.get('/socket.io/socket.io.js', function (res, data) {
-        res.headers['content-type'].should.eql('application/javascript');
-        res.headers['content-length'].should.match(/([0-9]+)/);
-        should.strictEqual(res.headers.etag, undefined);
-
-        data.should.match(/XMLHttpRequest/);
-        data.length.should.be.greaterThan(length);
-
-        cl2.end();
-        io2.server.close();
-        done();
-      });
-    });
-  },
-
-  'test that the WebSocketMain.swf is served': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    cl.get('/socket.io/static/flashsocket/WebSocketMain.swf', function (res, data) {
-      res.headers['content-type'].should.eql('application/x-shockwave-flash');
-      res.headers['content-length'].should.match(/([0-9]+)/);
-      should.strictEqual(res.headers.etag, undefined);
-
-      var static = sio.Manager.static
-        , cache = static.cache['/static/flashsocket/WebSocketMain.swf'];
-
-      Buffer.isBuffer(cache.content).should.be.true;
-
-      cl.end();
-      io.server.close();
-      done();
-    });
-  },
-
-  'test that the WebSocketMainInsecure.swf is served': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    cl.get('/socket.io/static/flashsocket/WebSocketMainInsecure.swf', function (res, data) {
-      res.headers['content-type'].should.eql('application/x-shockwave-flash');
-      res.headers['content-length'].should.match(/([0-9]+)/);
-      should.strictEqual(res.headers.etag, undefined);
-
-      var static = sio.Manager.static
-        , cache = static.cache['/static/flashsocket/WebSocketMain.swf'];
-
-      Buffer.isBuffer(cache.content).should.be.true;
-
-      cl.end();
-      io.server.close();
-      done();
-    });
-  },
-
-  'test that you can serve custom clients': function (done) {
-    var port = ++ports
-      , io = sio.listen(port)
-      , cl = client(port);
-
-    io.configure(function () {
-      io.set('browser client handler', function (req, res) {
-        res.writeHead(200, {
-            'Content-Type': 'application/javascript'
-          , 'Content-Length': 13
-          , 'ETag': '1.0'
-        });
-        res.end('custom_client');
-      });
-    });
-
-    cl.get('/socket.io/socket.io.js', function (res, data) {
-      res.headers['content-type'].should.eql('application/javascript');
-      res.headers['content-length'].should.eql(13);
-      res.headers.etag.should.eql('1.0');
-
-      data.should.eql('custom_client');
-
-      cl.end();
-      io.server.close();
-      done();
-    });
-  },
-
   'test that you can disable clients': function (done) {
     var port = ++ports
       , io = sio.listen(port)
@@ -472,6 +242,111 @@ module.exports = {
     });
   },
 
+  'test that a referer is accepted for *:* origin': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.configure(function () {
+      io.set('origins', '*:*');
+    });
+
+    cl.get('/socket.io/{protocol}', { headers: { referer: 'http://foo.bar.com:82/something' } }, function (res, data) {
+      res.statusCode.should.eql(200);
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that valid referer is accepted for addr:* origin': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.configure(function () {
+      io.set('origins', 'foo.bar.com:*');
+    });
+
+    cl.get('/socket.io/{protocol}', { headers: { referer: 'http://foo.bar.com/something' } }, function (res, data) {
+      res.statusCode.should.eql(200);
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that erroneous referer is denied for addr:* origin': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.configure(function () {
+      io.set('origins', 'foo.bar.com:*');
+    });
+
+    cl.get('/socket.io/{protocol}', { headers: { referer: 'http://baz.bar.com/something' } }, function (res, data) {
+      res.statusCode.should.eql(403);
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that valid referer port is accepted for addr:port origin': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.configure(function () {
+      io.set('origins', 'foo.bar.com:81');
+    });
+
+    cl.get('/socket.io/{protocol}', { headers: { referer: 'http://foo.bar.com:81/something' } }, function (res, data) {
+      res.statusCode.should.eql(200);
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that erroneous referer port is denied for addr:port origin': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.configure(function () {
+      io.set('origins', 'foo.bar.com:81');
+    });
+
+    cl.get('/socket.io/{protocol}', { headers: { referer: 'http://foo.bar.com/something' } }, function (res, data) {
+      res.statusCode.should.eql(403);
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test handshake cross domain access control': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port)
+      , headers = {
+            Origin: 'http://example.org:1337'
+          , Cookie: 'name=value'
+        };
+
+    cl.get('/socket.io/{protocol}/', { headers:headers }, function (res, data) {
+      res.statusCode.should.eql(200);
+      res.headers['access-control-allow-origin'].should.eql('*');
+      res.headers['access-control-allow-credentials'].should.eql('true');
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
   'test limiting the supported transports for a manager': function (done) {
     var port = ++ports
       , io = sio.listen(port)

test/parser.test.js

@@ -343,6 +343,14 @@ module.exports = {
         parser.encodePacket({ type: 'message', data: '5', endpoint: '' })
       , parser.encodePacket({ type: 'message', data: '53d', endpoint: '' })
     ]).should.eql('\ufffd5\ufffd3:::5\ufffd7\ufffd3:::53d')
+  },
+
+  'test decoding newline': function () {
+    parser.decodePacket('3:::\n').should.eql({
+        type: 'message'
+      , endpoint: ''
+      , data: '\n'
+    });
   }
 
 };

test/static.test.js

@@ -0,0 +1,460 @@
+
+/*!
+* socket.io-node
+* Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+* MIT Licensed
+*/
+
+/**
+ * Test dependencies.
+ */
+
+var sio = require('socket.io')
+  , should = require('./common')
+  , ports = 15400;
+
+/**
+ * Test.
+ */
+
+module.exports = {
+
+  'test that the default static files are available': function (done) {
+    var port = ++ports
+      , io = sio.listen(port);
+
+    (!!io.static.has('/socket.io.js')).should.be.true;
+    (!!io.static.has('/socket.io+')).should.be.true;
+    (!!io.static.has('/static/flashsocket/WebSocketMain.swf')).should.be.true;
+    (!!io.static.has('/static/flashsocket/WebSocketMainInsecure.swf')).should.be.true;
+
+    io.server.close();
+    done();
+  },
+
+  'test that static files are correctly looked up': function (done) {
+    var port = ++ports
+      , io = sio.listen(port);
+
+    (!!io.static.has('/socket.io.js')).should.be.true;
+    (!!io.static.has('/invalidfilehereplease.js')).should.be.false;
+
+    io.server.close();
+    done();
+  },
+
+  'test that the client is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      should.strictEqual(res.headers.etag, undefined);
+
+      data.should.match(/XMLHttpRequest/);
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that the custom build client is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client etag');
+
+    cl.get('/socket.io/socket.io+websocket.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
+
+      data.should.match(/XMLHttpRequest/);
+      data.should.match(/WS\.prototype\.name/);
+      data.should.not.match(/Flashsocket\.prototype\.name/);
+      data.should.not.match(/HTMLFile\.prototype\.name/);
+      data.should.not.match(/JSONPPolling\.prototype\.name/);
+      data.should.not.match(/XHRPolling\.prototype\.name/);
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that the client is build with the enabled transports': function (done) {
+    var port = ++ports
+      , io = sio.listen(port) 
+      , cl = client(port);
+
+    io.set('transports', ['websocket']);
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+
+      data.should.match(/XMLHttpRequest/);
+      data.should.match(/WS\.prototype\.name/);
+      data.should.not.match(/Flashsocket\.prototype\.name/);
+      data.should.not.match(/HTMLFile\.prototype\.name/);
+      data.should.not.match(/JSONPPolling\.prototype\.name/);
+      data.should.not.match(/XHRPolling\.prototype\.name/);
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that the client cache is cleared when transports change': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.set('transports', ['websocket']);
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+
+      data.should.match(/XMLHttpRequest/);
+      data.should.match(/WS\.prototype\.name/);
+      data.should.not.match(/Flashsocket\.prototype\.name/);
+      data.should.not.match(/HTMLFile\.prototype\.name/);
+      data.should.not.match(/JSONPPolling\.prototype\.name/);
+      data.should.not.match(/XHRPolling\.prototype\.name/);
+
+      io.set('transports', ['xhr-polling']);
+      should.strictEqual(io.static.cache['/socket.io.js'], undefined);
+
+      cl.get('/socket.io/socket.io.js', function (res, data) {
+        res.headers['content-type'].should.eql('application/javascript');
+        res.headers['content-length'].should.match(/([0-9]+)/);
+
+        data.should.match(/XMLHttpRequest/);
+        data.should.match(/XHRPolling\.prototype\.name/);
+        data.should.not.match(/Flashsocket\.prototype\.name/);
+        data.should.not.match(/HTMLFile\.prototype\.name/);
+        data.should.not.match(/JSONPPolling\.prototype\.name/);
+        data.should.not.match(/WS\.prototype\.name/);
+
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+  },
+
+  'test that the client etag is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client etag');
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
+
+      data.should.match(/XMLHttpRequest/);
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that the client etag is changed for new transports': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.set('transports', ['websocket']);
+    io.enable('browser client etag');
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      var wsEtag = res.headers.etag;
+
+      io.set('transports', ['xhr-polling']);
+      cl.get('/socket.io/socket.io.js', function (res, data) {
+        res.headers.etag.should.not.equal(wsEtag);
+
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+  },
+
+  'test that the client is served with gzip': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client gzip');
+
+    cl.get('/socket.io/socket.io.js', {
+          headers: {
+              'accept-encoding': 'deflate, gzip'
+          }
+        }
+      , function (res, data) {
+        res.headers['content-type'].should.eql('application/javascript');
+        res.headers['content-encoding'].should.eql('gzip');
+        res.headers['content-length'].should.match(/([0-9]+)/);
+
+        cl.end();
+        io.server.close();
+        done();
+      }
+    );
+  },
+
+  'test that the cached client is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      should.strictEqual(res.headers.etag, undefined);
+
+      data.should.match(/XMLHttpRequest/);
+      var static = io.static;
+      static.cache['/socket.io.js'].content.should.match(/XMLHttpRequest/);
+
+      cl.get('/socket.io/socket.io.js', function (res, data) {
+        res.headers['content-type'].should.eql('application/javascript');
+        res.headers['content-length'].should.match(/([0-9]+)/);
+        should.strictEqual(res.headers.etag, undefined);
+
+        data.should.match(/XMLHttpRequest/);
+
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+  },
+
+  'test that the client is not cached': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.static.add('/random.js', function (path, callback) {
+      var random = Math.floor(Date.now() * Math.random()).toString();
+      callback(null, new Buffer(random));
+    });
+
+    io.disable('browser client cache');
+
+    cl.get('/socket.io/random.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      should.strictEqual(res.headers.etag, undefined);
+
+      cl.get('/socket.io/random.js', function (res, random) {
+        res.headers['content-type'].should.eql('application/javascript');
+        res.headers['content-length'].should.match(/([0-9]+)/);
+        should.strictEqual(res.headers.etag, undefined);
+
+        data.should.not.equal(random);
+
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+  },
+
+  'test that the cached client etag is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client etag');
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
+
+      data.should.match(/XMLHttpRequest/);
+      var static = io.static
+        , cache = static.cache['/socket.io.js'];
+
+      cache.content.toString().should.match(/XMLHttpRequest/);
+      Buffer.isBuffer(cache.content).should.be.true;
+
+      cl.get('/socket.io/socket.io.js', function (res, data) {
+        res.headers['content-type'].should.eql('application/javascript');
+        res.headers['content-length'].should.match(/([0-9]+)/);
+        res.headers.etag.should.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/);
+
+        data.should.match(/XMLHttpRequest/);
+
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+  },
+
+  'test that the cached client sends a 304 header': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client etag');
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      cl.get('/socket.io/socket.io.js', {
+          headers: {
+              'if-none-match': res.headers.etag
+          }
+        }, function (res, data) {
+            res.statusCode.should.eql(304);
+
+            cl.end();
+            io.server.close();
+            done();
+          }
+      );
+    });
+  },
+
+  'test that client minification works': function (done) {
+    // server 1
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    // server 2
+    var port = ++ports
+      , io2 = sio.listen(port)
+      , cl2 = client(port);
+
+    io.enable('browser client minification');
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      var length = data.length;
+
+      cl.end();
+      io.server.close();
+
+      cl2.get('/socket.io/socket.io.js', function (res, data) {
+        res.headers['content-type'].should.eql('application/javascript');
+        res.headers['content-length'].should.match(/([0-9]+)/);
+        should.strictEqual(res.headers.etag, undefined);
+
+        data.should.match(/XMLHttpRequest/);
+        data.length.should.be.greaterThan(length);
+
+        cl2.end();
+        io2.server.close();
+        done();
+      });
+    });
+  },
+
+  'test that the WebSocketMain.swf is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    cl.get('/socket.io/static/flashsocket/WebSocketMain.swf', function (res, data) {
+      res.headers['content-type'].should.eql('application/x-shockwave-flash');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      should.strictEqual(res.headers.etag, undefined);
+
+      var static = io.static
+        , cache = static.cache['/static/flashsocket/WebSocketMain.swf'];
+
+      Buffer.isBuffer(cache.content).should.be.true;
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that the WebSocketMainInsecure.swf is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    cl.get('/socket.io/static/flashsocket/WebSocketMainInsecure.swf', function (res, data) {
+      res.headers['content-type'].should.eql('application/x-shockwave-flash');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      should.strictEqual(res.headers.etag, undefined);
+
+      var static = io.static
+        , cache = static.cache['/static/flashsocket/WebSocketMainInsecure.swf'];
+
+      Buffer.isBuffer(cache.content).should.be.true;
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that swf files are not served with gzip': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client gzip');
+
+    cl.get('/socket.io/static/flashsocket/WebSocketMain.swf', {
+          headers: {
+              'accept-encoding': 'deflate, gzip'
+          }
+        }
+      , function (res, data) {
+          res.headers['content-type'].should.eql('application/x-shockwave-flash');
+          res.headers['content-length'].should.match(/([0-9]+)/);
+          should.strictEqual(res.headers['content-encoding'], undefined);
+
+          cl.end();
+          io.server.close();
+          done();
+        }
+    );
+  },
+
+  'test that you can serve custom clients': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.set('browser client handler', function (req, res) {
+      res.writeHead(200, {
+          'Content-Type': 'application/javascript'
+        , 'Content-Length': 13
+        , 'ETag': '1.0'
+      });
+      res.end('custom_client');
+    });
+
+    cl.get('/socket.io/socket.io.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.eql(13);
+      res.headers.etag.should.eql('1.0');
+
+      data.should.eql('custom_client');
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  }
+
+};

test/transports.flashsocket.test.js

@@ -77,7 +77,7 @@ module.exports = {
     var io = sio.listen(http.createServer())
       , port = ++ports;
 
-    io.get('flash policy port').should.eql(843);
+    io.get('flash policy port').should.eql(10843);
     io.set('flash policy port', port);
     io.get('flash policy port').should.eql(port);
 
@@ -163,6 +163,20 @@ module.exports = {
 
     io.flashPolicyServer.close();
     done();
-  }
+  },
 
+  'flashsocket identifies as flashsocket': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , messages = 0
+      , ws;
+    io.set('transports', ['flashsocket']);
+    io.sockets.on('connection', function (socket) {
+      socket.manager.transports[socket.id].name.should.equal('flashsocket');
+      done();
+    });
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid, 'flashsocket');
+    });
+  }
 };

test/transports.websocket.hybi07-12.parser.test.js

@@ -0,0 +1,262 @@
+/**
+ * Test dependencies.
+ */
+
+var assert = require('assert'); 
+var Parser = require('../lib/transports/websocket/hybi-07-12.js').Parser;
+require('./hybi-common');
+
+/**
+ * Tests.
+ */
+
+module.exports = {
+  'can parse unmasked text message': function() {
+    var p = new Parser();
+    var packet = '81 05 48 65 6c 6c 6f';
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal('Hello', data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse close message': function() {
+    var p = new Parser();
+    var packet = '88 00';
+  
+    var gotClose = false;
+    p.on('close', function(data) {
+      gotClose = true;
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotClose);
+  },
+  'can parse masked text message': function() {
+    var p = new Parser();
+    var packet = '81 93 34 83 a8 68 01 b9 92 52 4f a1 c6 09 59 e6 8a 52 16 e6 cb 00 5b a1 d5';
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal('5:::{"name":"echo"}', data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a masked text message longer than 125 bytes': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var packet = '81 FE ' + pack(4, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+    
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a really long masked text message': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 64*1024; ++i) message += (i % 5).toString();
+    var packet = '81 FF ' + pack(16, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a fragmented masked text message of 300 bytes': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var msgpiece1 = message.substr(0, 150);
+    var msgpiece2 = message.substr(150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;      
+      assert.equal(message, data);
+    });
+  
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(packet2));
+    assert.ok(gotData);
+  },
+  'can parse a ping message': function() {
+    var p = new Parser();
+    var message = 'Hello';
+    var packet = '89 FE ' + pack(4, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+    
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+      assert.equal(message, data);
+    });
+    
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotPing);
+  },
+  'can parse a ping with no data': function() {
+    var p = new Parser();
+    var packet = '89 00';
+    
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+    });
+    
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotPing);
+  },
+  'can parse a fragmented masked text message of 300 bytes with a ping in the middle': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+  
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+  
+    var pingMessage = 'Hello';
+    var pingPacket = '89 FE ' + pack(4, pingMessage.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+  
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    });
+    
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(pingPacket));
+    p.add(getBufferFromHexString(packet2));
+    assert.ok(gotData);
+    assert.ok(gotPing);
+  },
+  'can parse a fragmented masked text message of 300 bytes with a ping in the middle, which is delievered over sevaral tcp packets': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+  
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+  
+    var pingMessage = 'Hello';
+    var pingPacket = '89 FE ' + pack(4, pingMessage.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+  
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    });
+    
+    var buffers = [];
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet1)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(pingPacket)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet2)));
+    for (var i = 0; i < buffers.length; ++i) {
+      p.add(buffers[i]);
+    }
+    assert.ok(gotData);
+    assert.ok(gotPing);
+  },
+  'can parse a 100 byte long masked binary message': function() {
+    var p = new Parser();
+    var length = 100;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a 256 byte long masked binary message': function() {
+    var p = new Parser();
+    var length = 256;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a 200kb long masked binary message': function() {
+    var p = new Parser();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a 200kb long unmasked binary message': function() {
+    var p = new Parser();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, false) + ' ' + getHexStringFromBuffer(message);
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+};
+

test/transports.websocket.hybi16.parser.test.js

@@ -0,0 +1,262 @@
+/**
+ * Test dependencies.
+ */
+
+var assert = require('assert'); 
+var Parser = require('../lib/transports/websocket/hybi-16.js').Parser;
+require('./hybi-common');
+
+/**
+ * Tests.
+ */
+
+module.exports = {
+  'can parse unmasked text message': function() {
+    var p = new Parser();
+    var packet = '81 05 48 65 6c 6c 6f';
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal('Hello', data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse close message': function() {
+    var p = new Parser();
+    var packet = '88 00';
+  
+    var gotClose = false;
+    p.on('close', function(data) {
+      gotClose = true;
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotClose);
+  },
+  'can parse masked text message': function() {
+    var p = new Parser();
+    var packet = '81 93 34 83 a8 68 01 b9 92 52 4f a1 c6 09 59 e6 8a 52 16 e6 cb 00 5b a1 d5';
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal('5:::{"name":"echo"}', data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a masked text message longer than 125 bytes': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var packet = '81 FE ' + pack(4, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+    
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a really long masked text message': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 64*1024; ++i) message += (i % 5).toString();
+    var packet = '81 FF ' + pack(16, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a fragmented masked text message of 300 bytes': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var msgpiece1 = message.substr(0, 150);
+    var msgpiece2 = message.substr(150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;      
+      assert.equal(message, data);
+    });
+  
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(packet2));
+    assert.ok(gotData);
+  },
+  'can parse a ping message': function() {
+    var p = new Parser();
+    var message = 'Hello';
+    var packet = '89 FE ' + pack(4, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+    
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+      assert.equal(message, data);
+    });
+    
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotPing);
+  },
+  'can parse a ping with no data': function() {
+    var p = new Parser();
+    var packet = '89 00';
+    
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+    });
+    
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotPing);
+  },
+  'can parse a fragmented masked text message of 300 bytes with a ping in the middle': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+  
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+  
+    var pingMessage = 'Hello';
+    var pingPacket = '89 FE ' + pack(4, pingMessage.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+  
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    });
+    
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(pingPacket));
+    p.add(getBufferFromHexString(packet2));
+    assert.ok(gotData);
+    assert.ok(gotPing);
+  },
+  'can parse a fragmented masked text message of 300 bytes with a ping in the middle, which is delievered over sevaral tcp packets': function() {
+    var p = new Parser();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+  
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+  
+    var pingMessage = 'Hello';
+    var pingPacket = '89 FE ' + pack(4, pingMessage.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+  
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+  
+    var gotData = false;
+    p.on('data', function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    });
+    var gotPing = false;
+    p.on('ping', function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    });
+    
+    var buffers = [];
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet1)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(pingPacket)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet2)));
+    for (var i = 0; i < buffers.length; ++i) {
+      p.add(buffers[i]);
+    }
+    assert.ok(gotData);
+    assert.ok(gotPing);
+  },
+  'can parse a 100 byte long masked binary message': function() {
+    var p = new Parser();
+    var length = 100;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a 256 byte long masked binary message': function() {
+    var p = new Parser();
+    var length = 256;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a 200kb long masked binary message': function() {
+    var p = new Parser();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+  'can parse a 200kb long unmasked binary message': function() {
+    var p = new Parser();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message); 
+    var packet = '82 ' + getHybiLengthAsHexString(length, false) + ' ' + getHexStringFromBuffer(message);
+
+    var gotData = false;
+    p.on('binary', function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    });
+  
+    p.add(getBufferFromHexString(packet));
+    assert.ok(gotData);
+  },
+};
+

test/transports.xhr-polling.test.js

@@ -950,6 +950,44 @@ module.exports = {
     });
   },
 
+  'test that emitting an error event doesnt throw': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+
+    io.configure(function () {
+      io.set('polling duration', .05);
+      io.set('close timeout', .05);
+    });
+
+    io.sockets.on('connection', function (socket) {
+      socket.on('disconnect', function () {
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+
+    cl.handshake(function (sid) {
+      cl.get('/socket.io/{protocol}/xhr-polling/' + sid, function (res, msgs) {
+        res.statusCode.should.equal(200);
+        msgs.should.have.length(1);
+        msgs[0].should.eql({ type: 'noop', endpoint: '' });
+
+        cl.post(
+            '/socket.io/{protocol}/xhr-polling/' + sid
+          , parser.encodePacket({
+                type: 'event'
+              , name: 'error'
+            })
+          , function (res, data) {
+              res.statusCode.should.eql(200);
+              data.should.equal('1');
+            }
+        );
+      });
+    });
+  },
+
   'test emitting an event to the server with data': function (done) {
     var cl = client(++ports)
       , io = create(cl)