| |
| /** |
| * Module requirements. |
| */ |
| |
| var Transport = require('../transport'); |
| var parser = require('engine.io-parser'); |
| var zlib = require('zlib'); |
| var accepts = require('accepts'); |
| var util = require('util'); |
| var debug = require('debug')('engine:polling'); |
| |
| var compressionMethods = { |
| gzip: zlib.createGzip, |
| deflate: zlib.createDeflate |
| }; |
| |
| /** |
| * Exports the constructor. |
| */ |
| |
| module.exports = Polling; |
| |
| /** |
| * HTTP polling constructor. |
| * |
| * @api public. |
| */ |
| |
| function Polling (req) { |
| Transport.call(this, req); |
| |
| this.closeTimeout = 30 * 1000; |
| this.maxHttpBufferSize = null; |
| this.httpCompression = null; |
| } |
| |
| /** |
| * Inherits from Transport. |
| * |
| * @api public. |
| */ |
| |
| util.inherits(Polling, Transport); |
| |
| /** |
| * Transport name |
| * |
| * @api public |
| */ |
| |
| Polling.prototype.name = 'polling'; |
| |
| /** |
| * Overrides onRequest. |
| * |
| * @param {http.IncomingMessage} |
| * @api private |
| */ |
| |
| Polling.prototype.onRequest = function (req) { |
| var res = req.res; |
| |
| if ('GET' === req.method) { |
| this.onPollRequest(req, res); |
| } else if ('POST' === req.method) { |
| this.onDataRequest(req, res); |
| } else { |
| res.writeHead(500); |
| res.end(); |
| } |
| }; |
| |
| /** |
| * The client sends a request awaiting for us to send data. |
| * |
| * @api private |
| */ |
| |
| Polling.prototype.onPollRequest = function (req, res) { |
| if (this.req) { |
| debug('request overlap'); |
| // assert: this.res, '.req and .res should be (un)set together' |
| this.onError('overlap from client'); |
| res.writeHead(500); |
| res.end(); |
| return; |
| } |
| |
| debug('setting request'); |
| |
| this.req = req; |
| this.res = res; |
| |
| var self = this; |
| |
| function onClose () { |
| self.onError('poll connection closed prematurely'); |
| } |
| |
| function cleanup () { |
| req.removeListener('close', onClose); |
| self.req = self.res = null; |
| } |
| |
| req.cleanup = cleanup; |
| req.on('close', onClose); |
| |
| this.writable = true; |
| this.emit('drain'); |
| |
| // if we're still writable but had a pending close, trigger an empty send |
| if (this.writable && this.shouldClose) { |
| debug('triggering empty send to append close packet'); |
| this.send([{ type: 'noop' }]); |
| } |
| }; |
| |
| /** |
| * The client sends a request with data. |
| * |
| * @api private |
| */ |
| |
| Polling.prototype.onDataRequest = function (req, res) { |
| if (this.dataReq) { |
| // assert: this.dataRes, '.dataReq and .dataRes should be (un)set together' |
| this.onError('data request overlap from client'); |
| res.writeHead(500); |
| res.end(); |
| return; |
| } |
| |
| var isBinary = 'application/octet-stream' === req.headers['content-type']; |
| |
| this.dataReq = req; |
| this.dataRes = res; |
| |
| var chunks = isBinary ? Buffer.concat([]) : ''; |
| var self = this; |
| |
| function cleanup () { |
| req.removeListener('data', onData); |
| req.removeListener('end', onEnd); |
| req.removeListener('close', onClose); |
| self.dataReq = self.dataRes = chunks = null; |
| } |
| |
| function onClose () { |
| cleanup(); |
| self.onError('data request connection closed prematurely'); |
| } |
| |
| function onData (data) { |
| var contentLength; |
| if (isBinary) { |
| chunks = Buffer.concat([chunks, data]); |
| contentLength = chunks.length; |
| } else { |
| chunks += data; |
| contentLength = Buffer.byteLength(chunks); |
| } |
| |
| if (contentLength > self.maxHttpBufferSize) { |
| chunks = isBinary ? Buffer.concat([]) : ''; |
| req.connection.destroy(); |
| } |
| } |
| |
| function onEnd () { |
| self.onData(chunks); |
| |
| var headers = { |
| // text/html is required instead of text/plain to avoid an |
| // unwanted download dialog on certain user-agents (GH-43) |
| 'Content-Type': 'text/html', |
| 'Content-Length': 2 |
| }; |
| |
| res.writeHead(200, self.headers(req, headers)); |
| res.end('ok'); |
| cleanup(); |
| } |
| |
| req.on('close', onClose); |
| if (!isBinary) req.setEncoding('utf8'); |
| req.on('data', onData); |
| req.on('end', onEnd); |
| }; |
| |
| /** |
| * Processes the incoming data payload. |
| * |
| * @param {String} encoded payload |
| * @api private |
| */ |
| |
| Polling.prototype.onData = function (data) { |
| debug('received "%s"', data); |
| var self = this; |
| var callback = function (packet) { |
| if ('close' === packet.type) { |
| debug('got xhr close packet'); |
| self.onClose(); |
| return false; |
| } |
| |
| self.onPacket(packet); |
| }; |
| |
| parser.decodePayload(data, callback); |
| }; |
| |
| /** |
| * Overrides onClose. |
| * |
| * @api private |
| */ |
| |
| Polling.prototype.onClose = function () { |
| if (this.writable) { |
| // close pending poll request |
| this.send([{ type: 'noop' }]); |
| } |
| Transport.prototype.onClose.call(this); |
| }; |
| |
| /** |
| * Writes a packet payload. |
| * |
| * @param {Object} packet |
| * @api private |
| */ |
| |
| Polling.prototype.send = function (packets) { |
| this.writable = false; |
| |
| if (this.shouldClose) { |
| debug('appending close packet to payload'); |
| packets.push({ type: 'close' }); |
| this.shouldClose(); |
| this.shouldClose = null; |
| } |
| |
| var self = this; |
| parser.encodePayload(packets, this.supportsBinary, function (data) { |
| var compress = packets.some(function (packet) { |
| return packet.options && packet.options.compress; |
| }); |
| self.write(data, { compress: compress }); |
| }); |
| }; |
| |
| /** |
| * Writes data as response to poll request. |
| * |
| * @param {String} data |
| * @param {Object} options |
| * @api private |
| */ |
| |
| Polling.prototype.write = function (data, options) { |
| debug('writing "%s"', data); |
| var self = this; |
| this.doWrite(data, options, function () { |
| self.req.cleanup(); |
| }); |
| }; |
| |
| /** |
| * Performs the write. |
| * |
| * @api private |
| */ |
| |
| Polling.prototype.doWrite = function (data, options, callback) { |
| var self = this; |
| |
| // explicit UTF-8 is required for pages not served under utf |
| var isString = typeof data === 'string'; |
| var contentType = isString |
| ? 'text/plain; charset=UTF-8' |
| : 'application/octet-stream'; |
| |
| var headers = { |
| 'Content-Type': contentType |
| }; |
| |
| if (!this.httpCompression || !options.compress) { |
| respond(data); |
| return; |
| } |
| |
| var len = isString ? Buffer.byteLength(data) : data.length; |
| if (len < this.httpCompression.threshold) { |
| respond(data); |
| return; |
| } |
| |
| var encoding = accepts(this.req).encodings(['gzip', 'deflate']); |
| if (!encoding) { |
| respond(data); |
| return; |
| } |
| |
| this.compress(data, encoding, function (err, data) { |
| if (err) { |
| self.res.writeHead(500); |
| self.res.end(); |
| callback(err); |
| return; |
| } |
| |
| headers['Content-Encoding'] = encoding; |
| respond(data); |
| }); |
| |
| function respond (data) { |
| headers['Content-Length'] = 'string' === typeof data ? Buffer.byteLength(data) : data.length; |
| self.res.writeHead(200, self.headers(self.req, headers)); |
| self.res.end(data); |
| callback(); |
| } |
| }; |
| |
| /** |
| * Compresses data. |
| * |
| * @api private |
| */ |
| |
| Polling.prototype.compress = function (data, encoding, callback) { |
| debug('compressing'); |
| |
| var buffers = []; |
| var nread = 0; |
| |
| compressionMethods[encoding](this.httpCompression) |
| .on('error', callback) |
| .on('data', function (chunk) { |
| buffers.push(chunk); |
| nread += chunk.length; |
| }) |
| .on('end', function () { |
| callback(null, Buffer.concat(buffers, nread)); |
| }) |
| .end(data); |
| }; |
| |
| /** |
| * Closes the transport. |
| * |
| * @api private |
| */ |
| |
| Polling.prototype.doClose = function (fn) { |
| debug('closing'); |
| |
| var self = this; |
| var closeTimeoutTimer; |
| |
| if (this.dataReq) { |
| debug('aborting ongoing data request'); |
| this.dataReq.destroy(); |
| } |
| |
| if (this.writable) { |
| debug('transport writable - closing right away'); |
| this.send([{ type: 'close' }]); |
| onClose(); |
| } else if (this.discarded) { |
| debug('transport discarded - closing right away'); |
| onClose(); |
| } else { |
| debug('transport not writable - buffering orderly close'); |
| this.shouldClose = onClose; |
| closeTimeoutTimer = setTimeout(onClose, this.closeTimeout); |
| } |
| |
| function onClose () { |
| clearTimeout(closeTimeoutTimer); |
| fn(); |
| self.onClose(); |
| } |
| }; |
| |
| /** |
| * Returns headers for a response. |
| * |
| * @param {http.IncomingMessage} request |
| * @param {Object} extra headers |
| * @api private |
| */ |
| |
| Polling.prototype.headers = function (req, headers) { |
| headers = headers || {}; |
| |
| // prevent XSS warnings on IE |
| // https://github.com/LearnBoost/socket.io/pull/1333 |
| var ua = req.headers['user-agent']; |
| if (ua && (~ua.indexOf(';MSIE') || ~ua.indexOf('Trident/'))) { |
| headers['X-XSS-Protection'] = '0'; |
| } |
| |
| this.emit('headers', headers); |
| return headers; |
| }; |