576 lines
15 KiB
JavaScript
576 lines
15 KiB
JavaScript
|
|
/**
|
|
* Module dependencies.
|
|
*/
|
|
|
|
var qs = require('querystring');
|
|
var parse = require('url').parse;
|
|
var base64id = require('base64id');
|
|
var transports = require('./transports');
|
|
var EventEmitter = require('events').EventEmitter;
|
|
var Socket = require('./socket');
|
|
var util = require('util');
|
|
var debug = require('debug')('engine');
|
|
var cookieMod = require('cookie');
|
|
|
|
/**
|
|
* Module exports.
|
|
*/
|
|
|
|
module.exports = Server;
|
|
|
|
/**
|
|
* Server constructor.
|
|
*
|
|
* @param {Object} options
|
|
* @api public
|
|
*/
|
|
|
|
function Server (opts) {
|
|
if (!(this instanceof Server)) {
|
|
return new Server(opts);
|
|
}
|
|
|
|
this.clients = {};
|
|
this.clientsCount = 0;
|
|
|
|
opts = opts || {};
|
|
|
|
this.wsEngine = opts.wsEngine || process.env.EIO_WS_ENGINE || 'ws';
|
|
this.pingTimeout = opts.pingTimeout || 5000;
|
|
this.pingInterval = opts.pingInterval || 25000;
|
|
this.upgradeTimeout = opts.upgradeTimeout || 10000;
|
|
this.maxHttpBufferSize = opts.maxHttpBufferSize || 10E7;
|
|
this.transports = opts.transports || Object.keys(transports);
|
|
this.allowUpgrades = false !== opts.allowUpgrades;
|
|
this.allowRequest = opts.allowRequest;
|
|
this.cookie = false !== opts.cookie ? (opts.cookie || 'io') : false;
|
|
this.cookiePath = false !== opts.cookiePath ? (opts.cookiePath || '/') : false;
|
|
this.cookieHttpOnly = false !== opts.cookieHttpOnly;
|
|
this.perMessageDeflate = false !== opts.perMessageDeflate ? (opts.perMessageDeflate || true) : false;
|
|
this.httpCompression = false !== opts.httpCompression ? (opts.httpCompression || {}) : false;
|
|
this.initialPacket = opts.initialPacket;
|
|
|
|
var self = this;
|
|
|
|
// initialize compression options
|
|
['perMessageDeflate', 'httpCompression'].forEach(function (type) {
|
|
var compression = self[type];
|
|
if (true === compression) self[type] = compression = {};
|
|
if (compression && null == compression.threshold) {
|
|
compression.threshold = 1024;
|
|
}
|
|
});
|
|
|
|
this.init();
|
|
}
|
|
|
|
/**
|
|
* Protocol errors mappings.
|
|
*/
|
|
|
|
Server.errors = {
|
|
UNKNOWN_TRANSPORT: 0,
|
|
UNKNOWN_SID: 1,
|
|
BAD_HANDSHAKE_METHOD: 2,
|
|
BAD_REQUEST: 3,
|
|
FORBIDDEN: 4
|
|
};
|
|
|
|
Server.errorMessages = {
|
|
0: 'Transport unknown',
|
|
1: 'Session ID unknown',
|
|
2: 'Bad handshake method',
|
|
3: 'Bad request',
|
|
4: 'Forbidden'
|
|
};
|
|
|
|
/**
|
|
* Inherits from EventEmitter.
|
|
*/
|
|
|
|
util.inherits(Server, EventEmitter);
|
|
|
|
/**
|
|
* Initialize websocket server
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Server.prototype.init = function () {
|
|
if (!~this.transports.indexOf('websocket')) return;
|
|
|
|
if (this.ws) this.ws.close();
|
|
|
|
var wsModule;
|
|
switch (this.wsEngine) {
|
|
case 'uws': wsModule = require('uws'); break;
|
|
case 'ws': wsModule = require('ws'); break;
|
|
default: throw new Error('unknown wsEngine');
|
|
}
|
|
this.ws = new wsModule.Server({
|
|
noServer: true,
|
|
clientTracking: false,
|
|
perMessageDeflate: this.perMessageDeflate,
|
|
maxPayload: this.maxHttpBufferSize
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Returns a list of available transports for upgrade given a certain transport.
|
|
*
|
|
* @return {Array}
|
|
* @api public
|
|
*/
|
|
|
|
Server.prototype.upgrades = function (transport) {
|
|
if (!this.allowUpgrades) return [];
|
|
return transports[transport].upgradesTo || [];
|
|
};
|
|
|
|
/**
|
|
* Verifies a request.
|
|
*
|
|
* @param {http.IncomingMessage}
|
|
* @return {Boolean} whether the request is valid
|
|
* @api private
|
|
*/
|
|
|
|
Server.prototype.verify = function (req, upgrade, fn) {
|
|
// transport check
|
|
var transport = req._query.transport;
|
|
if (!~this.transports.indexOf(transport)) {
|
|
debug('unknown transport "%s"', transport);
|
|
return fn(Server.errors.UNKNOWN_TRANSPORT, false);
|
|
}
|
|
|
|
// 'Origin' header check
|
|
var isOriginInvalid = checkInvalidHeaderChar(req.headers.origin);
|
|
if (isOriginInvalid) {
|
|
req.headers.origin = null;
|
|
return fn(Server.errors.BAD_REQUEST, false);
|
|
}
|
|
|
|
// sid check
|
|
var sid = req._query.sid;
|
|
if (sid) {
|
|
if (!this.clients.hasOwnProperty(sid)) {
|
|
return fn(Server.errors.UNKNOWN_SID, false);
|
|
}
|
|
if (!upgrade && this.clients[sid].transport.name !== transport) {
|
|
debug('bad request: unexpected transport without upgrade');
|
|
return fn(Server.errors.BAD_REQUEST, false);
|
|
}
|
|
} else {
|
|
// handshake is GET only
|
|
if ('GET' !== req.method) return fn(Server.errors.BAD_HANDSHAKE_METHOD, false);
|
|
if (!this.allowRequest) return fn(null, true);
|
|
return this.allowRequest(req, fn);
|
|
}
|
|
|
|
fn(null, true);
|
|
};
|
|
|
|
/**
|
|
* Prepares a request by processing the query string.
|
|
*
|
|
* @api private
|
|
*/
|
|
|
|
Server.prototype.prepare = function (req) {
|
|
// try to leverage pre-existing `req._query` (e.g: from connect)
|
|
if (!req._query) {
|
|
req._query = ~req.url.indexOf('?') ? qs.parse(parse(req.url).query) : {};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Closes all clients.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
Server.prototype.close = function () {
|
|
debug('closing all open clients');
|
|
for (var i in this.clients) {
|
|
if (this.clients.hasOwnProperty(i)) {
|
|
this.clients[i].close(true);
|
|
}
|
|
}
|
|
if (this.ws) {
|
|
debug('closing webSocketServer');
|
|
this.ws.close();
|
|
// don't delete this.ws because it can be used again if the http server starts listening again
|
|
}
|
|
return this;
|
|
};
|
|
|
|
/**
|
|
* Handles an Engine.IO HTTP request.
|
|
*
|
|
* @param {http.IncomingMessage} request
|
|
* @param {http.ServerResponse|http.OutgoingMessage} response
|
|
* @api public
|
|
*/
|
|
|
|
Server.prototype.handleRequest = function (req, res) {
|
|
debug('handling "%s" http request "%s"', req.method, req.url);
|
|
this.prepare(req);
|
|
req.res = res;
|
|
|
|
var self = this;
|
|
this.verify(req, false, function (err, success) {
|
|
if (!success) {
|
|
sendErrorMessage(req, res, err);
|
|
return;
|
|
}
|
|
|
|
if (req._query.sid) {
|
|
debug('setting new request for existing client');
|
|
self.clients[req._query.sid].transport.onRequest(req);
|
|
} else {
|
|
self.handshake(req._query.transport, req);
|
|
}
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Sends an Engine.IO Error Message
|
|
*
|
|
* @param {http.ServerResponse} response
|
|
* @param {code} error code
|
|
* @api private
|
|
*/
|
|
|
|
function sendErrorMessage (req, res, code) {
|
|
var headers = { 'Content-Type': 'application/json' };
|
|
|
|
var isForbidden = !Server.errorMessages.hasOwnProperty(code);
|
|
if (isForbidden) {
|
|
res.writeHead(403, headers);
|
|
res.end(JSON.stringify({
|
|
code: Server.errors.FORBIDDEN,
|
|
message: code || Server.errorMessages[Server.errors.FORBIDDEN]
|
|
}));
|
|
return;
|
|
}
|
|
if (req.headers.origin) {
|
|
headers['Access-Control-Allow-Credentials'] = 'true';
|
|
headers['Access-Control-Allow-Origin'] = req.headers.origin;
|
|
} else {
|
|
headers['Access-Control-Allow-Origin'] = '*';
|
|
}
|
|
if (res !== undefined) {
|
|
res.writeHead(400, headers);
|
|
res.end(JSON.stringify({
|
|
code: code,
|
|
message: Server.errorMessages[code]
|
|
}));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* generate a socket id.
|
|
* Overwrite this method to generate your custom socket id
|
|
*
|
|
* @param {Object} request object
|
|
* @api public
|
|
*/
|
|
|
|
Server.prototype.generateId = function (req) {
|
|
return base64id.generateId();
|
|
};
|
|
|
|
/**
|
|
* Handshakes a new client.
|
|
*
|
|
* @param {String} transport name
|
|
* @param {Object} request object
|
|
* @api private
|
|
*/
|
|
|
|
Server.prototype.handshake = function (transportName, req) {
|
|
var id = this.generateId(req);
|
|
|
|
debug('handshaking client "%s"', id);
|
|
|
|
try {
|
|
var transport = new transports[transportName](req);
|
|
if ('polling' === transportName) {
|
|
transport.maxHttpBufferSize = this.maxHttpBufferSize;
|
|
transport.httpCompression = this.httpCompression;
|
|
} else if ('websocket' === transportName) {
|
|
transport.perMessageDeflate = this.perMessageDeflate;
|
|
}
|
|
|
|
if (req._query && req._query.b64) {
|
|
transport.supportsBinary = false;
|
|
} else {
|
|
transport.supportsBinary = true;
|
|
}
|
|
} catch (e) {
|
|
sendErrorMessage(req, req.res, Server.errors.BAD_REQUEST);
|
|
return;
|
|
}
|
|
var socket = new Socket(id, this, transport, req);
|
|
var self = this;
|
|
|
|
if (false !== this.cookie) {
|
|
transport.on('headers', function (headers) {
|
|
headers['Set-Cookie'] = cookieMod.serialize(self.cookie, id,
|
|
{
|
|
path: self.cookiePath,
|
|
httpOnly: self.cookiePath ? self.cookieHttpOnly : false
|
|
});
|
|
});
|
|
}
|
|
|
|
transport.onRequest(req);
|
|
|
|
this.clients[id] = socket;
|
|
this.clientsCount++;
|
|
|
|
socket.once('close', function () {
|
|
delete self.clients[id];
|
|
self.clientsCount--;
|
|
});
|
|
|
|
this.emit('connection', socket);
|
|
};
|
|
|
|
/**
|
|
* Handles an Engine.IO HTTP Upgrade.
|
|
*
|
|
* @api public
|
|
*/
|
|
|
|
Server.prototype.handleUpgrade = function (req, socket, upgradeHead) {
|
|
this.prepare(req);
|
|
|
|
var self = this;
|
|
this.verify(req, true, function (err, success) {
|
|
if (!success) {
|
|
abortConnection(socket, err);
|
|
return;
|
|
}
|
|
|
|
var head = new Buffer(upgradeHead.length); // eslint-disable-line node/no-deprecated-api
|
|
upgradeHead.copy(head);
|
|
upgradeHead = null;
|
|
|
|
// delegate to ws
|
|
self.ws.handleUpgrade(req, socket, head, function (conn) {
|
|
self.onWebSocket(req, conn);
|
|
});
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Called upon a ws.io connection.
|
|
*
|
|
* @param {ws.Socket} websocket
|
|
* @api private
|
|
*/
|
|
|
|
Server.prototype.onWebSocket = function (req, socket) {
|
|
socket.on('error', onUpgradeError);
|
|
|
|
if (transports[req._query.transport] !== undefined && !transports[req._query.transport].prototype.handlesUpgrades) {
|
|
debug('transport doesnt handle upgraded requests');
|
|
socket.close();
|
|
return;
|
|
}
|
|
|
|
// get client id
|
|
var id = req._query.sid;
|
|
|
|
// keep a reference to the ws.Socket
|
|
req.websocket = socket;
|
|
|
|
if (id) {
|
|
var client = this.clients[id];
|
|
if (!client) {
|
|
debug('upgrade attempt for closed client');
|
|
socket.close();
|
|
} else if (client.upgrading) {
|
|
debug('transport has already been trying to upgrade');
|
|
socket.close();
|
|
} else if (client.upgraded) {
|
|
debug('transport had already been upgraded');
|
|
socket.close();
|
|
} else {
|
|
debug('upgrading existing transport');
|
|
|
|
// transport error handling takes over
|
|
socket.removeListener('error', onUpgradeError);
|
|
|
|
var transport = new transports[req._query.transport](req);
|
|
if (req._query && req._query.b64) {
|
|
transport.supportsBinary = false;
|
|
} else {
|
|
transport.supportsBinary = true;
|
|
}
|
|
transport.perMessageDeflate = this.perMessageDeflate;
|
|
client.maybeUpgrade(transport);
|
|
}
|
|
} else {
|
|
// transport error handling takes over
|
|
socket.removeListener('error', onUpgradeError);
|
|
|
|
this.handshake(req._query.transport, req);
|
|
}
|
|
|
|
function onUpgradeError () {
|
|
debug('websocket error before upgrade');
|
|
// socket.close() not needed
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Captures upgrade requests for a http.Server.
|
|
*
|
|
* @param {http.Server} server
|
|
* @param {Object} options
|
|
* @api public
|
|
*/
|
|
|
|
Server.prototype.attach = function (server, options) {
|
|
var self = this;
|
|
options = options || {};
|
|
var path = (options.path || '/engine.io').replace(/\/$/, '');
|
|
|
|
var destroyUpgradeTimeout = options.destroyUpgradeTimeout || 1000;
|
|
|
|
// normalize path
|
|
path += '/';
|
|
|
|
function check (req) {
|
|
if ('OPTIONS' === req.method && false === options.handlePreflightRequest) {
|
|
return false;
|
|
}
|
|
return path === req.url.substr(0, path.length);
|
|
}
|
|
|
|
// cache and clean up listeners
|
|
var listeners = server.listeners('request').slice(0);
|
|
server.removeAllListeners('request');
|
|
server.on('close', self.close.bind(self));
|
|
server.on('listening', self.init.bind(self));
|
|
|
|
// add request handler
|
|
server.on('request', function (req, res) {
|
|
if (check(req)) {
|
|
debug('intercepting request for path "%s"', path);
|
|
if ('OPTIONS' === req.method && 'function' === typeof options.handlePreflightRequest) {
|
|
options.handlePreflightRequest.call(server, req, res);
|
|
} else {
|
|
self.handleRequest(req, res);
|
|
}
|
|
} else {
|
|
for (var i = 0, l = listeners.length; i < l; i++) {
|
|
listeners[i].call(server, req, res);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (~self.transports.indexOf('websocket')) {
|
|
server.on('upgrade', function (req, socket, head) {
|
|
if (check(req)) {
|
|
self.handleUpgrade(req, socket, head);
|
|
} else if (false !== options.destroyUpgrade) {
|
|
// default node behavior is to disconnect when no handlers
|
|
// but by adding a handler, we prevent that
|
|
// and if no eio thing handles the upgrade
|
|
// then the socket needs to die!
|
|
setTimeout(function () {
|
|
if (socket.writable && socket.bytesWritten <= 0) {
|
|
return socket.end();
|
|
}
|
|
}, destroyUpgradeTimeout);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Closes the connection
|
|
*
|
|
* @param {net.Socket} socket
|
|
* @param {code} error code
|
|
* @api private
|
|
*/
|
|
|
|
function abortConnection (socket, code) {
|
|
if (socket.writable) {
|
|
var message = Server.errorMessages.hasOwnProperty(code) ? Server.errorMessages[code] : String(code || '');
|
|
var length = Buffer.byteLength(message);
|
|
socket.write(
|
|
'HTTP/1.1 400 Bad Request\r\n' +
|
|
'Connection: close\r\n' +
|
|
'Content-type: text/html\r\n' +
|
|
'Content-Length: ' + length + '\r\n' +
|
|
'\r\n' +
|
|
message
|
|
);
|
|
}
|
|
socket.destroy();
|
|
}
|
|
|
|
/* eslint-disable */
|
|
|
|
/**
|
|
* From https://github.com/nodejs/node/blob/v8.4.0/lib/_http_common.js#L303-L354
|
|
*
|
|
* True if val contains an invalid field-vchar
|
|
* field-value = *( field-content / obs-fold )
|
|
* field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
|
|
* field-vchar = VCHAR / obs-text
|
|
*
|
|
* checkInvalidHeaderChar() is currently designed to be inlinable by v8,
|
|
* so take care when making changes to the implementation so that the source
|
|
* code size does not exceed v8's default max_inlined_source_size setting.
|
|
**/
|
|
var validHdrChars = [
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // 0 - 15
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 - 31
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 - 47
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 - 63
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 - 79
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 - 95
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 - 111
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 - 127
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 ...
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
|
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // ... 255
|
|
];
|
|
|
|
function checkInvalidHeaderChar(val) {
|
|
val += '';
|
|
if (val.length < 1)
|
|
return false;
|
|
if (!validHdrChars[val.charCodeAt(0)])
|
|
return true;
|
|
if (val.length < 2)
|
|
return false;
|
|
if (!validHdrChars[val.charCodeAt(1)])
|
|
return true;
|
|
if (val.length < 3)
|
|
return false;
|
|
if (!validHdrChars[val.charCodeAt(2)])
|
|
return true;
|
|
if (val.length < 4)
|
|
return false;
|
|
if (!validHdrChars[val.charCodeAt(3)])
|
|
return true;
|
|
for (var i = 4; i < val.length; ++i) {
|
|
if (!validHdrChars[val.charCodeAt(i)])
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|