|
|
var httpNative = require('http'), |
|
|
httpsNative = require('https'), |
|
|
web_o = require('./web-outgoing'), |
|
|
common = require('../common'), |
|
|
followRedirects = require('follow-redirects'); |
|
|
|
|
|
web_o = Object.keys(web_o).map(function(pass) { |
|
|
return web_o[pass]; |
|
|
}); |
|
|
|
|
|
var nativeAgents = { http: httpNative, https: httpsNative }; |
|
|
|
|
|
/*! |
|
|
* Array of passes. |
|
|
* |
|
|
* A `pass` is just a function that is executed on `req, res, options` |
|
|
* so that you can easily add new checks while still keeping the base |
|
|
* flexible. |
|
|
*/ |
|
|
|
|
|
|
|
|
module.exports = { |
|
|
|
|
|
/** |
|
|
* Sets `content-length` to '0' if request is of DELETE type. |
|
|
* |
|
|
* @param {ClientRequest} Req Request object |
|
|
* @param {IncomingMessage} Res Response object |
|
|
* @param {Object} Options Config object passed to the proxy |
|
|
* |
|
|
* @api private |
|
|
*/ |
|
|
|
|
|
deleteLength: function deleteLength(req, res, options) { |
|
|
if((req.method === 'DELETE' || req.method === 'OPTIONS') |
|
|
&& !req.headers['content-length']) { |
|
|
req.headers['content-length'] = '0'; |
|
|
delete req.headers['transfer-encoding']; |
|
|
} |
|
|
}, |
|
|
|
|
|
/** |
|
|
* Sets timeout in request socket if it was specified in options. |
|
|
* |
|
|
* @param {ClientRequest} Req Request object |
|
|
* @param {IncomingMessage} Res Response object |
|
|
* @param {Object} Options Config object passed to the proxy |
|
|
* |
|
|
* @api private |
|
|
*/ |
|
|
|
|
|
timeout: function timeout(req, res, options) { |
|
|
if(options.timeout) { |
|
|
req.socket.setTimeout(options.timeout); |
|
|
} |
|
|
}, |
|
|
|
|
|
/** |
|
|
* Sets `x-forwarded-*` headers if specified in config. |
|
|
* |
|
|
* @param {ClientRequest} Req Request object |
|
|
* @param {IncomingMessage} Res Response object |
|
|
* @param {Object} Options Config object passed to the proxy |
|
|
* |
|
|
* @api private |
|
|
*/ |
|
|
|
|
|
XHeaders: function XHeaders(req, res, options) { |
|
|
if(!options.xfwd) return; |
|
|
|
|
|
var encrypted = req.isSpdy || common.hasEncryptedConnection(req); |
|
|
var values = { |
|
|
for : req.connection.remoteAddress || req.socket.remoteAddress, |
|
|
port : common.getPort(req), |
|
|
proto: encrypted ? 'https' : 'http' |
|
|
}; |
|
|
|
|
|
['for', 'port', 'proto'].forEach(function(header) { |
|
|
req.headers['x-forwarded-' + header] = |
|
|
(req.headers['x-forwarded-' + header] || '') + |
|
|
(req.headers['x-forwarded-' + header] ? ',' : '') + |
|
|
values[header]; |
|
|
}); |
|
|
|
|
|
req.headers['x-forwarded-host'] = req.headers['x-forwarded-host'] || req.headers['host'] || ''; |
|
|
}, |
|
|
|
|
|
/** |
|
|
* Does the actual proxying. If `forward` is enabled fires up |
|
|
* a ForwardStream, same happens for ProxyStream. The request |
|
|
* just dies otherwise. |
|
|
* |
|
|
* @param {ClientRequest} Req Request object |
|
|
* @param {IncomingMessage} Res Response object |
|
|
* @param {Object} Options Config object passed to the proxy |
|
|
* |
|
|
* @api private |
|
|
*/ |
|
|
|
|
|
stream: function stream(req, res, options, _, server, clb) { |
|
|
|
|
|
// And we begin! |
|
|
server.emit('start', req, res, options.target || options.forward); |
|
|
|
|
|
var agents = options.followRedirects ? followRedirects : nativeAgents; |
|
|
var http = agents.http; |
|
|
var https = agents.https; |
|
|
|
|
|
if(options.forward) { |
|
|
// If forward enable, so just pipe the request |
|
|
var forwardReq = (options.forward.protocol === 'https:' ? https : http).request( |
|
|
common.setupOutgoing(options.ssl || {}, options, req, 'forward') |
|
|
); |
|
|
|
|
|
// error handler (e.g. ECONNRESET, ECONNREFUSED) |
|
|
// Handle errors on incoming request as well as it makes sense to |
|
|
var forwardError = createErrorHandler(forwardReq, options.forward); |
|
|
req.on('error', forwardError); |
|
|
forwardReq.on('error', forwardError); |
|
|
|
|
|
(options.buffer || req).pipe(forwardReq); |
|
|
if(!options.target) { return res.end(); } |
|
|
} |
|
|
|
|
|
// Request initalization |
|
|
var proxyReq = (options.target.protocol === 'https:' ? https : http).request( |
|
|
common.setupOutgoing(options.ssl || {}, options, req) |
|
|
); |
|
|
|
|
|
// Enable developers to modify the proxyReq before headers are sent |
|
|
proxyReq.on('socket', function(socket) { |
|
|
if(server && !proxyReq.getHeader('expect')) { |
|
|
server.emit('proxyReq', proxyReq, req, res, options); |
|
|
} |
|
|
}); |
|
|
|
|
|
// allow outgoing socket to timeout so that we could |
|
|
// show an error page at the initial request |
|
|
if(options.proxyTimeout) { |
|
|
proxyReq.setTimeout(options.proxyTimeout, function() { |
|
|
proxyReq.abort(); |
|
|
}); |
|
|
} |
|
|
|
|
|
// Ensure we abort proxy if request is aborted |
|
|
req.on('aborted', function () { |
|
|
proxyReq.abort(); |
|
|
}); |
|
|
|
|
|
// handle errors in proxy and incoming request, just like for forward proxy |
|
|
var proxyError = createErrorHandler(proxyReq, options.target); |
|
|
req.on('error', proxyError); |
|
|
proxyReq.on('error', proxyError); |
|
|
|
|
|
function createErrorHandler(proxyReq, url) { |
|
|
return function proxyError(err) { |
|
|
if (req.socket.destroyed && err.code === 'ECONNRESET') { |
|
|
server.emit('econnreset', err, req, res, url); |
|
|
return proxyReq.abort(); |
|
|
} |
|
|
|
|
|
if (clb) { |
|
|
clb(err, req, res, url); |
|
|
} else { |
|
|
server.emit('error', err, req, res, url); |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
(options.buffer || req).pipe(proxyReq); |
|
|
|
|
|
proxyReq.on('response', function(proxyRes) { |
|
|
if(server) { server.emit('proxyRes', proxyRes, req, res); } |
|
|
|
|
|
if(!res.headersSent && !options.selfHandleResponse) { |
|
|
for(var i=0; i < web_o.length; i++) { |
|
|
if(web_o[i](req, res, proxyRes, options)) { break; } |
|
|
} |
|
|
} |
|
|
|
|
|
if (!res.finished) { |
|
|
// Allow us to listen when the proxy has completed |
|
|
proxyRes.on('end', function () { |
|
|
if (server) server.emit('end', req, res, proxyRes); |
|
|
}); |
|
|
// We pipe to the response unless its expected to be handled by the user |
|
|
if (!options.selfHandleResponse) proxyRes.pipe(res); |
|
|
} else { |
|
|
if (server) server.emit('end', req, res, proxyRes); |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
};
|
|
|
|