Release 0.9.4

Issue795 fix

.gitignore

@@ -6,4 +6,5 @@ lib-cov
 *.dat
 *.out
 *.pid
+benchmarks/*.png
 node_modules

.travis.yml

@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - 0.6
+
+notifications:
+  irc: "irc.freenode.org#socket.io"

History.md

@@ -1,4 +1,179 @@
 
+0.9.4 / 2012-04-01
+==================
+
+  * Disconnecting from namespace improvement (#795) [DanielBaulig]
+  * Bumped client with polling reconnection loop (#438)
+
+0.9.3 / 2012-03-28
+==================
+
+  * Fix "Syntax error" on FF Web Console with XHR Polling [mikito]
+
+0.9.2 / 2012-03-13
+==================
+
+  * More sensible close `timeout default` (fixes disconnect issue)
+
+0.9.1-1 / 2012-03-02
+====================
+
+  * Bumped client with NPM dependency fix.
+
+0.9.1 / 2012-03-02
+==================
+
+  * Changed heartbeat timeout and interval defaults (60 and 25 seconds)
+  * Make tests work both on 0.4 and 0.6
+  * Updated client (improvements + bug fixes).
+
+0.9.0 / 2012-02-26
+==================
+
+  * Make it possible to use a regexp to match the socket.io resource URL.
+    We need this because we have to prefix the socket.io URL with a variable ID.
+  * Supplemental fix to gavinuhma/authfix, it looks like the same Access-Control-Origin logic is needed in the http and xhr-polling transports
+  * Updated express dep for windows compatibility.
+  * Combine two substr calls into one in decodePayload to improve performance
+  * Minor documentation fix
+  * Minor. Conform to style of other files.
+  * Switching setting to 'match origin protocol'
+  * Revert "Fixes leaking Redis subscriptions for #663. The local flag was not getting passed through onClientDisconnect()."
+  * Revert "Handle leaked dispatch:[id] subscription."
+  * Merge pull request #667 from dshaw/patch/redis-disconnect
+  * Handle leaked dispatch:[id] subscription.
+  * Fixes leaking Redis subscriptions for #663. The local flag was not getting passed through onClientDisconnect().
+  * Prevent memory leaking on uncompleted requests & add max post size limitation
+  * Fix for testcase
+  * Set Access-Control-Allow-Credentials true, regardless of cookie
+  * Remove assertvarnish from package as it breaks on 0.6
+  * Correct irc channel
+  * Added proper return after reserved field error
+  * Fixes manager.js failure to close connection after transport error has happened
+  * Added implicit port 80 for origin checks. fixes #638
+  * Fixed bug #432 in 0.8.7
+  * Set Access-Control-Allow-Origin header to origin to enable withCredentials
+  * Adding configuration variable matchOriginProtocol
+  * Fixes location mismatch error in Safari.
+  * Use tty to detect if we should add colors or not by default.
+  * Updated the package location.
+
+0.8.7 / 2011-11-05
+==================
+
+  * Fixed memory leaks in closed clients.
+  * Fixed memory leaks in namespaces.
+  * Fixed websocket handling for malformed requests from proxies. [einaros]
+  * Node 0.6 compatibility. [einaros] [3rd-Eden]
+  * Adapted tests and examples.
+
+0.8.6 / 2011-10-27 
+==================
+
+  * Added JSON decoding on jsonp-polling transport.
+  * Fixed README example.
+  * Major speed optimizations [3rd-Eden] [einaros] [visionmedia]
+  * Added decode/encode benchmarks [visionmedia]
+  * Added support for black-listing client sent events.
+  * Fixed logging options, closes #540 [3rd-Eden]
+  * Added vary header for gzip [3rd-Eden]
+  * Properly cleaned up async websocket / flashsocket tests, after patching node-websocket-client
+  * Patched to properly shut down when a finishClose call is made during connection establishment
+  * Added support for socket.io version on url and far-future Expires [3rd-Eden] [getify]
+  * Began IE10 compatibility [einaros] [tbranyen]
+  * Misc WebSocket fixes [einaros]
+  * Added UTF8 to respone headers for htmlfile [3rd-Eden]
+
+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
+===================
+
+  * Updated socket.io-client.
+
+0.7.10 / 2011-08-27
+===================
+
+  * Updated socket.io-client.
+
+0.7.9 / 2011-08-12
+==================
+
+  * Updated socket.io-client.
+  * Make sure we only do garbage collection when the server we receive is actually run.
+
+0.7.8 / 2011-08-08
+==================
+
+  * Changed; make sure sio#listen passes options to both HTTP server and socket.io manager.
+  * Added docs for sio#listen.
+  * Added options parameter support for Manager constructor.
+  * Added memory leaks tests and test-leaks Makefile task.
+  * Removed auto npm-linking from make test.
+  * Make sure that you can disable heartbeats. [3rd-Eden]
+  * Fixed rooms memory leak [3rd-Eden]
+  * Send response once we got all POST data, not immediately [Pita]
+  * Fixed onLeave behavior with missing clientsk [3rd-Eden]
+  * Prevent duplicate references in rooms.
+  * Added alias for `to` to `in` and `in` to `to`.
+  * Fixed roomClients definition.
+  * Removed dependency on redis for installation without npm [3rd-Eden]
+  * Expose path and querystring in handshakeData [3rd-Eden]
+
 0.7.7 / 2011-07-12
 ==================
 

Makefile

@@ -1,20 +1,31 @@
 
 ALL_TESTS = $(shell find test/ -name '*.test.js')
+ALL_BENCH = $(shell find benchmarks -name '*.bench.js')
 
 run-tests:
-	@npm link > /dev/null --local
 	@./node_modules/.bin/expresso \
 		-t 3000 \
 		-I support \
-		-I lib \
 		--serial \
 		$(TESTFLAGS) \
 		$(TESTS)
 
 test:
-	@$(MAKE) TESTS="$(ALL_TESTS)" run-tests
+	@$(MAKE) NODE_PATH=lib TESTS="$(ALL_TESTS)" run-tests
 
 test-cov:
 	@TESTFLAGS=--cov $(MAKE) test
 
-.PHONY: test
+test-leaks:
+	@ls test/leaks/* | xargs node --expose_debug_as=debug --expose_gc
+
+run-bench:
+	@node $(PROFILEFLAGS) benchmarks/runner.js
+
+bench:
+	@$(MAKE) BENCHMARKS="$(ALL_BENCH)" run-bench
+
+profile:
+	@PROFILEFLAGS='--prof --trace-opt --trace-bailout --trace-deopt' $(MAKE) bench
+
+.PHONY: test bench profile

Readme.md

@@ -6,7 +6,9 @@ horizontal scalability, automatic JSON encoding/decoding, and more.
 
 ## How to Install
 
-    npm install socket.io
+```bash
+npm install socket.io
+```
 
 ## How to use
 
@@ -20,7 +22,7 @@ Next, attach it to a HTTP/HTTPS server. If you're using the fantastic `express`
 web framework:
 
 ```js
-var app = express.createServer();
+var app = express.createServer()
   , io = io.listen(app);
 
 app.listen(80);
@@ -60,14 +62,14 @@ 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);
   });
 
   socket.on('disconnect', function () {
-    sockets.emit('user disconnected');
+    io.sockets.emit('user disconnected');
   });
 });
 ```
@@ -131,7 +133,7 @@ The following example defines a socket that listens on '/chat' and one for
 var io = require('socket.io').listen(80);
 
 var chat = io
-  .of('/chat');
+  .of('/chat')
   .on('connection', function (socket) {
     socket.emit('a message', { that: 'only', '/chat': 'will get' });
     chat.emit('a message', { everyone: 'in', '/chat': 'will get' });
@@ -222,7 +224,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'
     });

benchmarks/decode.bench.js

@@ -0,0 +1,64 @@
+
+/**
+ * Module dependencies.
+ */
+
+var benchmark = require('benchmark')
+  , colors = require('colors')
+  , io = require('../')
+  , parser = io.parser
+  , suite = new benchmark.Suite('Decode packet');
+
+suite.add('string', function () {
+  parser.decodePacket('4:::"2"');
+});
+
+suite.add('event', function () {
+  parser.decodePacket('5:::{"name":"woot"}');
+});
+
+suite.add('event+ack', function () {
+  parser.decodePacket('5:1+::{"name":"tobi"}');
+});
+
+suite.add('event+data', function () {
+  parser.decodePacket('5:::{"name":"edwald","args":[{"a": "b"},2,"3"]}');
+});
+
+suite.add('heartbeat', function () {
+  parser.decodePacket('2:::');
+});
+
+suite.add('error', function () {
+  parser.decodePacket('7:::2+0');
+});
+
+var payload = parser.encodePayload([
+    parser.encodePacket({ type: 'message', data: '5', endpoint: '' })
+  , parser.encodePacket({ type: 'message', data: '53d', endpoint: '' })
+  , parser.encodePacket({ type: 'message', data: 'foobar', endpoint: '' })
+  , parser.encodePacket({ type: 'message', data: 'foobarbaz', endpoint: '' })
+  , parser.encodePacket({ type: 'message', data: 'foobarbazfoobarbaz', endpoint: '' })
+  , parser.encodePacket({ type: 'message', data: 'foobarbaz', endpoint: '' })
+  , parser.encodePacket({ type: 'message', data: 'foobar', endpoint: '' })
+]);
+
+suite.add('payload', function () {
+  parser.decodePayload(payload);
+});
+
+suite.on('cycle', function (bench, details) {
+  console.log('\n' + suite.name.grey, details.name.white.bold);
+  console.log([
+      details.hz.toFixed(2).cyan + ' ops/sec'.grey
+    , details.count.toString().white + ' times executed'.grey
+    , 'benchmark took '.grey + details.times.elapsed.toString().white + ' sec.'.grey
+    , 
+  ].join(', '.grey));
+});
+
+if (!module.parent) {
+  suite.run();
+} else {
+  module.exports = suite;
+}

benchmarks/encode.bench.js

@@ -0,0 +1,90 @@
+
+/**
+ * Module dependencies.
+ */
+
+var benchmark = require('benchmark')
+  , colors = require('colors')
+  , io = require('../')
+  , parser = io.parser
+  , suite = new benchmark.Suite('Encode packet');
+
+suite.add('string', function () {
+  parser.encodePacket({
+      type: 'json'
+    , endpoint: ''
+    , data: '2'
+  });
+});
+
+suite.add('event', function () {
+  parser.encodePacket({
+      type: 'event'
+    , name: 'woot'
+    , endpoint: ''
+    , args: []
+  });
+});
+
+suite.add('event+ack', function () {
+  parser.encodePacket({
+      type: 'json'
+    , id: 1
+    , ack: 'data'
+    , endpoint: ''
+    , data: { a: 'b' }
+  });
+});
+
+suite.add('event+data', function () {
+  parser.encodePacket({
+      type: 'event'
+    , name: 'edwald'
+    , endpoint: ''
+    , args: [{a: 'b'}, 2, '3']
+  });
+});
+
+suite.add('heartbeat', function () {
+  parser.encodePacket({
+      type: 'heartbeat'
+    , endpoint: ''
+  })
+});
+
+suite.add('error', function () {
+  parser.encodePacket({
+      type: 'error'
+    , reason: 'unauthorized'
+    , advice: 'reconnect'
+    , endpoint: ''
+  })
+})
+
+suite.add('payload', function () {
+  parser.encodePayload([
+      parser.encodePacket({ type: 'message', data: '5', endpoint: '' })
+    , parser.encodePacket({ type: 'message', data: '53d', endpoint: '' })
+    , parser.encodePacket({ type: 'message', data: 'foobar', endpoint: '' })
+    , parser.encodePacket({ type: 'message', data: 'foobarbaz', endpoint: '' })
+    , parser.encodePacket({ type: 'message', data: 'foobarbazfoobarbaz', endpoint: '' })
+    , parser.encodePacket({ type: 'message', data: 'foobarbaz', endpoint: '' })
+    , parser.encodePacket({ type: 'message', data: 'foobar', endpoint: '' })
+  ]);
+});
+
+suite.on('cycle', function (bench, details) {
+  console.log('\n' + suite.name.grey, details.name.white.bold);
+  console.log([
+      details.hz.toFixed(2).cyan + ' ops/sec'.grey
+    , details.count.toString().white + ' times executed'.grey
+    , 'benchmark took '.grey + details.times.elapsed.toString().white + ' sec.'.grey
+    , 
+  ].join(', '.grey));
+});
+
+if (!module.parent) {
+  suite.run();
+} else {
+  module.exports = suite;
+}

benchmarks/runner.js

@@ -0,0 +1,55 @@
+/**
+ * Benchmark runner dependencies
+ */
+
+var colors = require('colors')
+  , path = require('path');
+
+/**
+ * Find all the benchmarks
+ */
+
+var benchmarks_files = process.env.BENCHMARKS.split(' ')
+  , all = [].concat(benchmarks_files)
+  , first = all.shift()
+  , benchmarks = {};
+
+// find the benchmarks and load them all in our obj
+benchmarks_files.forEach(function (file) {
+  benchmarks[file] = require(path.join(__dirname, '..', file));
+});
+
+// setup the complete listeners
+benchmarks_files.forEach(function (file) {
+  var benchmark = benchmarks[file]
+    , next_file = all.shift()
+    , next = benchmarks[next_file];
+
+  /**
+   * Generate a oncomplete function for the tests, either we are done or we
+   * have more benchmarks to process.
+   */
+
+   function complete () {
+      if (!next) {
+        console.log(
+          '\n\nBenchmark completed in'.grey
+        , (Date.now() - start).toString().green + ' ms'.grey
+        );
+      } else {
+        console.log('\nStarting benchmark '.grey + next_file.yellow);
+        next.run();
+      }
+   }
+
+   // attach the listener
+   benchmark.on('complete', complete);
+});
+
+/**
+ * Start the benchmark
+ */
+
+var start = Date.now();
+console.log('Starting benchmark '.grey + first.yellow);
+benchmarks[first].run();

examples/chat/app.js

@@ -1,10 +1,3 @@
-
-/**
- * Bootstrap app.
- */
-
-require.paths.unshift(__dirname + '/../../lib/');
-
 /**
  * Module dependencies.
  */
@@ -12,7 +5,7 @@ require.paths.unshift(__dirname + '/../../lib/');
 var express = require('express')
   , stylus = require('stylus')
   , nib = require('nib')
-  , sio = require('socket.io');
+  , sio = require('../../lib/socket.io');
 
 /**
  * App.
@@ -25,7 +18,7 @@ var app = express.createServer();
  */
 
 app.configure(function () {
-  app.use(stylus.middleware({ src: __dirname + '/public', compile: compile }))
+  app.use(stylus.middleware({ src: __dirname + '/public', compile: compile }));
   app.use(express.static(__dirname + '/public'));
   app.set('views', __dirname);
   app.set('view engine', 'jade');

examples/chat/package.json

@@ -3,9 +3,9 @@
   , "description": "example chat application with socket.io"
   , "version": "0.0.1"
   , "dependencies": {
-        "express": "2.3.11"
-      , "jade": "0.12.1"
-      , "stylus": "0.13.3"
-      , "nib": "0.0.8"
+        "express": "2.5.5"
+      , "jade": "0.16.4"
+      , "stylus": "0.19.0"
+      , "nib": "0.2.0"
     }
 }

examples/irc-output/app.js

@@ -1,10 +1,3 @@
-
-/**
- * Bootstrap app.
- */
-
-require.paths.unshift(__dirname + '/../../lib/');
-
 /**
  * Module dependencies.
  */
@@ -12,7 +5,7 @@ require.paths.unshift(__dirname + '/../../lib/');
 var express = require('express')
   , stylus = require('stylus')
   , nib = require('nib')
-  , sio = require('socket.io')
+  , sio = require('../../lib/socket.io')
   , irc = require('./irc');
 
 /**

examples/irc-output/irc.js

@@ -2,7 +2,7 @@
  * From https://github.com/felixge/nodelog/
  */
 
-var sys = require('sys');
+var sys = require('util');
 var tcp = require('net');
 var irc = exports;
 

examples/irc-output/package.json

@@ -2,9 +2,9 @@
     "name": "socket.io-irc"
   , "version": "0.0.1"
   , "dependencies": {
-        "express": "2.3.11"
-      , "jade": "0.12.1"
-      , "stylus": "0.13.3"
-      , "nib": "0.0.8"
+        "express": "2.5.5"
+      , "jade": "0.16.4"
+      , "stylus": "0.19.0"
+      , "nib": "0.2.0"
     }
 }

lib/logger.js

@@ -60,6 +60,7 @@ var Logger = module.exports = function (opts) {
   opts = opts || {}
   this.colors = false !== opts.colors;
   this.level = 3;
+  this.enabled = true;
 };
 
 /**
@@ -71,7 +72,7 @@ var Logger = module.exports = function (opts) {
 Logger.prototype.log = function (type) {
   var index = levels.indexOf(type);
 
-  if (index > this.level)
+  if (index > this.level || !this.enabled)
     return this;
 
   console.log.apply(

lib/manager.js

@@ -1,4 +1,3 @@
-
 /*!
  * socket.io-node
  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
@@ -9,10 +8,9 @@
  * Module dependencies.
  */
 
-var http = require('http')
-  , https = require('https')
-  , fs = require('fs')
+var fs = require('fs')
   , url = require('url')
+  , tty = require('tty')
   , util = require('./util')
   , store = require('./store')
   , client = require('socket.io-client')
@@ -21,6 +19,7 @@ var http = require('http')
   , Socket = require('./socket')
   , MemoryStore = require('./stores/memory')
   , SocketNamespace = require('./namespace')
+  , Static = require('./static')
   , EventEmitter = process.EventEmitter;
 
 /**
@@ -55,7 +54,7 @@ var parent = module.parent.exports
  * @api public
  */
 
-function Manager (server) {
+function Manager (server, options) {
   this.server = server;
   this.namespaces = {};
   this.sockets = this.of('');
@@ -64,33 +63,54 @@ function Manager (server) {
     , log: true
     , store: new MemoryStore
     , logger: new Logger
+    , static: new Static(this)
     , heartbeats: true
     , resource: '/socket.io'
     , transports: defaultTransports
     , authorization: false
+    , blacklist: ['disconnect']
     , 'log level': 3
-    , 'close timeout': 25
-    , 'heartbeat timeout': 15
-    , 'heartbeat interval': 20
+    , 'log colors': tty.isatty(process.stdout.fd)
+    , 'close timeout': 60
+    , 'heartbeat interval': 25
+    , 'heartbeat timeout': 60
     , 'polling duration': 20
     , 'flash policy server': true
-    , 'flash policy port': 843
+    , 'flash policy port': 10843
     , 'destroy upgrade': true
+    , 'destroy buffer size': 10E7
     , 'browser client': true
+    , 'browser client cache': true
     , 'browser client minification': false
     , 'browser client etag': false
+    , 'browser client expires': 315360000
+    , 'browser client gzip': false
     , 'browser client handler': false
     , 'client store expiration': 15
+    , 'match origin protocol': false
   };
 
+  for (var i in options) {
+    this.settings[i] = options[i];
+  }
+
+  var self = this;
+
+  // default error handler
+  server.on('error', function(err) {
+    self.log.warn('error raised: ' + err);
+  });
+
   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);
   });
@@ -99,12 +119,26 @@ function Manager (server) {
     self.handleUpgrade(req, socket, head);
   });
 
+  server.on('close', function () {
+    clearInterval(self.gc);
+  });
+
+  server.once('listening', function () {
+    self.gc = setInterval(self.garbageCollection.bind(self), 10000);
+  });
+
   for (var i in transports) {
     if (transports[i].init) {
       transports[i].init(this);
     }
   }
 
+  // forward-compatibility with 1.0
+  var self = this;
+  this.sockets.on('connection', function (conn) {
+    self.emit('connection', conn);
+  });
+
   this.log.info('socket.io started');
 };
 
@@ -129,14 +163,25 @@ Manager.prototype.__defineGetter__('store', function () {
  */
 
 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;
+  logger.colors = this.get('log colors');
+  logger.enabled = this.enabled('log');
 
   return logger;
 });
 
+/**
+ * Static accessor.
+ *
+ * @api public
+ */
+
+Manager.prototype.__defineGetter__('static', function () {
+  return this.get('static');
+});
+
 /**
  * Get settings.
  *
@@ -213,7 +258,7 @@ Manager.prototype.disabled = function (key) {
 Manager.prototype.configure = function (env, fn) {
   if ('function' == typeof env) {
     env.call(this);
-  } else if (env == process.env.NODE_ENV) {
+  } else if (env == (process.env.NODE_ENV || 'development')) {
     fn.call(this);
   }
 
@@ -231,7 +276,6 @@ Manager.prototype.initStore = function () {
   this.connected = {};
   this.open = {};
   this.closed = {};
-  this.closedA = [];
   this.rooms = {};
   this.roomClients = {};
 
@@ -303,8 +347,6 @@ Manager.prototype.onOpen = function (id) {
   if (this.closed[id]) {
     var self = this;
 
-    this.closedA.splice(this.closedA.indexOf(id), 1);
-
     this.store.unsubscribe('dispatch:' + id, function () {
       delete self.closed[id];
     });
@@ -347,15 +389,17 @@ Manager.prototype.onDispatch = function (room, packet, volatile, exceptions) {
 
 Manager.prototype.onJoin = function (id, name) {
   if (!this.roomClients[id]) {
-    this.roomClients[id] = [];
+    this.roomClients[id] = {};
   }
 
   if (!this.rooms[name]) {
     this.rooms[name] = [];
   }
 
-  this.rooms[name].push(id);
-  this.roomClients[id][name] = true;
+  if (!~this.rooms[name].indexOf(id)) {
+    this.rooms[name].push(id);
+    this.roomClients[id][name] = true;
+  }
 };
 
 /**
@@ -366,7 +410,15 @@ Manager.prototype.onJoin = function (id, name) {
 
 Manager.prototype.onLeave = function (id, room) {
   if (this.rooms[room]) {
-    this.rooms[room].splice(this.rooms[room].indexOf(id), 1);
+    var index = this.rooms[room].indexOf(id);
+
+    if (index >= 0) {
+      this.rooms[room].splice(index, 1);
+    }
+
+    if (!this.rooms[room].length) {
+      delete this.rooms[room];
+    }
     delete this.roomClients[id][room];
   }
 };
@@ -383,7 +435,6 @@ Manager.prototype.onClose = function (id) {
   }
 
   this.closed[id] = [];
-  this.closedA.push(id);
 
   var self = this;
 
@@ -425,13 +476,12 @@ Manager.prototype.onClientMessage = function (id, packet) {
  */
 
 Manager.prototype.onClientDisconnect = function (id, reason) {
-  this.onDisconnect(id);
-
   for (var name in this.namespaces) {
-    if (this.roomClients[id][name]) {
-      this.namespaces[name].handleDisconnect(id, reason);
-    }
+    this.namespaces[name].handleDisconnect(id, reason, typeof this.roomClients[id] !== 'undefined' &&
+      typeof this.roomClients[id][name] !== 'undefined');
   }
+
+  this.onDisconnect(id);
 };
 
 /**
@@ -458,13 +508,13 @@ Manager.prototype.onDisconnect = function (id, local) {
 
   if (this.closed[id]) {
     delete this.closed[id];
-    this.closedA.splice(this.closedA.indexOf(id), 1);
   }
 
   if (this.roomClients[id]) {
     for (var room in this.roomClients[id]) {
-      this.rooms[room].splice(this.rooms[room].indexOf(id), 1);
+      this.onLeave(id, room);
     }
+    delete this.roomClients[id]
   }
 
   this.store.destroyClient(id, this.get('client store expiration'));
@@ -496,7 +546,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.');
@@ -581,9 +631,15 @@ Manager.prototype.handleClient = function (data, req) {
     return;
   }
 
-  var transport = new transports[data.transport](this, data, req);
+  var transport = new transports[data.transport](this, data, req)
+    , handshaken = this.handshaken[data.id];
 
-  if (this.handshaken[data.id]) {
+  if (transport.disconnected) {
+    // failed during transport setup
+    req.connection.end();
+    return;
+  }
+  if (handshaken) {
     if (transport.open) {
       if (this.closed[data.id] && this.closed[data.id].length) {
         transport.payload(this.closed[data.id]);
@@ -599,6 +655,11 @@ Manager.prototype.handleClient = function (data, req) {
       this.onConnect(data.id);
       this.store.publish('connect', data.id);
 
+      // flag as used
+      delete handshaken.issued;
+      this.onHandshake(data.id, handshaken);
+      this.store.publish('handshake', data.id, handshaken);
+
       // initialize the socket for all namespaces
       for (var i in this.namespaces) {
         var socket = this.namespaces[i].socket(data.id, true);
@@ -626,104 +687,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.
  *
@@ -742,14 +705,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);
     }
   };
@@ -766,6 +733,12 @@ 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'] = origin;
+    headers['Access-Control-Allow-Credentials'] = 'true';
+  }
+
   this.authorize(handshakeData, function (err, authorized, newData) {
     if (err) return error(err);
 
@@ -773,7 +746,7 @@ Manager.prototype.handleHandshake = function (data, req, res) {
       var id = self.generateId()
         , hs = [
               id
-            , self.get('heartbeat timeout') || ''
+            , self.enabled('heartbeats') ? self.get('heartbeat timeout') || '' : ''
             , self.get('close timeout') || ''
             , self.transports(data).join(',')
           ].join(':');
@@ -782,7 +755,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);
@@ -806,26 +779,30 @@ Manager.prototype.handleHandshake = function (data, req, res) {
 
 Manager.prototype.handshakeData = function (data) {
   var connection = data.request.connection
-    , connectionAddress;
+    , connectionAddress
+    , date = new Date;
 
   if (connection.remoteAddress) {
     connectionAddress = {
         address: connection.remoteAddress
       , port: connection.remotePort
-    }; 
+    };
   } else if (connection.socket && connection.socket.remoteAddress) {
     connectionAddress = {
         address: connection.socket.remoteAddress
       , port: connection.socket.remotePort
-    }; 
+    };
   }
 
   return {
       headers: data.headers
     , address: connectionAddress
-    , time: (new Date).toString()
+    , time: date.toString()
+    , query: data.query
+    , url: data.request.url
     , xdomain: !!data.request.headers.origin
     , secure: data.request.connection.secure
+    , issued: +date
   };
 };
 
@@ -836,7 +813,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 = '*';
@@ -848,14 +825,20 @@ Manager.prototype.verifyOrigin = function (request) {
   if (origin) {
     try {
       var parts = url.parse(origin);
-
-      return
-        ~origins.indexOf(parts.host + ':' + parts.port) ||
-        ~origins.indexOf(parts.host + ':*') ||
+      parts.port = parts.port || 80;
+      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;
 };
 
@@ -927,8 +910,17 @@ var regexp = /^\/([^\/]+)\/?([^\/]+)?\/?([^\/]+)?\/?$/
 Manager.prototype.checkRequest = function (req) {
   var resource = this.get('resource');
 
-  if (req.url.substr(0, resource.length) == resource) {
-    var uri = url.parse(req.url.substr(resource.length), true)
+  var match;
+  if (typeof resource === 'string') {
+    match = req.url.substr(0, resource.length);
+    if (match !== resource) match = null;
+  } else {
+    match = resource.exec(req.url);
+    if (match) match = match[0];
+  }
+
+  if (match) {
+    var uri = url.parse(req.url.substr(match.length), true)
       , path = uri.pathname || ''
       , pieces = path.match(regexp);
 
@@ -944,7 +936,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;
@@ -955,6 +947,8 @@ Manager.prototype.checkRequest = function (req) {
 
 /**
  * Declares a socket namespace
+ *
+ * @api public
  */
 
 Manager.prototype.of = function (nsp) {
@@ -964,3 +958,26 @@ Manager.prototype.of = function (nsp) {
 
   return this.namespaces[nsp] = new SocketNamespace(this, nsp);
 };
+
+/**
+ * Perform garbage collection on long living objects and properties that cannot
+ * be removed automatically.
+ *
+ * @api private
+ */
+
+Manager.prototype.garbageCollection = function () {
+  // clean up unused handshakes
+  var ids = Object.keys(this.handshaken)
+    , i = ids.length
+    , now = Date.now()
+    , handshake;
+
+  while (i--) {
+    handshake = this.handshaken[ids[i]];
+
+    if ('issued' in handshake && (now - handshake.issued) >= 3E4) {
+      this.onDisconnect(ids[i]);
+    }
+  }
+};

lib/namespace.js

@@ -34,7 +34,7 @@ function SocketNamespace (mgr, name) {
 SocketNamespace.prototype.__proto__ = EventEmitter.prototype;
 
 /**
- * Copies emit since we override it
+ * Copies emit since we override it.
  *
  * @api private
  */
@@ -103,18 +103,18 @@ SocketNamespace.prototype.__defineGetter__('volatile', function () {
 });
 
 /**
- * Overrides the room to relay messages to (flag)
+ * Overrides the room to relay messages to (flag).
  *
  * @api public
  */
 
-SocketNamespace.prototype.in = function (room) {
+SocketNamespace.prototype.in = SocketNamespace.prototype.to = function (room) {
   this.flags.endpoint = this.name + (room ? '/' + room : '');
   return this;
 };
 
 /**
- * Adds a session id we should prevent relaying messages to (flag)
+ * Adds a session id we should prevent relaying messages to (flag).
  *
  * @api public
  */
@@ -139,7 +139,7 @@ SocketNamespace.prototype.setFlags = function () {
 };
 
 /**
- * Sends out a packet
+ * Sends out a packet.
  *
  * @api private
  */
@@ -175,9 +175,9 @@ SocketNamespace.prototype.send = function (data) {
 };
 
 /**
- * Emits to everyone (override)
+ * Emits to everyone (override).
  *
- * @api private
+ * @api public
  */
 
 SocketNamespace.prototype.emit = function (name) {
@@ -196,7 +196,7 @@ SocketNamespace.prototype.emit = function (name) {
  * Retrieves or creates a write-only socket for a client, unless specified.
  *
  * @param {Boolean} whether the socket will be readable when initialized
- * @api private
+ * @api public
  */
 
 SocketNamespace.prototype.socket = function (sid, readable) {
@@ -208,7 +208,7 @@ SocketNamespace.prototype.socket = function (sid, readable) {
 };
 
 /**
- * Sets authorization for this namespace
+ * Sets authorization for this namespace.
  *
  * @api public
  */
@@ -224,9 +224,10 @@ SocketNamespace.prototype.authorization = function (fn) {
  * @api private
  */
 
-SocketNamespace.prototype.handleDisconnect = function (sid, reason) {
+SocketNamespace.prototype.handleDisconnect = function (sid, reason, raiseOnDisconnect) {
   if (this.sockets[sid] && this.sockets[sid].readable) {
-    this.sockets[sid].onDisconnect(reason);
+    if (raiseOnDisconnect) this.sockets[sid].onDisconnect(reason);
+    delete this.sockets[sid];
   }
 };
 
@@ -263,6 +264,7 @@ SocketNamespace.prototype.authorize = function (data, fn) {
 SocketNamespace.prototype.handlePacket = function (sessid, packet) {
   var socket = this.socket(sessid)
     , dataAck = packet.ack == 'data'
+    , manager = this.manager
     , self = this;
 
   function ack () {
@@ -295,8 +297,7 @@ SocketNamespace.prototype.handlePacket = function (sessid, packet) {
       if (packet.endpoint == '') {
         connect();
       } else {
-        var manager = this.manager
-          , handshakeData = manager.handshaken[sessid];
+        var handshakeData = manager.handshaken[sessid];
 
         this.authorize(handshakeData, function (err, authorized, newData) {
           if (err) return error(err);
@@ -321,12 +322,18 @@ SocketNamespace.prototype.handlePacket = function (sessid, packet) {
       break;
 
     case 'event':
-      var params = [packet.name].concat(packet.args);
+      // check if the emitted event is not blacklisted
+      if (-~manager.get('blacklist').indexOf(packet.name)) {
+        this.log.debug('ignoring blacklisted event `' + packet.name + '`');
+      } else {
+        var params = [packet.name].concat(packet.args);
 
-      if (dataAck)
-        params.push(ack);
+        if (dataAck) {
+          params.push(ack);
+        }
 
-      socket.$emit.apply(socket, params);
+        socket.$emit.apply(socket, params);
+      }
       break;
 
     case 'disconnect':

lib/parser.js

@@ -13,35 +13,38 @@
  * Packet types.
  */
 
-var packets = exports.packets = [
-    'disconnect'
-  , 'connect'
-  , 'heartbeat'
-  , 'message'
-  , 'json'
-  , 'event'
-  , 'ack'
-  , 'error'
-  , 'noop'
-];
+var packets = exports.packets = {
+      'disconnect': 0
+    , 'connect': 1
+    , 'heartbeat': 2
+    , 'message': 3
+    , 'json': 4
+    , 'event': 5
+    , 'ack': 6
+    , 'error': 7
+    , 'noop': 8
+  }
+  , packetslist = Object.keys(packets);
 
 /**
  * Errors reasons.
  */
 
-var reasons = exports.reasons = [
-    'transport not supported'
-  , 'client not handshaken'
-  , 'unauthorized'
-];
+var reasons = exports.reasons = {
+      'transport not supported': 0
+    , 'client not handshaken': 1
+    , 'unauthorized': 2
+  }
+  , reasonslist = Object.keys(reasons);
 
 /**
  * Errors advice.
  */
 
-var advice = exports.advice = [
-    'reconnect'
-];
+var advice = exports.advice = {
+      'reconnect': 0
+  }
+  , advicelist = Object.keys(advice);
 
 /**
  * Encodes a packet.
@@ -50,22 +53,13 @@ var advice = exports.advice = [
  */
 
 exports.encodePacket = function (packet) {
-  var type = packets.indexOf(packet.type)
+  var type = packets[packet.type]
     , id = packet.id || ''
     , endpoint = packet.endpoint || ''
     , ack = packet.ack
     , data = null;
 
   switch (packet.type) {
-    case 'error':
-      var reason = packet.reason ? reasons.indexOf(packet.reason) : ''
-        , adv = packet.advice ? advice.indexOf(packet.advice) : ''
-
-      if (reason !== '' || adv !== '')
-        data = reason + (adv !== '' ? ('+' + adv) : '')
-
-      break;
-
     case 'message':
       if (packet.data !== '')
         data = packet.data;
@@ -85,30 +79,35 @@ exports.encodePacket = function (packet) {
       data = JSON.stringify(packet.data);
       break;
 
-    case 'connect':
-      if (packet.qs)
-        data = packet.qs;
-      break;
-
     case 'ack':
       data = packet.ackId
         + (packet.args && packet.args.length
             ? '+' + JSON.stringify(packet.args) : '');
       break;
+
+    case 'connect':
+      if (packet.qs)
+        data = packet.qs;
+      break;
+
+     case 'error':
+      var reason = packet.reason ? reasons[packet.reason] : ''
+        , adv = packet.advice ? advice[packet.advice] : ''
+
+      if (reason !== '' || adv !== '')
+        data = reason + (adv !== '' ? ('+' + adv) : '')
+
+      break;
   }
 
   // construct packet with required fragments
-  var encoded = [
-      type
-    , id + (ack == 'data' ? '+' : '')
-    , endpoint
-  ];
+  var encoded = type + ':' + id + (ack == 'data' ? '+' : '') + ':' + endpoint;
 
   // data fragment is optional
   if (data !== null && data !== undefined)
-    encoded.push(data);
+    encoded += ':' + data;
 
-  return encoded.join(':');
+  return encoded;
 };
 
 /**
@@ -138,7 +137,19 @@ exports.encodePayload = function (packets) {
  * @api private
  */
 
-var regexp = /^([^:]+):([0-9]+)?(\+)?:([^:]+)?:?(.*)?$/;
+var regexp = /([^:]+):([0-9]+)?(\+)?:([^:]+)?:?([\s\S]*)?/;
+
+/**
+ * Wrap the JSON.parse in a seperate function the crankshaft optimizer will
+ * only punish this function for the usage for try catch
+ *
+ * @api private
+ */
+
+function parse (data) {
+  try { return JSON.parse(data) }
+  catch (e) { return false }
+}
 
 exports.decodePacket = function (data) {
   var pieces = data.match(regexp);
@@ -148,7 +159,7 @@ exports.decodePacket = function (data) {
   var id = pieces[2] || ''
     , data = pieces[5] || ''
     , packet = {
-          type: packets[pieces[1]]
+          type: packetslist[pieces[1]]
         , endpoint: pieces[4] || ''
       };
 
@@ -163,30 +174,22 @@ exports.decodePacket = function (data) {
 
   // handle different packet types
   switch (packet.type) {
-    case 'error':
-      var pieces = data.split('+');
-      packet.reason = reasons[pieces[0]] || '';
-      packet.advice = advice[pieces[1]] || '';
-      break;
-
     case 'message':
       packet.data = data || '';
       break;
 
     case 'event':
-      try {
-        var opts = JSON.parse(data);
-        packet.name = opts.name;
-        packet.args = opts.args;
-      } catch (e) { }
+      pieces = parse(data);
+      if (pieces) {
+        packet.name = pieces.name;
+        packet.args = pieces.args;
+      }
 
       packet.args = packet.args || [];
       break;
 
     case 'json':
-      try {
-        packet.data = JSON.parse(data);
-      } catch (e) { }
+      packet.data = parse(data);
       break;
 
     case 'connect':
@@ -194,23 +197,22 @@ exports.decodePacket = function (data) {
       break;
 
     case 'ack':
-      var pieces = data.match(/^([0-9]+)(\+)?(.*)/);
+      pieces = data.match(/^([0-9]+)(\+)?(.*)/);
       if (pieces) {
         packet.ackId = pieces[1];
         packet.args = [];
 
         if (pieces[3]) {
-          try {
-            packet.args = pieces[3] ? JSON.parse(pieces[3]) : [];
-          } catch (e) { }
+          packet.args = parse(pieces[3]) || [];
         }
       }
       break;
 
-    case 'disconnect':
-    case 'heartbeat':
-      break;
-  };
+    case 'error':
+      pieces = data.split('+');
+      packet.reason = reasonslist[pieces[0]] || '';
+      packet.advice = advicelist[pieces[1]] || '';
+  }
 
   return packet;
 };
@@ -223,12 +225,16 @@ exports.decodePacket = function (data) {
  */
 
 exports.decodePayload = function (data) {
+  if (undefined == data || null == data) {
+    return [];
+  }
+
   if (data[0] == '\ufffd') {
     var ret = [];
 
     for (var i = 1, length = ''; i < data.length; i++) {
       if (data[i] == '\ufffd') {
-        ret.push(exports.decodePacket(data.substr(i + 1).substr(0, length)));
+        ret.push(exports.decodePacket(data.substr(i + 1, length)));
         i += Number(length) + 1;
         length = '';
       } else {

lib/socket.io.js

@@ -15,7 +15,7 @@ var client = require('socket.io-client');
  * Version.
  */
 
-exports.version = '0.7.7';
+exports.version = '0.9.4';
 
 /**
  * Supported protocol version.
@@ -32,6 +32,9 @@ exports.clientVersion = client.version;
 /**
  * Attaches a manager
  *
+ * @param {HTTPServer/Number} a HTTP/S server or a port number to listen on.
+ * @param {Object} opts to be passed to Manager and/or http server
+ * @param {Function} callback if a port is supplied
  * @api public
  */
 
@@ -65,7 +68,7 @@ exports.listen = function (server, options, fn) {
   }
 
   // otherwise assume a http/s server
-  return new exports.Manager(server);
+  return new exports.Manager(server, options);
 };
 
 /**
@@ -92,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.
  *
@@ -106,7 +123,7 @@ Socket.prototype.__defineGetter__('broadcast', function () {
  * @api public
  */
 
-Socket.prototype.to = function (room) {
+Socket.prototype.to = Socket.prototype.in = function (room) {
   this.flags.room = room;
   return this;
 };
@@ -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
  */
@@ -274,12 +291,19 @@ Socket.prototype.disconnect = function () {
   if (!this.disconnected) {
     this.log.info('booting client');
 
-    if (this.manager.transports[this.id] && this.manager.transports[this.id].open) {
-      this.manager.transports[this.id].onForcedDisconnect();
+    if ('' === this.namespace.name) {
+      if (this.manager.transports[this.id] && this.manager.transports[this.id].open) {
+        this.manager.transports[this.id].onForcedDisconnect();
+      } else {
+        this.manager.onClientDisconnect(this.id);
+        this.manager.store.publish('disconnect:' + this.id);
+      }
     } else {
-      this.manager.onClientDisconnect(this.id);
-      this.manager.store.publish('disconnect:' + this.id);
+      this.packet({type: 'disconnect'});
+      this.manager.onLeave(this.id, this.namespace.name);
+      this.$emit('disconnect', 'booted');
     }
+
   }
 
   return this;

lib/static.js

@@ -0,0 +1,395 @@
+
+/*!
+* 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\-]+)*(?:\.v\d+\.\d+\.\d+)?(?:\.js)$/
+  , versioning = /\.v\d+\.\d+\.\d+(?:\.js)$/;
+
+/**
+ * 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);
+  });
+
+  this.add('/socket.io.v', { mime: mime.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 = path.match(bundle)
+      , 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);
+
+      // only write content if it's not a HEAD request and we actually have
+      // some content to write (304's doesn't have content).
+      res.end(
+          req.method !== 'HEAD' && content ? 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
+      , versioned = reply.versioned
+      , headers = {
+          'Content-Type': mime.type
+      };
+
+    // check if we can add a etag
+    if (self.manager.enabled('browser client etag') && reply.etag && !versioned) {
+      headers['Etag'] = reply.etag;
+    }
+
+    // see if we need to set Expire headers because the path is versioned
+    if (versioned) {
+      var expires = self.manager.get('browser client expires');
+      headers['Cache-Control'] = 'private, x-gzip-ok="", max-age=' + expires;
+      headers['Date'] = new Date().toUTCString();
+      headers['Expires'] = new Date(Date.now() + (expires * 1000)).toUTCString();
+    }
+
+    if (gzip && reply.gzip) {
+      headers['Content-Length'] = reply.gzip.length;
+      headers['Content-Encoding'] = 'gzip';
+      headers['Vary'] = 'Accept-Encoding';
+      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
+          , versioned: versioning.test(path)
+        };
+
+      // 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

@@ -11,8 +11,7 @@
 
 var crypto = require('crypto')
   , Store = require('../store')
-  , assert = require('assert')
-  , redis = require('redis');
+  , assert = require('assert');
 
 /**
  * Exports the constructor.
@@ -25,6 +24,7 @@ Redis.Client = Client;
  * Redis store.
  * Options:
  *     - nodeId (fn) gets an id that uniquely identifies this node
+ *     - redis (fn) redis constructor, defaults to redis
  *     - redisPub (object) options to pass to the pub redis client
  *     - redisSub (object) options to pass to the sub redis client
  *     - redisClient (object) options to pass to the general redis client
@@ -60,12 +60,33 @@ function Redis (opts) {
     }
   }
 
+  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);
+
+  this.sub.setMaxListeners(0);
+  this.setMaxListeners(0);
 };
 
 /**
@@ -116,7 +137,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/transport.js

@@ -259,7 +259,7 @@ Transport.prototype.clearCloseTimeout = function () {
  */
 
 Transport.prototype.setHeartbeatTimeout = function () {
-  if (!this.heartbeatTimeout) {
+  if (!this.heartbeatTimeout && this.manager.enabled('heartbeats')) {
     var self = this;
 
     this.heartbeatTimeout = setTimeout(function () {
@@ -279,7 +279,7 @@ Transport.prototype.setHeartbeatTimeout = function () {
  */
 
 Transport.prototype.clearHeartbeatTimeout = function () {
-  if (this.heartbeatTimeout) {
+  if (this.heartbeatTimeout && this.manager.enabled('heartbeats')) {
     clearTimeout(this.heartbeatTimeout);
     this.heartbeatTimeout = null;
     this.log.debug('cleared heartbeat timeout for client', this.id);
@@ -294,7 +294,7 @@ Transport.prototype.clearHeartbeatTimeout = function () {
  */
 
 Transport.prototype.setHeartbeatInterval = function () {
-  if (!this.heartbeatInterval) {
+  if (!this.heartbeatInterval && this.manager.enabled('heartbeats')) {
     var self = this;
 
     this.heartbeatInterval = setTimeout(function () {
@@ -398,7 +398,7 @@ Transport.prototype.onMessage = function (packet) {
  */
 
 Transport.prototype.clearHeartbeatInterval = function () {
-  if (this.heartbeatInterval) {
+  if (this.heartbeatInterval && this.manager.enabled('heartbeats')) {
     clearTimeout(this.heartbeatInterval);
     this.heartbeatInterval = null;
     this.log.debug('cleared heartbeat interval for client', this.id);

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);
 }
 
 /**
@@ -49,9 +49,9 @@ FlashSocket.prototype.name = 'flashsocket';
  * @api private
  */
 
-var server;
 
 FlashSocket.init = function (manager) {
+  var server;
   function create () {
     server = require('policyfile').createServer({ 
       log: function(msg){
@@ -80,10 +80,15 @@ FlashSocket.init = function (manager) {
   // destory the server and create a new server
   manager.on('set:flash policy port', function (value, key) {
     var transports = manager.get('transports');
-
-    if (server && server.port !== value && ~transports.indexOf('flashsocket')) {
-      // destroy the server and rebuild it on a new port
-      server.close();
+    if (~transports.indexOf('flashsocket')) {
+      if (server) {
+        if (server.port === value) return;
+        // destroy the server and rebuild it on a new port
+        try {
+          server.close();
+        }
+        catch (e) { /* ignore exception. could e.g. be that the server isn't started yet */ }
+      }
       create();
     }
   });
@@ -94,7 +99,6 @@ FlashSocket.init = function (manager) {
       create();
     }
   });
-
   // check if we need to initialize at start
   if (~manager.get('transports').indexOf('flashsocket')){
     create();

lib/transports/htmlfile.js

@@ -52,7 +52,7 @@ HTMLFile.prototype.handleRequest = function (req) {
 
   if (req.method == 'GET') {
     req.res.writeHead(200, {
-        'Content-Type': 'text/html'
+        'Content-Type': 'text/html; charset=UTF-8'
       , 'Connection': 'keep-alive'
       , 'Transfer-Encoding': 'chunked'
     });

lib/transports/http.js

@@ -46,28 +46,35 @@ HTTPTransport.prototype.handleRequest = function (req) {
     var buffer = ''
       , res = req.res
       , origin = req.headers.origin
-      , headers = { 'Content-Length': 1 }
+      , headers = { 'Content-Length': 1, 'Content-Type': 'text/plain; charset=UTF-8' }
       , self = this;
 
     req.on('data', function (data) {
       buffer += data;
+
+      if (Buffer.byteLength(buffer) >= self.manager.get('destroy buffer size')) {
+        buffer = '';
+        req.connection.destroy();
+      }
     });
 
     req.on('end', function () {
+      res.writeHead(200, headers);
+      res.end('1');
+
       self.onData(self.postEncoded ? qs.parse(buffer).d : buffer);
     });
 
+    // prevent memory leaks for uncompleted requests
+    req.on('close', function () {
+      buffer = '';
+    });
+
     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';
-      }
+      headers['Access-Control-Allow-Origin'] = origin;
+      headers['Access-Control-Allow-Credentials'] = 'true';
     }
-
-    res.writeHead(200, headers);
-    res.end('1');
   } else {
     this.response = req.res;
 
@@ -83,9 +90,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/jsonp-polling.js

@@ -54,6 +54,24 @@ JSONPPolling.prototype.name = 'jsonppolling';
 
 JSONPPolling.prototype.postEncoded = true;
 
+/**
+ * Handles incoming data.
+ * Due to a bug in \n handling by browsers, we expect a JSONified string.
+ *
+ * @api private
+ */
+
+JSONPPolling.prototype.onData = function (data) {
+  try {
+    data = JSON.parse(data);
+  } catch (e) {
+    this.error('parse', 'reconnect');
+    return;
+  }
+
+  HTTPPolling.prototype.onData.call(this, data);
+};
+
 /**
  * Performs the write.
  *
@@ -70,6 +88,7 @@ JSONPPolling.prototype.doWrite = function (data) {
       'Content-Type': 'text/javascript; charset=UTF-8'
     , 'Content-Length': Buffer.byteLength(data)
     , 'Connection': 'Keep-Alive'
+    , 'X-XSS-Protection': '0'
   });
 
   this.response.write(data);

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,360 @@
+
+/*!
+ * 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.manager.settings['match origin protocol'] ?
+                      origin.match(/^https/) : 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,622 @@
+
+/*!
+ * 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
+    try {
+      self.socket.write('\u008a\u0000');
+    }
+    catch (e) {
+      self.end();
+      return;
+    }
+  });
+  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 (typeof this.req.headers.upgrade === 'undefined' || 
+      this.req.headers.upgrade.toLowerCase() !== 'websocket') {
+    this.log.warn(this.name + ' connection invalid');
+    this.end();
+    return;
+  }
+
+  var origin = this.req.headers['sec-websocket-origin']
+    , location = ((this.manager.settings['match origin protocol'] ?
+                      origin.match(/^https/) : 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);
+      parts.port = parts.port || 80;
+      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);
+    try {
+      this.socket.write(buf, 'binary');
+    }
+    catch (e) {
+      this.end();
+      return;
+    }
+    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,623 @@
+
+/*!
+ * 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
+    try {
+      self.socket.write('\u008a\u0000');
+    }
+    catch (e) {
+      self.end();
+      return;
+    }
+  });
+  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 (typeof this.req.headers.upgrade === 'undefined' || 
+      this.req.headers.upgrade.toLowerCase() !== 'websocket') {
+    this.log.warn(this.name + ' connection invalid');
+    this.end();
+    return;
+  }
+
+  var origin = this.req.headers['origin']
+    , location = ((this.manager.settings['match origin protocol'] ?
+                      origin.match(/^https/) : 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);
+      parts.port = parts.port || 80;
+      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);
+    try {
+      this.socket.write(buf, 'binary');
+    }
+    catch (e) {
+      this.end();
+      return;
+    }
+    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');
+    return;
+  } 
+  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/transports/xhr-polling.js

@@ -59,11 +59,8 @@ XHRPolling.prototype.doWrite = function (data) {
 
   if (origin) {
     // https://developer.mozilla.org/En/HTTP_Access_Control
-    headers['Access-Control-Allow-Origin'] = '*';
-
-    if (this.req.headers.cookie) {
-      headers['Access-Control-Allow-Credentials'] = 'true';
-    }
+    headers['Access-Control-Allow-Origin'] = origin;
+    headers['Access-Control-Allow-Credentials'] = 'true';
   }
 
   this.response.writeHead(200, headers);

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.7"
+  , "version": "0.9.4"
   , "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,20 +9,27 @@
         { "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.4"
-      , "policyfile": "0.0.3"
-      , "redis": "0.6.0"
+        "socket.io-client": "0.9.4"
+      , "policyfile": "0.0.4"
+      , "redis": "0.6.7"
     }
   , "devDependencies": {
-        "expresso": "0.7.7"
+        "expresso": "0.9.2"
       , "should": "0.0.4"
+      , "benchmark": "0.2.2"
+      , "microtime": "0.1.3-1"
+      , "colors": "0.5.1"
     }
   , "main": "index"
   , "engines": { "node": ">= 0.4.0" }
+  , "scripts": {
+        "test": "make test"
+    }
 }

support/node-websocket-client/lib/websocket.js

@@ -5,7 +5,7 @@ var events = require('events');
 var http = require('http');
 var net = require('net');
 var urllib = require('url');
-var sys = require('sys');
+var sys = require('util');
 
 var FRAME_NO = 0;
 var FRAME_LO = 1;
@@ -347,7 +347,6 @@ var WebSocket = function(url, proto, opts) {
     // that we've closed.
     var finishClose = self.finishClose = function() {
         readyState = CLOSED;
-
         if (stream) {
             stream.end();
             stream.destroy();
@@ -469,31 +468,54 @@ var WebSocket = function(url, proto, opts) {
         //      that http.Client passes its constructor arguments through,
         //      un-inspected to net.Stream.connect(). The latter accepts a
         //      string as its first argument to connect to a UNIX socket.
-        var httpClient = undefined;
+        var opt = {};
+        var agent = null;
         switch (getUrlScheme(url)) {
         case 'ws':
             var u = urllib.parse(url);
-            httpClient = http.createClient(u.port || 80, u.hostname);
-            httpPath = (u.pathname || '/') + (u.search || '');
-            httpHeaders.Host = u.hostname + (u.port ? (":" + u.port) : "");
+            agent = new http.Agent({
+                host: u.hostname,
+                port: u.port || 80
+            });
+            opt.agent = agent;
+            opt.host = u.hostname;
+            opt.port = u.port || 80;
+            opt.path = (u.pathname || '/') + (u.search || '');
+            opt.headers = httpHeaders;
             break;
 
         case 'ws+unix':
             var sockPath = url.substring('ws+unix://'.length, url.length);
-            httpClient = http.createClient(sockPath);
-            httpHeaders.Host = 'localhost';
+            var u = urllib.parse(url);
+            agent = new http.Agent({
+                host: 'localhost',
+                port: sockPath
+            });
+            opt.agent = agent;
+            opt.host = 'localhost';
+            opt.path = sockPath;
+            opt.headers = httpHeaders;
             break;
 
         default:
             throw new Error('Invalid URL scheme \'' + urlScheme + '\' specified.');
         }
 
-        httpClient.on('upgrade', (function() {
+        var httpReq = http.request(opt, function() { });
+        var upgradeHandler = (function() {
             var data = undefined;
 
             return function(req, s, head) {
+                req.socket.setNoDelay(true);
                 stream = s;
 
+                if (readyState == CLOSED) {
+                    stream.end();
+                    stream.destroy();
+                    stream = undefined;
+                    return;
+                }
+
                 stream.on('data', function(d) {
                     if (d.length <= 0) {
                         return;
@@ -547,7 +569,7 @@ var WebSocket = function(url, proto, opts) {
                         //
                         // XXX: This is lame. We should only remove the listeners
                         //      that we added.
-                        httpClient.removeAllListeners('upgrade');
+                        httpReq.removeAllListeners('upgrade');
                         stream.removeAllListeners('data');
                         stream.on('data', dataListener);
 
@@ -575,13 +597,9 @@ var WebSocket = function(url, proto, opts) {
 
                 stream.emit('data', head);
             };
-        })());
-        httpClient.on('error', function(e) {
-            httpClient.end();
-            errorListener(e);
-        });
-
-        var httpReq = httpClient.request(httpPath, httpHeaders);
+        })();
+        agent.on('upgrade', upgradeHandler); // node v0.4
+        httpReq.on('upgrade', upgradeHandler); // node v0.5+
 
         httpReq.write(challenge, 'binary');
         httpReq.end();

test/common.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var io = require('socket.io')
+var io = require('../')
   , parser = io.parser
   , http = require('http')
   , https = require('https')
@@ -91,8 +91,21 @@ HTTPClient.prototype.request = function (path, opts, fn) {
  */
 
 HTTPClient.prototype.end = function () {
-  this.agent.sockets.forEach(function (socket) {
-    socket.end();
+  // node <v0.5 compat
+  if (this.agent.sockets.forEach) {
+      this.agent.sockets.forEach(function (socket) {
+        if (socket.end) socket.end();
+      });
+      return;
+  }
+  // node >=v0.5 compat
+  var self = this;
+  Object.keys(this.agent.sockets).forEach(function (socket) {
+    for (var i = 0, l = self.agent.sockets[socket].length; i < l; ++i) {
+      if (self.agent.sockets[socket][i]._handle) {
+        self.agent.sockets[socket][i]._handle.socket.end();
+      }
+    }
   });
 };
 
@@ -147,6 +160,24 @@ HTTPClient.prototype.post = function (path, data, opts, fn) {
   return this.request(path, opts, fn);
 };
 
+/**
+ * Issue a HEAD request
+ *
+ * @api private
+ */
+
+HTTPClient.prototype.head = function (path, opts, fn) {
+  if ('function' == typeof opts) {
+    fn = opts;
+    opts = {};
+  }
+
+  opts = opts || {};
+  opts.method = 'HEAD';
+
+  return this.request(path, opts, fn);
+};
+
 /**
  * Performs a handshake (GET) request
  *
@@ -179,7 +210,6 @@ client = function (port) {
  */
 
 create = function (cl) {
-  console.log('');
   var manager = io.listen(cl.port);
   manager.set('client store expiration', 0);
   return manager;
@@ -191,14 +221,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
+    , 'ws://localhost:' + port + '/socket.io/'
+        + io.protocol + '/' + this.transportName + '/' + sid
   );
 };
 
@@ -239,6 +269,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/io.test.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , fs = require('fs')
   , http = require('http')
   , https = require('https')
@@ -116,10 +116,10 @@ module.exports = {
         io.server.close();
         done();
       });
+      done();
     } catch (e) {
       e.should.match(/EACCES/);
       done();
     }
   }
-
 };

test/leaks/socket.leaktest.js

@@ -0,0 +1,54 @@
+/*!
+ * socket.io-node
+ * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Test dependencies.
+ */
+
+require.paths.unshift(__dirname + '/../../lib');
+
+var assertvanish = require('assertvanish')
+  , common = require('../common')
+  , ports = 15800;
+
+function resultCallback (leaks, leakedSocket) {
+  if (leaks) {
+    console.error('Leak detected');
+    process.exit(1);
+  } else {
+    console.error('No leaks');
+    process.exit(0);
+  }
+};
+
+/**
+ * Test.
+ */
+
+var cl = client(++ports);
+var io = create(cl);
+
+io.sockets.on('connection', function (socket) {
+  console.log('connected');
+  
+  socket.on('disconnect', function() {
+    console.log("client gone");
+    setTimeout(gc, 1000);
+    assertvanish(socket, 2000, {silent: true, callback: resultCallback});
+  });
+});
+
+setTimeout(function() {
+  cl.handshake(function (sid) {
+    var ws = websocket(cl, sid);
+    ws.on('open', function () {
+      console.log('open!');
+      setTimeout(function() {
+        ws.close();
+      }, 500);
+    });
+  });
+}, 100);

test/manager.test.js

@@ -1,4 +1,3 @@
-
 /*!
  * socket.io-node
  * Copyright(c) 2011 LearnBoost <dev@learnboost.com>
@@ -9,7 +8,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , http = require('http')
   , should = require('./common')
   , ports = 15100;
@@ -21,6 +20,22 @@ var sio = require('socket.io')
 module.exports = {
 
   'test setting and getting a configuration flag': function (done) {
+    var port = ++ports
+      , io = sio.listen(http.createServer());
+
+    io.set('a', 'b');
+    io.get('a').should.eql('b');
+
+    var port = ++ports
+      , io = sio.listen(http.createServer());
+
+    io.configure(function () {
+      io.set('a', 'b');
+      io.enable('tobi');
+    });
+
+    io.get('a').should.eql('b');
+
     done();
   },
 
@@ -37,11 +52,9 @@ module.exports = {
       , io = sio.listen(http.createServer());
 
     io.configure(function () {
-      io.set('a', 'b');
       io.enable('tobi');
     });
 
-    io.get('a').should.eql('b');
     io.enabled('tobi').should.be.true;
 
     done();
@@ -104,6 +117,7 @@ module.exports = {
     io.disable('foo');
 
     calls.should.eql(3);
+
     done();
   },
 
@@ -134,236 +148,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)
@@ -459,6 +243,128 @@ 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 a referer with implicit port 80 is accepted for foo.bar.com:80 origin': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.configure(function () {
+      io.set('origins', 'foo.bar.com:80');
+    });
+
+    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('http://example.org:1337');
+      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)
@@ -534,6 +440,150 @@ module.exports = {
       io.server.close();
       done();
     });
-  }
+  },
 
+  'test disabling heartbeats': function (done) {
+    var port = ++ports
+      , cl = client(port)
+      , io = create(cl)
+      , messages = 0
+      , beat = false
+      , ws;
+
+    io.configure(function () {
+      io.disable('heartbeats');
+      io.set('heartbeat interval', .05);
+      io.set('heartbeat timeout', .05);
+      io.set('close timeout', .05);
+    });
+
+    io.sockets.on('connection', function (socket) {
+      setTimeout(function () {
+        socket.disconnect();
+      }, io.get('heartbeat timeout') * 1000 + 100);
+
+      socket.on('disconnect', function (reason) {
+        beat.should.be.false;
+        ws.finishClose();
+        cl.end();
+        io.server.close();
+        done();
+      });
+    });
+
+    cl.get('/socket.io/{protocol}/', function (res, data) {
+      res.statusCode.should.eql(200);
+      data.should.match(/([^:]+)::[\.0-9]+:(.*)/);
+
+      cl.handshake(function (sid) {
+        ws = websocket(cl, sid);
+        ws.on('message', function (packet) {
+          if (++messages == 1) {
+            packet.type.should.eql('connect');
+          } else if (packet.type == 'heartbeat'){
+            beat = true;
+          }
+        });
+      });
+    });
+  },
+
+  'no duplicate room members': function (done) {
+    var port = ++ports
+      , io = sio.listen(port);
+
+    Object.keys(io.rooms).length.should.equal(0);
+
+    io.onJoin(123, 'foo');
+    io.rooms.foo.length.should.equal(1);
+
+    io.onJoin(123, 'foo');
+    io.rooms.foo.length.should.equal(1);
+
+    io.onJoin(124, 'foo');
+    io.rooms.foo.length.should.equal(2);
+
+    io.onJoin(124, 'foo');
+    io.rooms.foo.length.should.equal(2);
+
+    io.onJoin(123, 'bar');
+    io.rooms.foo.length.should.equal(2);
+    io.rooms.bar.length.should.equal(1);
+
+    io.onJoin(123, 'bar');
+    io.rooms.foo.length.should.equal(2);
+    io.rooms.bar.length.should.equal(1);
+
+    io.onJoin(124, 'bar');
+    io.rooms.foo.length.should.equal(2);
+    io.rooms.bar.length.should.equal(2);
+
+    io.onJoin(124, 'bar');
+    io.rooms.foo.length.should.equal(2);
+    io.rooms.bar.length.should.equal(2);
+
+    process.nextTick(function() {
+      io.server.close();
+      done();
+    });
+  },
+
+  'test passing options directly to the Manager through listen': function (done) {
+    var port = ++ports
+      , io = sio.listen(port, { resource: '/my resource', custom: 'opt' });
+
+    io.get('resource').should.equal('/my resource');
+    io.get('custom').should.equal('opt');
+    process.nextTick(function() {
+      io.server.close();
+      done();
+    });
+  },
+
+  'test disabling the log': function (done) {
+    var port = ++ports
+      , io = sio.listen(port, { log: false })
+      , _console = console.log
+      , calls = 0;
+
+    // the logger uses console.log to output data, override it to see if get's
+    // used
+    console.log = function () { ++calls };
+
+    io.log.debug('test');
+    io.log.log('testing');
+
+    console.log = _console;
+    calls.should.equal(0);
+
+    process.nextTick(function() {
+      io.server.close();
+      done();
+    });
+  },
+
+  'test disabling logging with colors': function (done) {
+     var port = ++ports
+      , io = sio.listen(port, { 'log colors': false })
+      , _console = console.log
+      , calls = 0;
+
+    // the logger uses console.log to output data, override it to see if get's
+    // used
+    console.log = function (data) {
+      ++calls;
+      data.indexOf('\033').should.equal(-1);
+    };
+
+    io.log.debug('test');
+    io.log.log('testing');
+
+    console.log = _console;
+    calls.should.equal(2);
+
+    process.nextTick(function() {
+      io.server.close();
+      done();
+    });
+  }
 };

test/namespace.test.js

@@ -131,7 +131,7 @@ module.exports = {
         if (data.endpoint == '/a') {
           data.type.should.eql('error');
           data.reason.should.eql('unauthorized')
-          
+
           cl.end();
           ws.finishClose();
           io.server.close()
@@ -154,6 +154,9 @@ module.exports = {
 
     io.of('a')
       .on('connection', function (socket){
+        if (connect < 2) {
+          return;
+        }
         socket.broadcast.emit('b', 'test');
         socket.broadcast.json.emit('json', {foo:'bar'});
         socket.broadcast.send('foo');
@@ -163,7 +166,6 @@ module.exports = {
       connect.should.equal(2);
       message.should.equal(1);
       events.should.equal(2);
-
       cl.end();
       ws1.finishClose();
       ws2.finishClose();
@@ -173,16 +175,19 @@ module.exports = {
 
     cl.handshake(function (sid) {
      ws1 = websocket(cl, sid);
-
-      ws1.on('open', function() {
-        ws1.packet({
-            type: 'connect'
-          , endpoint: 'a'
-        });
-      });
-
       ws1.on('message', function (data) {
         if (data.type === 'connect') {
+          if (connect == 0) {
+            cl.handshake(function (sid) {
+              ws2 = websocket(cl, sid);
+              ws2.on('open', function () {
+                ws2.packet({
+                    type: 'connect'
+                  , endpoint: 'a'
+                });
+              });
+            });
+          }
           ++connect;
           if (++calls === expected) finish();
         }
@@ -197,17 +202,12 @@ module.exports = {
           if (++calls === expected) finish();
         }
       });
-
-      cl.handshake(function (sid) {
-        ws2 = websocket(cl, sid);
-
-        ws2.on('open', function () {
-          ws2.packet({
-              type: 'connect'
-            , endpoint: 'a'
-          });
+      ws1.on('open', function() {
+        ws1.packet({
+            type: 'connect'
+          , endpoint: 'a'
         });
-      })
+      });
     })
   },
 
@@ -243,5 +243,85 @@ module.exports = {
         }
       });
     })
+  },
+
+  'ignoring blacklisted events': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , calls = 0
+      , ws;
+
+    io.set('heartbeat interval', 1);
+    io.set('blacklist', ['foobar']);
+
+    io.sockets.on('connection', function (socket) {
+      socket.on('foobar', function () {
+         calls++;
+      });
+    });
+
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid);
+
+      ws.on('open', function (){
+         ws.packet({
+            type: 'event'
+          , name: 'foobar'
+          , endpoint: ''
+        });
+      });
+
+      ws.on('message', function (data) {
+        if (data.type === 'heartbeat') {
+          cl.end();
+          ws.finishClose();
+          io.server.close();
+
+          calls.should.equal(0);
+          done();
+        }
+      });
+    });
+  },
+  'disconnecting from namespace only': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws1
+      , ws2;
+
+    io.of('/foo').on('connection', function (socket) {
+      socket.disconnect();
+    });
+
+    cl.handshake(function (sid) {
+      ws1 = websocket(cl, sid);
+      ws1.on('open', function () {
+        ws1.packet({
+            type: 'connect'
+          , endpoint: '/bar'
+        });
+        cl.handshake(function (sid) {
+          ws2 = websocket(cl, sid);
+          ws2.on('open', function () {
+            ws2.packet({
+                type: 'connect'
+              , endpoint: '/foo'
+            });
+          });
+          ws2.on('message', function (data) {
+            if ('disconnect' === data.type) {
+              cl.end();
+              ws1.finishClose();
+              ws2.finishClose();
+              io.server.close();
+
+              data.endpoint.should.eql('/foo');
+
+              done();
+            }
+          });
+        });
+      });
+    });
   }
 };

test/parser.test.js

@@ -3,7 +3,7 @@
  * Test dependencies.
  */
 
-var parser = require('socket.io').parser
+var parser = require('../').parser
   , decode = parser.decode
   , should = require('./common');
 
@@ -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/socket.js

@@ -1,15 +0,0 @@
-
-/**
- * Test dependencies.
- */
-
-var sio = require('socket.io')
-  , should = require('./common');
-
-/**
- * Test.
- */
-
-module.exports = {
-
-};

test/static.test.js

@@ -0,0 +1,549 @@
+
+/*!
+* socket.io-node
+* Copyright(c) 2011 LearnBoost <dev@learnboost.com>
+* MIT Licensed
+*/
+
+/**
+ * Test dependencies.
+ */
+
+var sio = require('../')
+  , 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.v1.0.0.js')).should.be.true;
+    (!!io.static.has('/socket.io+xhr-polling.js')).should.be.true;
+    (!!io.static.has('/socket.io+xhr-polling.v1.0.0.js')).should.be.true;
+    (!!io.static.has('/static/flashsocket/WebSocketMain.swf')).should.be.true;
+    (!!io.static.has('/static/flashsocket/WebSocketMainInsecure.swf')).should.be.true;
+
+    process.nextTick(function() {
+      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;
+
+    process.nextTick(function() {
+      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 that HEAD requests work': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    cl.head('/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.eql('');
+
+      cl.end();
+      io.server.close()
+      done();
+    });
+  },
+
+  'test that a versioned client is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    cl.get('/socket.io/socket.io.v0.8.9.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      res.headers['cache-control']
+        .indexOf(io.get('browser client expires')).should.be.above(-1);
+
+      data.should.match(/XMLHttpRequest/);
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+
+  'test that a custom versioned build client is served': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.set('browser client expires', 1337);
+
+    cl.get('/socket.io/socket.io+websocket.v0.8.10.js', function (res, data) {
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      res.headers['cache-control']
+        .indexOf(io.get('browser client expires')).should.be.above(-1);
+
+      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 etags are ignored for versioned requests': function (done) {
+    var port = ++ports
+      , io = sio.listen(port)
+      , cl = client(port);
+
+    io.enable('browser client etag');
+
+    cl.get('/socket.io/socket.io.v0.8.9.js', function (res, data) {
+      should.strictEqual(res.headers.etag, undefined);
+      res.headers['content-type'].should.eql('application/javascript');
+      res.headers['content-length'].should.match(/([0-9]+)/);
+      res.headers['cache-control']
+        .indexOf(io.get('browser client expires')).should.be.above(-1);
+
+      data.should.match(/XMLHttpRequest/);
+
+      cl.end();
+      io.server.close();
+      done();
+    });
+  },
+};

test/stores.memory.test.js

@@ -5,7 +5,7 @@
  * @api private
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , should = require('should')
   , MemoryStore = sio.MemoryStore;
 
@@ -45,7 +45,7 @@ module.exports = {
 
                 client.set('b', 'c', function (err) {
                   should.strictEqual(err, null);
-                  
+
                   client.set('c', 'd', function (err) {
                     should.strictEqual(err, null);
 

test/stores.redis.test.js

@@ -5,7 +5,7 @@
  * @api private
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , redis = require('redis')
   , should = require('should')
   , RedisStore = sio.RedisStore;
@@ -95,7 +95,7 @@ module.exports = {
 
                 client.set('b', 'c', function (err) {
                   should.strictEqual(err, null);
-                  
+
                   client.set('c', 'd', function (err) {
                     should.strictEqual(err, null);
 

test/transports.flashsocket.test.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , net = require('net')
   , http = require('http')
   , should = require('./common')
@@ -30,7 +30,7 @@ function FlashSocket (port, sid) {
 
   WebSocket.call(
       this
-    , 'ws://localhost:' + port + '/socket.io/' 
+    , 'ws://localhost:' + port + '/socket.io/'
         + sio.protocol + '/flashsocket/' + sid
   );
 };
@@ -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,25 @@ module.exports = {
 
     io.flashPolicyServer.close();
     done();
-  }
+  },
 
+  'flashsocket identifies as flashsocket': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws;
+
+    io.set('transports', ['flashsocket']);
+    io.sockets.on('connection', function (socket) {
+      socket.manager.transports[socket.id].name.should.equal('flashsocket');
+      ws.finishClose();
+      cl.end();
+      io.flashPolicyServer.close();
+      io.server.close();
+      done();
+    });
+
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid, 'flashsocket');
+    });
+  }
 };

test/transports.htmlfile.test.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , should = require('./common')
   , HTTPClient = should.HTTPClient
   , parser = sio.parser

test/transports.jsonp-polling.test.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , should = require('./common')
   , qs = require('querystring')
   , HTTPClient = should.HTTPClient
@@ -250,8 +250,7 @@ module.exports = {
     });
   },
 
-  'test the disconnection event when the client sends ?disconnect req':
-  function (done) {
+  'test the disconnection event when the client sends ?disconnect req': function (done) {
     var cl = client(++ports)
       , io = create(cl)
       , disconnected = false
@@ -279,12 +278,17 @@ module.exports = {
           msgs.should.have.length(1);
           msgs[0].should.eql({ type: 'disconnect', endpoint: '' });
           disconnected.should.be.true;
-          cl.end();
           io.server.close();
+          cl.end();
           done();
         });
 
-        cl.get('/socket.io/{protocol}/jsonp-polling/' + sid + '/?disconnect');
+        // with the new http bits in node 0.5, there's no guarantee that
+        // the previous request is actually dispatched (and received) before the following
+        // reset call is sent. to not waste more time on a workaround, a timeout is added.
+        setTimeout(function() {
+          cl.get('/socket.io/{protocol}/jsonp-polling/' + sid + '/?disconnect');
+        }, 500);
       });
     });
   },
@@ -323,7 +327,7 @@ module.exports = {
     io.sockets.on('connection', function (client) {
       cl.post(
           '/socket.io/{protocol}/jsonp-polling/' + sid
-        , parser.encodePacket({ type: 'disconnect' })
+        , JSON.stringify(parser.encodePacket({ type: 'disconnect' }))
         , function (res, data) {
             res.statusCode.should.eql(200);
             data.should.eql('1');
@@ -390,11 +394,11 @@ module.exports = {
 
       cl.post(
           '/socket.io/{protocol}/jsonp-polling/' + sid
-        , parser.encodePayload([
+        , JSON.stringify(parser.encodePayload([
               parser.encodePacket({ type: 'message', data: 'a' })
             , parser.encodePacket({ type: 'message', data: 'b' })
             , parser.encodePacket({ type: 'disconnect' })
-          ])
+          ]))
         , function (res, data) {
             res.statusCode.should.eql(200);
             data.should.eql('1');
@@ -504,7 +508,7 @@ module.exports = {
 
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'connect', endpoint: '/woot' })
+          , JSON.stringify(parser.encodePacket({ type: 'connect', endpoint: '/woot' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
@@ -585,21 +589,21 @@ module.exports = {
       cl.get('/socket.io/{protocol}/jsonp-polling/' + sid, function () {
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'connect', endpoint: '/woot' })
+          , JSON.stringify(parser.encodePacket({ type: 'connect', endpoint: '/woot' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
 
               cl.post(
                   '/socket.io/{protocol}/jsonp-polling/' + sid
-                , parser.encodePacket({ type: 'disconnect', endpoint: '/woot' })
+                , JSON.stringify(parser.encodePacket({ type: 'disconnect', endpoint: '/woot' }))
                 , function (res, data) {
                     res.statusCode.should.eql(200);
                     data.should.eql('1');
 
                     cl.post(
                         '/socket.io/{protocol}/jsonp-polling/' + sid
-                      , parser.encodePacket({ type: 'message', data: 'ferret' })
+                      , JSON.stringify(parser.encodePacket({ type: 'message', data: 'ferret' }))
                       , function (res, data) {
                           res.statusCode.should.eql(200);
                           data.should.eql('1');
@@ -656,7 +660,7 @@ module.exports = {
 
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'connect', endpoint: '/a' })
+          , JSON.stringify(parser.encodePacket({ type: 'connect', endpoint: '/a' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
@@ -665,7 +669,7 @@ module.exports = {
 
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'connect', endpoint: '/b' })
+          , JSON.stringify(parser.encodePacket({ type: 'connect', endpoint: '/b' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
@@ -721,7 +725,7 @@ module.exports = {
       cl.get('/socket.io/{protocol}/jsonp-polling/' + sid, function (res, data) {
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'message', data: '' })
+          , JSON.stringify(parser.encodePacket({ type: 'message', data: '' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
@@ -730,14 +734,14 @@ module.exports = {
 
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'connect', endpoint: '/a' })
+          , JSON.stringify(parser.encodePacket({ type: 'connect', endpoint: '/a' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
 
               cl.post(
                   '/socket.io/{protocol}/jsonp-polling/' + sid
-                , parser.encodePacket({ type: 'message', endpoint: '/a', data: 'a' })
+                , JSON.stringify(parser.encodePacket({ type: 'message', endpoint: '/a', data: 'a' }))
                 , function (res, data) {
                     res.statusCode.should.eql(200);
                     data.should.eql('1');
@@ -748,14 +752,14 @@ module.exports = {
 
         cl.post(
             '/socket.io/{protocol}/jsonp-polling/' + sid
-          , parser.encodePacket({ type: 'connect', endpoint: '/b' })
+          , JSON.stringify(parser.encodePacket({ type: 'connect', endpoint: '/b' }))
           , function (res, data) {
               res.statusCode.should.eql(200);
               data.should.eql('1');
 
               cl.post(
                   '/socket.io/{protocol}/jsonp-polling/' + sid
-                , parser.encodePacket({ type: 'message', endpoint: '/b', data: 'b' })
+                , JSON.stringify(parser.encodePacket({ type: 'message', endpoint: '/b', data: 'b' }))
                 , function (res, data) {
                     res.statusCode.should.eql(200);
                     data.should.eql('1');

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.websocket.test.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , should = require('./common')
   , parser = sio.parser
   , ports = 15800;
@@ -19,6 +19,226 @@ var sio = require('socket.io')
  */
 
 module.exports = {
+  'websocket identifies as websocket': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws;
+
+    io.set('transports', ['websocket']);
+    io.on('connection', function (socket) {
+      socket.manager.transports[socket.id].name.should.equal('websocket');
+      ws.finishClose();
+      cl.end();
+      io.server.close();
+      done();
+    });
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid);
+    });
+  },
+
+  'default websocket draft parser is used for unknown sec-websocket-version': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws;
+
+    io.set('transports', ['websocket']);
+    io.sockets.on('connection', function (socket) {
+      socket.manager.transports[socket.id].protocolVersion.should.equal('hixie-76');
+      ws.finishClose();
+      cl.end();
+      io.server.close();
+      done();
+    });
+
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid);
+    });
+  },
+
+  'hybi-07-12 websocket draft parser is used for sec-websocket-version: 8': function (done) {
+    var cl = client(++ports)
+      , io = create(cl);
+
+    io.set('transports', ['websocket']);
+    io.sockets.on('connection', function (socket) {
+      socket.manager.transports[socket.id].protocolVersion.should.equal('07-12');
+      cl.end();
+      io.server.close();
+      done();
+    });
+
+    var headers = {
+      'sec-websocket-version': 8,
+      'upgrade': 'websocket',
+      'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ=='
+    }
+
+    cl.get('/socket.io/{protocol}', {}, function (res, data) {
+      var sid = data.split(':')[0];
+      var url = '/socket.io/' + sio.protocol + '/websocket/' + sid;
+      cl.get(url, {headers: headers}, function (res, data) {});
+    });
+  },
+
+  'hybi-16 websocket draft parser is used for sec-websocket-version: 13': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+
+    io.set('transports', ['websocket']);
+
+    io.sockets.on('connection', function (socket) {
+      socket.manager.transports[socket.id].protocolVersion.should.equal('16');
+      cl.end();
+      io.server.close();
+      done();
+    });
+
+    var headers = {
+      'sec-websocket-version': 13,
+      'upgrade': 'websocket',
+      'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ=='
+    }
+
+    cl.get('/socket.io/{protocol}', {}, function (res, data) {
+      var sid = data.split(':')[0];
+      var url = '/socket.io/' + sio.protocol + '/websocket/' + sid;
+      cl.get(url, {headers: headers}, function (res, data) {});
+    });
+  },
+
+  'hybi-07-12 origin filter blocks access for mismatched sec-websocket-origin': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+
+    io.set('transports', ['websocket']);
+    io.set('origins', 'foo.bar.com:*');
+    var notConnected = true;
+    io.sockets.on('connection', function() {
+        notConnected = false;
+    });
+
+    var headers = {
+      'sec-websocket-version': 8,
+      'upgrade': 'websocket',
+      'Sec-WebSocket-Origin': 'http://baz.bar.com',
+      'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ=='
+    }
+
+    // handshake uses correct origin -- we want to block the actual websocket call
+    cl.get('/socket.io/{protocol}', {headers: {origin: 'http://foo.bar.com'}}, function (res, data) {
+      var sid = data.split(':')[0];
+      var url = '/socket.io/' + sio.protocol + '/websocket/' + sid;
+      var req = cl.get(url, {headers: headers}, function (res, data) {});
+      var closed = false;
+      (req.socket || req).on('close', function() {
+        if (closed) return;
+        closed = true;
+        notConnected.should.be.true;
+        cl.end();
+        try {
+          io.server.close();
+        }
+        catch (e) {}
+        done();
+      });
+    });
+  },
+
+  'hybi-16 origin filter blocks access for mismatched sec-websocket-origin': function (done) {
+    var cl = client(++ports)
+      , io = create(cl);
+
+    io.set('transports', ['websocket']);
+    io.set('origins', 'foo.bar.com:*');
+    var notConnected = true;
+    io.sockets.on('connection', function() {
+        notConnected = false;
+    });
+
+    var headers = {
+      'sec-websocket-version': 13,
+      'upgrade': 'websocket',
+      'origin': 'http://baz.bar.com',
+      'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ=='
+    }
+
+    // handshake uses correct origin -- we want to block the actual websocket call
+    cl.get('/socket.io/{protocol}', {headers: {origin: 'http://foo.bar.com'}}, function (res, data) {
+      var sid = data.split(':')[0];
+      var url = '/socket.io/' + sio.protocol + '/websocket/' + sid;
+      var req = cl.get(url, {headers: headers}, function (res, data) {});
+      var closed = false;
+      (req.socket || req).on('close', function() {
+        if (closed) return;
+        closed = true;
+        notConnected.should.be.true;
+        cl.end();
+        try {
+          io.server.close();
+        }
+        catch (e) {}
+        done();
+      });
+    });
+  },
+
+  'hybi-07-12 origin filter accepts implicit port 80 for sec-websocket-origin': function (done) {
+done();return;
+    var cl = client(++ports)
+      , io = create(cl)
+
+    io.set('transports', ['websocket']);
+    io.set('origins', 'foo.bar.com:80');
+
+    var headers = {
+      'sec-websocket-version': 8,
+      'upgrade': 'websocket',
+      'Sec-WebSocket-Origin': 'http://foo.bar.com',
+      'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ=='
+    }
+
+    io.sockets.on('connection', function() {
+        cl.end();
+        io.server.close();
+        done();
+    });
+
+    // handshake uses correct origin -- we want to block the actual websocket call
+    cl.get('/socket.io/{protocol}', {headers: {origin: 'http://foo.bar.com'}}, function (res, data) {
+      var sid = data.split(':')[0];
+      var url = '/socket.io/' + sio.protocol + '/websocket/' + sid;
+      cl.get(url, {headers: headers}, function (res, data) {});
+    });
+  },
+
+  'hybi-16 origin filter accepts implicit port 80 for sec-websocket-origin': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+
+    io.set('transports', ['websocket']);
+    io.set('origins', 'foo.bar.com:80');
+
+    var headers = {
+      'sec-websocket-version': 13,
+      'upgrade': 'websocket',
+      'origin': 'http://foo.bar.com',
+      'Sec-WebSocket-Key': 'dGhlIHNhbXBsZSBub25jZQ=='
+    }
+
+    io.sockets.on('connection', function() {
+        cl.end();
+        io.server.close();
+        done();
+    });
+
+    // handshake uses correct origin -- we want to block the actual websocket call
+    cl.get('/socket.io/{protocol}', {headers: {origin: 'http://foo.bar.com'}}, function (res, data) {
+      var sid = data.split(':')[0];
+      var url = '/socket.io/' + sio.protocol + '/websocket/' + sid;
+      cl.get(url, {headers: headers}, function (res, data) {});
+    });
+  },
 
   'test that not responding to a heartbeat drops client': function (done) {
     var cl = client(++ports)
@@ -99,134 +319,6 @@ module.exports = {
     });
   },
 
-  'test sending undeliverable volatile messages': function (done) {
-    var cl = client(++ports)
-      , io = create(cl)
-      , messages = 0
-      , messaged = false
-      , s;
-
-    io.configure(function () {
-      io.set('close timeout', .05);
-    });
-
-    io.sockets.on('connection', function (socket) {
-      s = socket;
-
-      socket.on('disconnect', function () {
-        messaged.should.be.false;
-        cl.end();
-        io.server.close();
-        done();
-      });
-    });
-
-    cl.handshake(function (sid) {
-      var ws = websocket(cl, sid);
-      ws.on('message', function (msg) {
-        msg.type.should.eql('connect');
-        ws.finishClose();
-
-        setTimeout(function () {
-          s.volatile.send('ah wha wha');
-
-          ws = websocket(cl, sid);
-          ws.on('message', function () {
-            messaged = true;
-          });
-
-          setTimeout(function () {
-            ws.finishClose();
-          }, 10);
-        }, 10);
-      });
-    });
-  },
-
-  'test sending undeliverable volatile json': function (done) {
-    var cl = client(++ports)
-      , io = create(cl)
-      , messaged = false
-      , s;
-
-    io.configure(function () {
-      io.set('close timeout', .05);
-    });
-
-    io.sockets.on('connection', function (socket) {
-      s = socket;
-
-      socket.on('disconnect', function () {
-        messaged.should.be.false;
-        cl.end();
-        io.server.close();
-        done();
-      });
-    });
-
-    cl.handshake(function (sid) {
-      var ws = websocket(cl, sid);
-      ws.on('message', function () {
-        ws.finishClose();
-
-        setTimeout(function () {
-          s.volatile.json.send({ a: 'b' });
-
-          ws = websocket(cl, sid);
-          ws.on('message', function () {
-            messaged = true;
-          });
-
-          setTimeout(function () {
-            ws.finishClose();
-          }, 10);
-        }, 10);
-      });
-    });
-  },
-
-  'test sending undeliverable volatile events': function (done) {
-    var cl = client(++ports)
-      , io = create(cl)
-      , messaged = false
-      , s;
-
-    io.configure(function () {
-      io.set('close timeout', .05);
-    });
-
-    io.sockets.on('connection', function (socket) {
-      s = socket;
-
-      socket.on('disconnect', function () {
-        messaged.should.be.false;
-        cl.end();
-        io.server.close();
-        done();
-      });
-    });
-
-    cl.handshake(function (sid) {
-      var ws = websocket(cl, sid);
-      ws.on('message', function () {
-        ws.finishClose();
-
-        setTimeout(function () {
-          s.volatile.emit({ a: 'b' });
-
-          ws = websocket(cl, sid);
-          ws.on('message', function () {
-            messaged = true;
-          });
-
-          setTimeout(function () {
-            ws.finishClose();
-          }, 10);
-        }, 10);
-      });
-    });
-  },
-
   'test sending deliverable volatile messages': function (done) {
     var cl = client(++ports)
       , io = create(cl)
@@ -899,6 +991,59 @@ module.exports = {
     });
   },
 
+  'test leaving a room': function (done) {
+    var port = ++ports
+      , cl1 = client(port)
+      , cl2 = client(port)
+      , io = create(cl1)
+      , joins = 0
+      , disconnects = 0;
+
+    io.set('close timeout', 0);
+
+    io.sockets.on('connection', function (socket) {
+      socket.join('foo');
+      io.sockets.clients('foo').should.have.length(++joins);
+
+      socket.on('disconnect', function () {
+        socket.leave('foo');
+        socket.leave('foo');
+        socket.leave('foo');
+
+        io.sockets.clients('foo').should.have.length(--joins);
+
+        if (++disconnects == 2) {
+          io.server.close();
+          cl1.end();
+          cl2.end();
+          done();
+        }
+      })
+    });
+
+    cl1.handshake(function (sid) {
+      var ws1 = websocket(cl1, sid);
+      ws1.on('message', function (msg) {
+        if (!ws1.connected) {
+          msg.type.should.eql('connect');
+          ws1.connected = true;
+           ws1.finishClose();
+        }
+      });
+    });
+
+    cl2.handshake(function (sid) {
+      var ws2 = websocket(cl2, sid);
+      ws2.on('message', function (msg) {
+        if (!ws2.connected) {
+          msg.type.should.eql('connect');
+          ws2.connected = true;
+          ws2.finishClose();
+        }
+      });
+    });
+  },
+
   'test message with broadcast flag': function (done) {
     var port = ++ports
       , cl1 = client(port)
@@ -1584,6 +1729,42 @@ module.exports = {
     });
   },
 
+  'test accessing handshake data from sockets on disconnect': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws;
+
+    io.sockets.on('connection', function (socket) {
+      socket.on('disconnect', function () {
+
+      (!!socket.handshake.address.address).should.be.true;
+      (!!socket.handshake.address.port).should.be.true;
+      socket.handshake.headers.host.should.equal('localhost');
+      socket.handshake.headers.connection.should.equal('keep-alive');
+      socket.handshake.time.should.match(/GMT/);
+
+        setTimeout(function () {
+          ws.finishClose();
+          cl.end();
+          io.server.close();
+          done();
+        }, 10);
+      });
+
+      socket.disconnect();
+    });
+
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid);
+      ws.on('message', function (msg) {
+        if (!ws.connected) {
+          msg.type.should.eql('connect');
+          ws.connected = true;
+        }
+      });
+    });
+  },
+
   'test for intentional and unintentional disconnects': function (done) {
     var cl = client(++ports)
       , io = create(cl)
@@ -1642,5 +1823,72 @@ module.exports = {
         }
       });
     });
+  },
+
+  'test socket clean up': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws;
+
+    io.sockets.on('connection', function (socket) {
+      var self = this
+        , id = socket.id;
+
+      socket.on('disconnect', function () {
+        setTimeout(function () {
+          var available = !!self.sockets[id];
+
+          available.should.be.false;
+          ws.finishClose();
+          cl.end();
+          io.server.close();
+          done();
+        }, 10);
+      });
+
+      socket.disconnect();
+    });
+
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid);
+      ws.on('message', function (msg) {
+        if (!ws.connected) {
+          msg.type.should.eql('connect');
+          ws.connected = true;
+        }
+      });
+    });
+  },
+
+  'accessing the transport type': function (done) {
+    var cl = client(++ports)
+      , io = create(cl)
+      , ws;
+
+    io.sockets.on('connection', function (socket) {
+      socket.transport.should.equal('websocket');
+
+      socket.on('disconnect', function () {
+        setTimeout(function () {
+          ws.finishClose();
+          cl.end();
+          io.server.close();
+          done();
+        }, 10);
+      });
+
+      socket.disconnect();
+    });
+
+    cl.handshake(function (sid) {
+      ws = websocket(cl, sid);
+      ws.on('message', function (msg) {
+        if (!ws.connected) {
+          msg.type.should.eql('connect');
+          ws.connected = true;
+        }
+      });
+    });
   }
+
 };

test/transports.xhr-polling.test.js

@@ -9,7 +9,7 @@
  * Test dependencies.
  */
 
-var sio = require('socket.io')
+var sio = require('../')
   , should = require('./common')
   , HTTPClient = should.HTTPClient
   , parser = sio.parser
@@ -220,7 +220,12 @@ module.exports = {
           done();
         });
 
-        cl.get('/socket.io/{protocol}/xhr-polling/' + sid + '/?disconnect');
+        // with the new http bits in node 0.5, there's no guarantee that
+        // the previous request is actually dispatched (and received) before the following
+        // reset call is sent. to not waste more time on a workaround, a timeout is added.
+        setTimeout(function() {
+          cl.get('/socket.io/{protocol}/xhr-polling/' + sid + '/?disconnect');
+        }, 500);
       });
     });
   },
@@ -763,7 +768,7 @@ module.exports = {
     var cl = client(++ports)
       , io = create(cl)
       , messages = 0;
-    
+
     io.configure(function () {
       io.set('polling duration', 0);
       io.set('close timeout', .1);
@@ -950,6 +955,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)
@@ -2609,8 +2652,8 @@ module.exports = {
       }, function (res, packs) {
         var headers = res.headers;
 
-        headers['access-control-allow-origin'].should.equal('*');
-        should.strictEqual(headers['access-control-allow-credentials'], undefined);
+        headers['access-control-allow-origin'].should.equal('http://localhost:3500');
+        headers['access-control-allow-credentials'].should.equal('true');
 
         packs.should.have.length(1);
         packs[0].type.should.eql('message');
@@ -2626,7 +2669,7 @@ module.exports = {
           }
         }, function (res, data) {
           var headers = res.headers;
-          headers['access-control-allow-origin'].should.equal('*');
+          headers['access-control-allow-origin'].should.equal('http://localhost:3500');
           headers['access-control-allow-credentials'].should.equal('true');
 
           data.should.equal('1');
@@ -2708,7 +2751,7 @@ module.exports = {
               }
           );
         });
-        
+
       });
     });
   }