internals.Client.prototype.request = function (method, url, options, callback, _trace) {
var self = this;
options = Hoek.applyToDefaultsWithShallow(options || {}, this._defaults, ['agent', 'payload', 'downstreamRes']);
Hoek.assert(options.payload === null || options.payload === undefined || typeof options.payload === 'string' ||
options.payload instanceof Stream || Buffer.isBuffer(options.payload),
'options.payload must be a string, a Buffer, or a Stream');
Hoek.assert((options.agent === undefined || options.agent === null) || (typeof options.rejectUnauthorized !== 'boolean'),
'options.agent cannot be set to an Agent at the same time as options.rejectUnauthorized is set');
if (options.baseUrl) {
url = internals.resolveUrl(options.baseUrl, url);
}
var uri = Url.parse(url);
var timeoutId;
uri.method = method.toUpperCase();
uri.headers = options.headers;
var payloadSupported = (uri.method !== 'GET' && uri.method !== 'HEAD' && options.payload !== null && options.payload !== undefined);
if (payloadSupported &&
(typeof options.payload === 'string' || Buffer.isBuffer(options.payload))) {
uri.headers = Hoek.clone(uri.headers) || {};
uri.headers['Content-Length'] = Buffer.isBuffer(options.payload) ? options.payload.length : Buffer.byteLength(options.payload);
}
var redirects = (options.hasOwnProperty('redirects') ? options.redirects : false); // Needed to allow 0 as valid value when passed recursively
_trace = (_trace || []);
_trace.push({ method: uri.method, url: url });
var client = (uri.protocol === 'https:' ? Https : Http);
if (options.rejectUnauthorized !== undefined && uri.protocol === 'https:') {
uri.agent = options.rejectUnauthorized ? this.agents.https : this.agents.httpsAllowUnauthorized;
}
else if (options.agent || options.agent === false) {
uri.agent = options.agent;
}
else {
uri.agent = uri.protocol === 'https:' ? this.agents.https : this.agents.http;
}
if (options.secureProtocol !== undefined) {
uri.secureProtocol = options.secureProtocol;
}
var start = Date.now();
var req = client.request(uri);
var shadow = null; // A copy of the streamed request payload when redirects are enabled
// Register handlers
var finish = function (err, res) {
if (!callback || err) {
req.abort();
}
req.removeListener('response', onResponse);
req.removeListener('error', onError);
req.on('error', Hoek.ignore);
clearTimeout(timeoutId);
self.emit('response', err, req, res, start, uri);
if (callback) {
return callback(err, res);
}
};
finish = Hoek.once(finish);
var onError = function (err) {
err.trace = _trace;
return finish(Boom.badGateway('Client request error', err));
};
req.once('error', onError);
var onResponse = function (res) {
// Pass-through response
if (redirects === false ||
[301, 302, 307, 308].indexOf(res.statusCode) === -1) {
return finish(null, res);
}
// Redirection
var redirectMethod = (res.statusCode === 301 || res.statusCode === 302 ? 'GET' : uri.method);
var location = res.headers.location;
res.destroy();
if (redirects === 0) {
return finish(Boom.badGateway('Maximum redirections reached', _trace));
}
if (!location) {
return finish(Boom.badGateway('Received redirection without location', _trace));
}
if (!/^https?:/i.test(location)) {
location = Url.resolve(uri.href, location);
}
var redirectOptions = {
headers: options.headers,
payload: shadow || options.payload, // shadow must be ready at this point if set
redirects: --redirects
};
return self.request(redirectMethod, location, redirectOptions, finish, _trace);
};
req.once('response', onResponse);
if (options.timeout) {
timeoutId = setTimeout(function () {
return finish(Boom.gatewayTimeout('Client request timeout'));
}, options.timeout);
}
// Write payload
if (payloadSupported) {
if (options.payload instanceof Stream) {
var stream = options.payload;
if (redirects) {
var collector = new Tap();
collector.once('finish', function () {
shadow = collector.collect();
});
stream = options.payload.pipe(collector);
}
stream.pipe(req);
return;
}
req.write(options.payload);
}
// Custom abort method to detect early aborts
var _abort = req.abort;
var aborted = false;
req.abort = function () {
if (!aborted && !req.res && !req.socket) {
process.nextTick(function () {
// Fake an ECONNRESET error
var error = new Error('socket hang up');
error.code = 'ECONNRESET';
finish(error);
});
}
aborted = true;
return _abort.call(req);
};
// Finalize request
req.end();
return req;
};
exports = module.exports = internals.Route = function (options, connection, plugin) {
// Apply plugin environment (before schema validation)
var realm = plugin.realm;
if (realm.modifiers.route.vhost ||
realm.modifiers.route.prefix) {
options = Hoek.cloneWithShallow(options, ['config']); // config is left unchanged
options.path = (realm.modifiers.route.prefix ? realm.modifiers.route.prefix + (options.path !== '/' ? options.path : '') : options.path);
options.vhost = realm.modifiers.route.vhost || options.vhost;
}
// Setup and validate route configuration
Hoek.assert(options.path, 'Route missing path');
Hoek.assert(options.handler || (options.config && options.config.handler), 'Missing or undefined handler:', options.method, options.path);
Hoek.assert(!!options.handler ^ !!(options.config && options.config.handler), 'Handler must only appear once:', options.method, options.path); // XOR
Hoek.assert(options.path === '/' || options.path[options.path.length - 1] !== '/' || !connection.settings.router.stripTrailingSlash, 'Path cannot end with a trailing slash when connection configured to strip:', options.method, options.path);
Hoek.assert(/^[a-zA-Z0-9!#\$%&'\*\+\-\.^_`\|~]+$/.test(options.method), 'Invalid method name:', options.method, options.path);
options = Schema.apply('route', options, options.path);
var handler = options.handler || options.config.handler;
var method = options.method.toLowerCase();
Hoek.assert(method !== 'head', 'Method name not allowed:', options.method, options.path);
// Apply settings in order: {connection} <- {handler} <- {realm} <- {route}
var handlerDefaults = Handler.defaults(method, handler, connection.server);
var base = Hoek.applyToDefaultsWithShallow(connection.settings.routes, handlerDefaults, ['bind']);
base = Hoek.applyToDefaultsWithShallow(base, realm.settings, ['bind']);
this.settings = Hoek.applyToDefaultsWithShallow(base, options.config || {}, ['bind']);
this.settings.handler = handler;
this.settings = Schema.apply('routeConfig', this.settings, options.path);
var socketTimeout = (this.settings.timeout.socket === undefined ? 2 * 60 * 1000 : this.settings.timeout.socket);
Hoek.assert(!this.settings.timeout.server || !socketTimeout || this.settings.timeout.server < socketTimeout, 'Server timeout must be shorter than socket timeout:', options.path);
Hoek.assert(!this.settings.payload.timeout || !socketTimeout || this.settings.payload.timeout < socketTimeout, 'Payload timeout must be shorter than socket timeout:', options.path);
this.connection = connection;
this.server = connection.server;
this.path = options.path;
this.method = method;
this.plugin = plugin;
this.public = {
method: this.method,
path: this.path,
vhost: this.vhost,
realm: this.plugin.realm,
settings: this.settings
};
this.settings.vhost = options.vhost;
this.settings.plugins = this.settings.plugins || {}; // Route-specific plugins settings, namespaced using plugin name
this.settings.app = this.settings.app || {}; // Route-specific application settings
// Path parsing
this._analysis = this.connection._router.analyze(this.path);
this.params = this._analysis.params;
this.fingerprint = this._analysis.fingerprint;
// Validation
var validation = this.settings.validate;
if (this.method === 'get') {
// Assert on config, not on merged settings
Hoek.assert(!options.config || !options.config.payload, 'Cannot set payload settings on HEAD or GET request:', options.path);
Hoek.assert(!options.config || !options.config.validate || !options.config.validate.payload, 'Cannot validate HEAD or GET requests:', options.path);
validation.payload = null;
}
['headers', 'params', 'query', 'payload'].forEach(function (type) {
validation[type] = internals.compileRule(validation[type]);
});
if (this.settings.response.schema !== undefined ||
this.settings.response.status) {
var rule = this.settings.response.schema;
this.settings.response.status = this.settings.response.status || {};
var statuses = Object.keys(this.settings.response.status);
if (rule === true && !statuses.length) {
this.settings.response = null;
}
else {
this.settings.response.schema = internals.compileRule(rule);
for (var i = 0, il = statuses.length; i < il; ++i) {
var code = statuses[i];
this.settings.response.status[code] = internals.compileRule(this.settings.response.status[code]);
}
}
}
else {
this.settings.response = null;
}
// Payload parsing
if (this.method === 'get') {
this.settings.payload = null;
}
else {
if (this.settings.payload.allow) {
this.settings.payload.allow = [].concat(this.settings.payload.allow);
}
}
Hoek.assert(!this.settings.validate.payload || this.settings.payload.parse, 'Route payload must be set to \'parse\' when payload validation enabled:', options.method, options.path);
Hoek.assert(!this.settings.jsonp || typeof this.settings.jsonp === 'string', 'Bad route JSONP parameter name:', options.path);
// Authentication configuration
this.settings.auth = this.connection.auth._setupRoute(this.settings.auth, options.path);
// Cache
if (this.method === 'get' &&
(this.settings.cache.expiresIn || this.settings.cache.expiresAt)) {
this.settings.cache._statuses = Hoek.mapToObject(this.settings.cache.statuses);
this._cache = new Catbox.Policy({ expiresIn: this.settings.cache.expiresIn, expiresAt: this.settings.cache.expiresAt });
}
// CORS
if (this.settings.cors) {
this.settings.cors = Hoek.applyToDefaults(Defaults.cors, this.settings.cors);
var cors = this.settings.cors;
this.settings._cors = {
headers: cors.headers.concat(cors.additionalHeaders).join(','),
methods: cors.methods.concat(cors.additionalMethods).join(','),
exposedHeaders: cors.exposedHeaders.concat(cors.additionalExposedHeaders).join(',')
};
var _cors = this.settings._cors;
if (cors.origin.length) {
_cors.origin = {
any: false,
qualified: [],
qualifiedString: '',
wildcards: []
};
if (cors.origin.indexOf('*') !== -1) {
Hoek.assert(cors.origin.length === 1, 'Cannot specify cors.origin * together with other values');
_cors.origin.any = true;
}
else {
for (var c = 0, cl = cors.origin.length; c < cl; ++c) {
var origin = cors.origin[c];
if (origin.indexOf('*') !== -1) {
_cors.origin.wildcards.push(new RegExp('^' + Hoek.escapeRegex(origin).replace(/\\\*/g, '.*').replace(/\\\?/g, '.') + '$'));
}
else {
_cors.origin.qualified.push(origin);
}
}
Hoek.assert(cors.matchOrigin || !_cors.origin.wildcards.length, 'Cannot include wildcard origin values with matchOrigin disabled');
_cors.origin.qualifiedString = _cors.origin.qualified.join(' ');
}
}
}
// Security
if (this.settings.security) {
this.settings.security = Hoek.applyToDefaults(Defaults.security, this.settings.security);
var security = this.settings.security;
if (security.hsts) {
if (security.hsts === true) {
security._hsts = 'max-age=15768000';
}
else if (typeof security.hsts === 'number') {
security._hsts = 'max-age=' + security.hsts;
}
else {
security._hsts = 'max-age=' + (security.hsts.maxAge || 15768000);
if (security.hsts.includeSubdomains || security.hsts.includeSubDomains) {
security._hsts += '; includeSubDomains';
}
if (security.hsts.preload) {
security._hsts += '; preload';
}
}
}
if (security.xframe) {
if (security.xframe === true) {
security._xframe = 'DENY';
}
else if (typeof security.xframe === 'string') {
security._xframe = security.xframe.toUpperCase();
}
else if (security.xframe.rule === 'allow-from') {
if (!security.xframe.source) {
security._xframe = 'SAMEORIGIN';
}
else {
security._xframe = 'ALLOW-FROM ' + security.xframe.source;
}
}
else {
security._xframe = security.xframe.rule.toUpperCase();
}
}
}
// Handler
this.settings.handler = Handler.configure(this.settings.handler, this);
this._prerequisites = Handler.prerequisites(this.settings.pre, this.server);
// Route lifecycle
this._extensions = {
onPreAuth: this._combineExtensions('onPreAuth'),
onPostAuth: this._combineExtensions('onPostAuth'),
onPreHandler: this._combineExtensions('onPreHandler'),
onPostHandler: this._combineExtensions('onPostHandler'),
onPreResponse: this._combineExtensions('onPreResponse')
};
this._cycle = null;
this.rebuild();
};
internals.Client.prototype.read = function (res, options, callback) {
options = Hoek.applyToDefaultsWithShallow(options || {}, this._defaults, ['agent', 'payload', 'downstreamRes']);
// Set stream timeout
var clientTimeout = options.timeout;
var clientTimeoutId = null;
if (clientTimeout &&
clientTimeout > 0) {
clientTimeoutId = setTimeout(function () {
finish(Boom.clientTimeout());
}, clientTimeout);
}
// Finish once
var finish = function (err, buffer) {
clearTimeout(clientTimeoutId);
reader.removeListener('error', onReaderError);
reader.removeListener('finish', onReaderFinish);
res.removeListener('error', onResError);
res.removeListener('close', onResClose);
res.on('error', Hoek.ignore);
if (err || !options.json) {
return callback(err, buffer);
}
// Parse JSON
var result;
if (buffer.length === 0) {
return callback(null, null);
}
if (options.json === 'force') {
result = internals.tryParseBuffer(buffer);
return callback(result.err, result.json);
}
// mode is "smart" or true
var contentType = (res.headers && res.headers['content-type']) || '';
var mime = contentType.split(';')[0].trim().toLowerCase();
if (!internals.jsonRegex.test(mime)) {
return callback(null, buffer);
}
result = internals.tryParseBuffer(buffer);
return callback(result.err, result.json);
};
finish = Hoek.once(finish);
// Hander errors
var onResError = function (err) {
return finish(Boom.internal('Payload stream error', err));
};
var onResClose = function () {
return finish(Boom.internal('Payload stream closed prematurely'));
};
res.once('error', onResError);
res.once('close', onResClose);
// Read payload
var reader = new Recorder({ maxBytes: options.maxBytes });
var onReaderError = function (err) {
res.destroy();
return finish(err);
};
reader.once('error', onReaderError);
var onReaderFinish = function () {
return finish(null, reader.collect());
};
reader.once('finish', onReaderFinish);
res.pipe(reader);
};
internals.Client.prototype.defaults = function (options) {
options = Hoek.applyToDefaultsWithShallow(options, this._defaults, ['agent', 'payload', 'downstreamRes']);
return new internals.Client(options);
};
internals.Client.prototype.request = function (method, url, options, callback, _trace) {
options = Hoek.applyToDefaultsWithShallow(this._defaults, options || {}, internals.shallowOptions);
Hoek.assert(options.payload === undefined || typeof options.payload === 'string' || typeof options.payload === 'object',
'options.payload must be a string, a Buffer, a Stream, or an Object');
Hoek.assert((options.agent === undefined || options.agent === null) || (typeof options.rejectUnauthorized !== 'boolean'),
'options.agent cannot be set to an Agent at the same time as options.rejectUnauthorized is set');
Hoek.assert(options.beforeRedirect === undefined || options.beforeRedirect === null || typeof options.beforeRedirect === 'function',
'options.beforeRedirect must be a function');
Hoek.assert(options.redirected === undefined || options.redirected === null || typeof options.redirected === 'function',
'options.redirected must be a function');
options.beforeRedirect = options.beforeRedirect || ((redirectMethod, statusCode, location, resHeaders, redirectOptions, next) => next());
if (options.baseUrl) {
url = internals.resolveUrl(options.baseUrl, url);
delete options.baseUrl;
}
const uri = Url.parse(url);
if (options.socketPath) {
uri.socketPath = options.socketPath;
delete options.socketPath;
}
uri.method = method.toUpperCase();
uri.headers = options.headers || {};
const hasContentLength = Object.keys(uri.headers).some((key) => {
return key.toLowerCase() === 'content-length';
});
if (options.payload && typeof options.payload === 'object' && !(options.payload instanceof Stream) && !Buffer.isBuffer(options.payload)) {
options.payload = JSON.stringify(options.payload);
uri.headers['content-type'] = uri.headers['content-type'] || 'application/json';
}
const payloadSupported = (uri.method !== 'GET' && uri.method !== 'HEAD' && options.payload !== null && options.payload !== undefined);
if (payloadSupported &&
(typeof options.payload === 'string' || Buffer.isBuffer(options.payload)) &&
(!hasContentLength)) {
uri.headers = Hoek.clone(uri.headers);
uri.headers['content-length'] = Buffer.isBuffer(options.payload) ? options.payload.length : Buffer.byteLength(options.payload);
}
let redirects = (options.hasOwnProperty('redirects') ? options.redirects : false); // Needed to allow 0 as valid value when passed recursively
_trace = (_trace || []);
_trace.push({ method: uri.method, url });
const client = (uri.protocol === 'https:' ? Https : Http);
if (options.rejectUnauthorized !== undefined && uri.protocol === 'https:') {
uri.agent = options.rejectUnauthorized ? this.agents.https : this.agents.httpsAllowUnauthorized;
}
else if (options.agent || options.agent === false) {
uri.agent = options.agent;
}
else {
uri.agent = uri.protocol === 'https:' ? this.agents.https : this.agents.http;
}
if (options.secureProtocol !== undefined) {
uri.secureProtocol = options.secureProtocol;
}
this.emit('request', uri, options);
const start = Date.now();
const req = client.request(uri);
let shadow = null; // A copy of the streamed request payload when redirects are enabled
let timeoutId;
const onError = (err) => {
err.trace = _trace;
return finishOnce(Boom.badGateway('Client request error', err));
};
req.once('error', onError);
const onResponse = (res) => {
// Pass-through response
const statusCode = res.statusCode;
const redirectMethod = internals.redirectMethod(statusCode, uri.method, options);
if (redirects === false ||
!redirectMethod) {
return finishOnce(null, res);
}
// Redirection
res.destroy();
if (redirects === 0) {
return finishOnce(Boom.badGateway('Maximum redirections reached', _trace));
}
let location = res.headers.location;
if (!location) {
return finishOnce(Boom.badGateway('Received redirection without location', _trace));
}
if (!/^https?:/i.test(location)) {
location = Url.resolve(uri.href, location);
}
const redirectOptions = Hoek.cloneWithShallow(options, internals.shallowOptions);
redirectOptions.payload = shadow || options.payload; // shadow must be ready at this point if set
redirectOptions.redirects = --redirects;
return options.beforeRedirect(redirectMethod, statusCode, location, res.headers, redirectOptions, () => {
const redirectReq = this.request(redirectMethod, location, redirectOptions, finishOnce, _trace);
if (options.redirected) {
options.redirected(statusCode, location, redirectReq);
}
});
};
// Register handlers
const finish = (err, res) => {
if (err) {
req.abort();
}
req.removeListener('response', onResponse);
req.removeListener('error', onError);
req.on('error', Hoek.ignore);
clearTimeout(timeoutId);
this.emit('response', err, req, res, start, uri);
if (callback) {
return callback(err, res);
}
};
const finishOnce = Hoek.once(finish);
req.once('response', onResponse);
if (options.timeout) {
timeoutId = setTimeout(() => {
return finishOnce(Boom.gatewayTimeout('Client request timeout'));
}, options.timeout);
delete options.timeout;
}
// Custom abort method to detect early aborts
const _abort = req.abort;
let aborted = false;
req.abort = () => {
if (!aborted && !req.res && !req.socket) {
process.nextTick(() => {
// Fake an ECONNRESET error
const error = new Error('socket hang up');
error.code = 'ECONNRESET';
finishOnce(error);
});
}
aborted = true;
return _abort.call(req);
};
// Write payload
if (payloadSupported) {
if (options.payload instanceof Stream) {
let stream = options.payload;
if (redirects) {
const collector = new Tap();
collector.once('finish', () => {
shadow = collector.collect();
});
stream = options.payload.pipe(collector);
}
stream.pipe(req);
return req;
}
req.write(options.payload);
}
// Finalize request
req.end();
return req;
};
exports = module.exports = internals.Route = function (route, connection, plugin, options) {
options = options || {};
// Apply plugin environment (before schema validation)
const realm = plugin.realm;
if (realm.modifiers.route.vhost ||
realm.modifiers.route.prefix) {
route = Hoek.cloneWithShallow(route, ['config']); // config is left unchanged
route.path = (realm.modifiers.route.prefix ? realm.modifiers.route.prefix + (route.path !== '/' ? route.path : '') : route.path);
route.vhost = realm.modifiers.route.vhost || route.vhost;
}
// Setup and validate route configuration
Hoek.assert(route.path, 'Route missing path');
const routeDisplay = route.method + ' ' + route.path;
Hoek.assert(route.handler || (route.config && route.config.handler), 'Missing or undefined handler:', routeDisplay);
Hoek.assert(!!route.handler ^ !!(route.config && route.config.handler), 'Handler must only appear once:', routeDisplay); // XOR
Hoek.assert(route.path === '/' || route.path[route.path.length - 1] !== '/' || !connection.settings.router.stripTrailingSlash, 'Path cannot end with a trailing slash when connection configured to strip:', routeDisplay);
route = Schema.apply('route', route, routeDisplay);
const handler = route.handler || route.config.handler;
const method = route.method.toLowerCase();
Hoek.assert(method !== 'head', 'Method name not allowed:', routeDisplay);
// Apply settings in order: {connection} <- {handler} <- {realm} <- {route}
const handlerDefaults = Handler.defaults(method, handler, connection.server);
let base = Hoek.applyToDefaultsWithShallow(connection.settings.routes, handlerDefaults, ['bind']);
base = Hoek.applyToDefaultsWithShallow(base, realm.settings, ['bind']);
this.settings = Hoek.applyToDefaultsWithShallow(base, route.config || {}, ['bind']);
this.settings.handler = handler;
this.settings = Schema.apply('routeConfig', this.settings, routeDisplay);
const socketTimeout = (this.settings.timeout.socket === undefined ? 2 * 60 * 1000 : this.settings.timeout.socket);
Hoek.assert(!this.settings.timeout.server || !socketTimeout || this.settings.timeout.server < socketTimeout, 'Server timeout must be shorter than socket timeout:', routeDisplay);
Hoek.assert(!this.settings.payload.timeout || !socketTimeout || this.settings.payload.timeout < socketTimeout, 'Payload timeout must be shorter than socket timeout:', routeDisplay);
this.connection = connection;
this.server = connection.server;
this.path = route.path;
this.method = method;
this.plugin = plugin;
this.settings.vhost = route.vhost;
this.settings.plugins = this.settings.plugins || {}; // Route-specific plugins settings, namespaced using plugin name
this.settings.app = this.settings.app || {}; // Route-specific application settings
// Path parsing
this._special = !!options.special;
this._analysis = this.connection._router.analyze(this.path);
this.params = this._analysis.params;
this.fingerprint = this._analysis.fingerprint;
this.public = {
method: this.method,
path: this.path,
vhost: this.vhost,
realm: this.plugin.realm,
settings: this.settings,
fingerprint: this.fingerprint
};
// Validation
const validation = this.settings.validate;
if (this.method === 'get') {
// Assert on config, not on merged settings
Hoek.assert(!route.config || !route.config.payload, 'Cannot set payload settings on HEAD or GET request:', routeDisplay);
Hoek.assert(!route.config || !route.config.validate || !route.config.validate.payload, 'Cannot validate HEAD or GET requests:', routeDisplay);
validation.payload = null;
}
['headers', 'params', 'query', 'payload'].forEach((type) => {
validation[type] = Validation.compile(validation[type]);
});
if (this.settings.response.schema !== undefined ||
this.settings.response.status) {
this.settings.response._validate = true;
const rule = this.settings.response.schema;
this.settings.response.status = this.settings.response.status || {};
const statuses = Object.keys(this.settings.response.status);
if (rule === true &&
!statuses.length) {
this.settings.response._validate = false;
}
else {
this.settings.response.schema = Validation.compile(rule);
for (let i = 0; i < statuses.length; ++i) {
const code = statuses[i];
this.settings.response.status[code] = Validation.compile(this.settings.response.status[code]);
}
}
}
// Payload parsing
if (this.method === 'get') {
this.settings.payload = null;
}
else {
if (this.settings.payload.allow) {
this.settings.payload.allow = [].concat(this.settings.payload.allow);
}
}
Hoek.assert(!this.settings.validate.payload || this.settings.payload.parse, 'Route payload must be set to \'parse\' when payload validation enabled:', routeDisplay);
Hoek.assert(!this.settings.jsonp || typeof this.settings.jsonp === 'string', 'Bad route JSONP parameter name:', routeDisplay);
// Authentication configuration
this.settings.auth = (this._special ? false : this.connection.auth._setupRoute(this.settings.auth, route.path));
// Cache
if (this.method === 'get' &&
(this.settings.cache.expiresIn || this.settings.cache.expiresAt)) {
this.settings.cache._statuses = Hoek.mapToObject(this.settings.cache.statuses);
this._cache = new Catbox.Policy({ expiresIn: this.settings.cache.expiresIn, expiresAt: this.settings.cache.expiresAt });
}
// CORS
this.settings.cors = Cors.route(this.settings.cors);
// Security
if (this.settings.security) {
this.settings.security = Hoek.applyToDefaults(Defaults.security, this.settings.security);
const security = this.settings.security;
if (security.hsts) {
if (security.hsts === true) {
security._hsts = 'max-age=15768000';
}
else if (typeof security.hsts === 'number') {
security._hsts = 'max-age=' + security.hsts;
}
else {
security._hsts = 'max-age=' + (security.hsts.maxAge || 15768000);
if (security.hsts.includeSubdomains || security.hsts.includeSubDomains) {
security._hsts = security._hsts + '; includeSubDomains';
}
if (security.hsts.preload) {
security._hsts = security._hsts + '; preload';
}
}
}
if (security.xframe) {
if (security.xframe === true) {
security._xframe = 'DENY';
}
else if (typeof security.xframe === 'string') {
security._xframe = security.xframe.toUpperCase();
}
else if (security.xframe.rule === 'allow-from') {
if (!security.xframe.source) {
security._xframe = 'SAMEORIGIN';
}
else {
security._xframe = 'ALLOW-FROM ' + security.xframe.source;
}
}
else {
security._xframe = security.xframe.rule.toUpperCase();
}
}
}
// Handler
this.settings.handler = Handler.configure(this.settings.handler, this);
this._prerequisites = Handler.prerequisitesConfig(this.settings.pre, this.server);
// Route lifecycle
this._extensions = {
onPreResponse: this._combineExtensions('onPreResponse')
};
if (this._special) {
this._cycle = [Handler.execute];
return;
}
this._extensions.onPreAuth = this._combineExtensions('onPreAuth');
this._extensions.onPostAuth = this._combineExtensions('onPostAuth');
this._extensions.onPreHandler = this._combineExtensions('onPreHandler');
this._extensions.onPostHandler = this._combineExtensions('onPostHandler');
this.rebuild();
};
internals.Client.prototype.read = function (res, options, callback) {
options = Hoek.applyToDefaultsWithShallow(options || {}, this._defaults, internals.shallowOptions);
// Set stream timeout
const clientTimeout = options.timeout;
let clientTimeoutId = null;
// Finish once
const finish = (err, buffer) => {
clearTimeout(clientTimeoutId);
reader.removeListener('error', onReaderError);
reader.removeListener('finish', onReaderFinish);
res.removeListener('error', onResError);
res.removeListener('close', onResClose);
res.on('error', Hoek.ignore);
if (err ||
!options.json) {
return callback(err, buffer);
}
// Parse JSON
let result;
if (buffer.length === 0) {
return callback(null, null);
}
if (options.json === 'force') {
result = internals.tryParseBuffer(buffer);
return callback(result.err, result.json);
}
// mode is "smart" or true
const contentType = (res.headers && res.headers['content-type']) || '';
const mime = contentType.split(';')[0].trim().toLowerCase();
if (!internals.jsonRegex.test(mime)) {
return callback(null, buffer);
}
result = internals.tryParseBuffer(buffer);
return callback(result.err, result.json);
};
const finishOnce = Hoek.once(finish);
if (clientTimeout &&
clientTimeout > 0) {
clientTimeoutId = setTimeout(() => {
finishOnce(Boom.clientTimeout());
}, clientTimeout);
}
// Hander errors
const onResError = (err) => {
return finishOnce(Boom.internal('Payload stream error', err));
};
const onResClose = () => {
return finishOnce(Boom.internal('Payload stream closed prematurely'));
};
res.once('error', onResError);
res.once('close', onResClose);
// Read payload
const reader = new Recorder({ maxBytes: options.maxBytes });
const onReaderError = (err) => {
if (res.destroy) { // GZip stream has no destroy() method
res.destroy();
}
return finishOnce(err);
};
reader.once('error', onReaderError);
const onReaderFinish = () => {
return finishOnce(null, reader.collect());
};
reader.once('finish', onReaderFinish);
res.pipe(reader);
};
internals.Client.prototype.defaults = function (options) {
options = Hoek.applyToDefaultsWithShallow(options, this._defaults, internals.shallowOptions);
return new internals.Client(options);
};
extensions.forEach((extension) => {
const config = engines[extension];
const engine = {};
if (config.compile &&
typeof config.compile === 'function') {
engine.module = config;
engine.config = defaults;
}
else {
Joi.assert(config, internals.schema.view);
engine.module = config.module;
engine.config = Hoek.applyToDefaultsWithShallow(defaults, config, ['module']);
}
engine.suffix = '.' + extension;
engine.compileFunc = engine.module.compile;
if (engine.config.compileMode === 'sync') {
engine.compileFunc = function (str, opt, next) {
let compiled = null;
try {
compiled = engine.module.compile(str, opt);
}
catch (err) {
return next(err);
}
const renderer = function (context, runtimeOptions, renderNext) {
let rendered = null;
try {
rendered = compiled(context, runtimeOptions);
}
catch (err) {
return renderNext(err);
}
return renderNext(null, rendered);
};
return next(null, renderer);
};
}
if (engine.config.isCached) {
engine.cache = {};
}
// When a prepare function is provided, state needs to be initialized before trying to compile and render
engine.ready = !(engine.module.prepare && typeof engine.module.prepare === 'function');
// Load partials and helpers
this._loadPartials(engine);
this._loadHelpers(engine);
// Set engine
this._engines[extension] = engine;
});
exports = module.exports = internals.Manager = function (options) {
Joi.assert(options, internals.schema.manager);
// Save non-defaults values
const engines = options.engines;
const defaultExtension = options.defaultExtension;
// Clone options
const defaults = Hoek.applyToDefaultsWithShallow(internals.defaults, options, ['engines', 'context']);
delete defaults.engines;
delete defaults.defaultExtension;
// Prepare manager state
const extensions = Object.keys(engines);
Hoek.assert(extensions.length, 'Views manager requires at least one registered extension handler');
this._context = defaults.context;
this._engines = {};
this._defaultExtension = defaultExtension || (extensions.length === 1 ? extensions[0] : '');
// Load engines
extensions.forEach((extension) => {
const config = engines[extension];
const engine = {};
if (config.compile &&
typeof config.compile === 'function') {
engine.module = config;
engine.config = defaults;
}
else {
Joi.assert(config, internals.schema.view);
engine.module = config.module;
engine.config = Hoek.applyToDefaultsWithShallow(defaults, config, ['module']);
}
engine.suffix = '.' + extension;
engine.compileFunc = engine.module.compile;
if (engine.config.compileMode === 'sync') {
engine.compileFunc = function (str, opt, next) {
let compiled = null;
try {
compiled = engine.module.compile(str, opt);
}
catch (err) {
return next(err);
}
const renderer = function (context, runtimeOptions, renderNext) {
let rendered = null;
try {
rendered = compiled(context, runtimeOptions);
}
catch (err) {
return renderNext(err);
}
return renderNext(null, rendered);
};
return next(null, renderer);
};
}
if (engine.config.isCached) {
engine.cache = {};
}
// When a prepare function is provided, state needs to be initialized before trying to compile and render
engine.ready = !(engine.module.prepare && typeof engine.module.prepare === 'function');
// Load partials and helpers
this._loadPartials(engine);
this._loadHelpers(engine);
// Set engine
this._engines[extension] = engine;
});
};
exports = module.exports = internals.Server = function (/* host, port, options */) { // all optional
Hoek.assert(this.constructor === internals.Server, 'Server must be instantiated using new');
var Pack = require('./pack'); // Delayed required to avoid circular dependencies
// Register as event emitter
Events.EventEmitter.call(this);
// Validate arguments
Hoek.assert(arguments.length <= 4, 'Too many arguments'); // 4th is for internal Pack usage
var argMap = {
string: 'host',
number: 'port',
object: 'options'
};
var args = {};
for (var a = 0, al = arguments.length; a < al; ++a) {
var argVal = arguments[a];
if (argVal === undefined) {
continue;
}
if (argVal instanceof Pack) {
args.pack = arguments[a];
continue;
}
var type = typeof argVal;
if (type === 'string' && isFinite(+argVal)) {
type = 'number';
argVal = +argVal;
}
var key = argMap[type];
Hoek.assert(key, 'Bad server constructor arguments: no match for arg type:', type);
Hoek.assert(!args[key], 'Bad server constructor arguments: duplicated arg type:', type, '(values: `' + args[key] + '`, `' + argVal + '`)');
args[key] = argVal;
}
this.settings = Hoek.applyToDefaultsWithShallow(Defaults.server, args.options || {}, ['app', 'plugins']);
Schema.assert('server', this.settings);
this.settings.labels = Hoek.unique([].concat(this.settings.labels)); // Convert string to array and removes duplicates
// Set basic configuration
this._unixDomainSocket = (args.host && args.host.indexOf('/') !== -1);
this._windowsNamedPipe = (args.host && args.host.indexOf('\\\\.\\pipe\\') === 0);
Hoek.assert(!this._unixDomainSocket || args.port === undefined, 'Cannot specify port with a UNIX domain socket');
Hoek.assert(!this._windowsNamedPipe || args.port === undefined, 'Cannot specify port with a Windows named pipe');
this._host = (args.host ? (this._unixDomainSocket ? Path.resolve(args.host) : (this._windowsNamedPipe ? args.host : args.host.toLowerCase())) : '');
this._port = (args.port !== undefined ? args.port : (this.settings.tls ? 443 : 80));
this._onConnection = null; // Used to remove event listener on stop
Hoek.assert(!this.settings.location || this.settings.location.charAt(this.settings.location.length - 1) !== '/', 'Location setting must not contain a trailing \'/\'');
var socketTimeout = (this.settings.timeout.socket === undefined ? 2 * 60 * 1000 : this.settings.timeout.socket);
Hoek.assert(!this.settings.timeout.server || !socketTimeout || this.settings.timeout.server < socketTimeout, 'Server timeout must be shorter than socket timeout');
Hoek.assert(!this.settings.timeout.client || !socketTimeout || this.settings.timeout.client < socketTimeout, 'Client timeout must be shorter than socket timeout');
// Server facilities
this._started = false;
this.auth = new Auth(this);
this._etags = (this.settings.files.etagsCacheMaxSize ? new Inert.file.Etags(this.settings.files.etagsCacheMaxSize) : null);
this._views = null;
this._router = null;
Router.create(this); // Sets this._router
this._heavy = new Heavy(this.settings.load);
this.load = this._heavy.load;
/*
onRequest: New request, before handing over to the router (allows changes to the request method, url, etc.)
onPreAuth: After cookie parse and before authentication (skipped if state error)
onPostAuth: After authentication (and payload processing) and before validation (skipped if auth or payload error)
onPreHandler: After validation and body parsing, before route handler (skipped if auth or validation error)
onPostHandler: After route handler returns, before sending response (skipped if onPreHandler not called)
onPreResponse: Before response is sent (always called)
*/
this._ext = new Ext(['onRequest', 'onPreAuth', 'onPostAuth', 'onPreHandler', 'onPostHandler', 'onPreResponse']);
this._stateDefinitions = new Statehood.Definitions(this.settings.state.cookies);
this._registrations = {};
if (args.pack) {
this.pack = args.pack;
}
else {
this.pack = new Pack({ cache: this.settings.cache, debug: this.settings.debug });
this.pack._server(this);
}
this.plugins = {}; // Registered plugin APIs by plugin name
this.app = {}; // Place for application-specific state without conflicts with hapi, should not be used by plugins
this.methods = this.pack._methods.methods; // Method functions
// Generate CORS headers
this.settings.cors = Hoek.applyToDefaults(Defaults.cors, this.settings.cors);
if (this.settings.cors) {
this.settings.cors._headers = this.settings.cors.headers.concat(this.settings.cors.additionalHeaders).join(', ');
this.settings.cors._methods = this.settings.cors.methods.concat(this.settings.cors.additionalMethods).join(', ');
this.settings.cors._exposedHeaders = this.settings.cors.exposedHeaders.concat(this.settings.cors.additionalExposedHeaders).join(', ');
if (this.settings.cors.origin.length) {
this.settings.cors._origin = {
any: false,
qualified: [],
qualifiedString: '',
wildcards: []
};
if (this.settings.cors.origin.indexOf('*') !== -1) {
Hoek.assert(this.settings.cors.origin.length === 1, 'Cannot specify cors.origin * together with other values');
this.settings.cors._origin.any = true;
}
else {
for (var c = 0, cl = this.settings.cors.origin.length; c < cl; ++c) {
var origin = this.settings.cors.origin[c];
if (origin.indexOf('*') !== -1) {
this.settings.cors._origin.wildcards.push(new RegExp('^' + Hoek.escapeRegex(origin).replace(/\\\*/g, '.*').replace(/\\\?/g, '.') + '$'));
}
else {
this.settings.cors._origin.qualified.push(origin);
}
}
Hoek.assert(this.settings.cors.matchOrigin || !this.settings.cors._origin.wildcards.length, 'Cannot include wildcard origin values with matchOrigin disabled');
this.settings.cors._origin.qualifiedString = this.settings.cors._origin.qualified.join(' ');
}
}
}
// Generate security headers
this.settings.security = Hoek.applyToDefaults(Defaults.security, this.settings.security);
if (this.settings.security) {
if (this.settings.security.hsts) {
if (this.settings.security.hsts === true) {
this.settings.security._hsts = 'max-age=15768000';
}
else if (typeof this.settings.security.hsts === 'number') {
this.settings.security._hsts = 'max-age=' + this.settings.security.hsts;
}
else {
this.settings.security._hsts = 'max-age=' + (this.settings.security.hsts.maxAge || 15768000);
if (this.settings.security.hsts.includeSubdomains) {
this.settings.security._hsts += '; includeSubdomains';
}
}
}
if (this.settings.security.xframe) {
if (this.settings.security.xframe === true) {
this.settings.security._xframe = 'DENY';
}
else if (typeof this.settings.security.xframe === 'string') {
this.settings.security._xframe = this.settings.security.xframe.toUpperCase();
}
else if (this.settings.security.xframe.rule === 'allow-from') {
if (!this.settings.security.xframe.source) {
this.settings.security._xframe = 'SAMEORIGIN';
}
else {
this.settings.security._xframe = 'ALLOW-FROM ' + this.settings.security.xframe.source;
}
}
else {
this.settings.security._xframe = this.settings.security.xframe.rule.toUpperCase();
}
}
}
// Cache-control status map
this.settings._cacheControlStatus = Hoek.mapToObject(this.settings.cacheControlStatus);
// Create server
if (this.settings.tls) {
this.listener = Https.createServer(this.settings.tls, this._dispatch());
}
else {
this.listener = Http.createServer(this._dispatch());
}
// Server information
this.info = {
host: this._host || '0.0.0.0'
};
if (this._unixDomainSocket ||
this._windowsNamedPipe) {
this.info.port = 0;
this.info.protocol = (this._unixDomainSocket ? 'unix' : 'windows');
this.info.uri = this.info.protocol + ':' + this._host;
}
else {
this.info.port = this._port || 0;
this.info.protocol = (this.settings.tls ? 'https' : 'http');
if (this.info.port) {
this.info.uri = this.info.protocol + '://' + (this._host || Os.hostname() || 'localhost') + ':' + this.info.port;
}
}
};
constructor(route, server, options = {}) {
const core = server._core;
const realm = server.realm;
// Apply plugin environment (before schema validation)
if (realm.modifiers.route.vhost ||
realm.modifiers.route.prefix) {
route = Hoek.cloneWithShallow(route, ['options']); // options is left unchanged
route.path = (realm.modifiers.route.prefix ? realm.modifiers.route.prefix + (route.path !== '/' ? route.path : '') : route.path);
route.vhost = realm.modifiers.route.vhost || route.vhost;
}
// Setup and validate route configuration
Hoek.assert(route.path, 'Route missing path');
const routeDisplay = route.method + ' ' + route.path;
let config = route.options || route.config;
if (typeof config === 'function') {
config = config.call(realm.settings.bind, server);
}
Hoek.assert(route.handler || (config && config.handler), 'Missing or undefined handler:', routeDisplay);
Hoek.assert(!!route.handler ^ !!(config && config.handler), 'Handler must only appear once:', routeDisplay); // XOR
Hoek.assert(route.path === '/' || route.path[route.path.length - 1] !== '/' || !core.settings.router.stripTrailingSlash, 'Path cannot end with a trailing slash when configured to strip:', routeDisplay);
config = Config.enable(config);
route = Config.apply('route', route, routeDisplay);
const handler = route.handler || config.handler;
const method = route.method.toLowerCase();
Hoek.assert(method !== 'head', 'Method name not allowed:', routeDisplay);
// Apply settings in order: {server} <- {handler} <- {realm} <- {route}
const handlerDefaults = Handler.defaults(method, handler, core);
let base = Hoek.applyToDefaultsWithShallow(core.settings.routes, handlerDefaults, ['bind']);
base = Hoek.applyToDefaultsWithShallow(base, realm.settings, ['bind']);
this.settings = Hoek.applyToDefaultsWithShallow(base, config, ['bind', 'validate.headers', 'validate.payload', 'validate.params', 'validate.query']);
this.settings.handler = handler;
this.settings = Config.apply('routeConfig', this.settings, routeDisplay);
const socketTimeout = (this.settings.timeout.socket === undefined ? 2 * 60 * 1000 : this.settings.timeout.socket);
Hoek.assert(!this.settings.timeout.server || !socketTimeout || this.settings.timeout.server < socketTimeout, 'Server timeout must be shorter than socket timeout:', routeDisplay);
Hoek.assert(!this.settings.payload.timeout || !socketTimeout || this.settings.payload.timeout < socketTimeout, 'Payload timeout must be shorter than socket timeout:', routeDisplay);
this._core = core;
this.path = route.path;
this.method = method;
this.realm = realm;
this.settings.vhost = route.vhost;
this.settings.plugins = this.settings.plugins || {}; // Route-specific plugins settings, namespaced using plugin name
this.settings.app = this.settings.app || {}; // Route-specific application settings
// Path parsing
this._special = !!options.special;
this._analysis = this._core.router.analyze(this.path);
this.params = this._analysis.params;
this.fingerprint = this._analysis.fingerprint;
this.public = {
method: this.method,
path: this.path,
vhost: this.vhost,
realm,
settings: this.settings,
fingerprint: this.fingerprint,
auth: {
access: (request) => Auth.testAccess(request, this.public)
}
};
// Validation
const validation = this.settings.validate;
if (this.method === 'get') {
// Assert on config, not on merged settings
Hoek.assert(!config.payload, 'Cannot set payload settings on HEAD or GET request:', routeDisplay);
Hoek.assert(!config.validate || !config.validate.payload, 'Cannot validate HEAD or GET requests:', routeDisplay);
validation.payload = null;
}
Hoek.assert(!validation.params || this.params.length, 'Cannot set path parameters validations without path parameters:', routeDisplay);
['headers', 'params', 'query', 'payload'].forEach((type) => {
validation[type] = Validation.compile(validation[type]);
});
if (this.settings.response.schema !== undefined ||
this.settings.response.status) {
this.settings.response._validate = true;
const rule = this.settings.response.schema;
this.settings.response.status = this.settings.response.status || {};
const statuses = Object.keys(this.settings.response.status);
if (rule === true &&
!statuses.length) {
this.settings.response._validate = false;
}
else {
this.settings.response.schema = Validation.compile(rule);
for (let i = 0; i < statuses.length; ++i) {
const code = statuses[i];
this.settings.response.status[code] = Validation.compile(this.settings.response.status[code]);
}
}
}
// Payload parsing
if (this.method === 'get') {
this.settings.payload = null;
}
else {
this.settings.payload.decoders = this._core.compression._decoders; // Reference the shared object to keep up to date
}
Hoek.assert(!this.settings.validate.payload || this.settings.payload.parse, 'Route payload must be set to \'parse\' when payload validation enabled:', routeDisplay);
Hoek.assert(!this.settings.jsonp || typeof this.settings.jsonp === 'string', 'Bad route JSONP parameter name:', routeDisplay);
// Authentication configuration
this.settings.auth = (this._special ? false : this._core.auth._setupRoute(this.settings.auth, route.path));
// Cache
if (this.method === 'get' &&
typeof this.settings.cache === 'object' &&
(this.settings.cache.expiresIn || this.settings.cache.expiresAt)) {
this.settings.cache._statuses = Hoek.mapToObject(this.settings.cache.statuses);
this._cache = new Catbox.Policy({ expiresIn: this.settings.cache.expiresIn, expiresAt: this.settings.cache.expiresAt });
}
// CORS
this.settings.cors = Cors.route(this.settings.cors);
// Security
this.settings.security = Security.route(this.settings.security);
// Handler
this.settings.handler = Handler.configure(this.settings.handler, this);
this._prerequisites = Handler.prerequisitesConfig(this.settings.pre);
// Route lifecycle
this._extensions = {
onPreResponse: Ext.combine(this, 'onPreResponse')
};
if (this._special) {
this._cycle = [internals.drain, Handler.execute];
this.rebuild();
return;
}
this._extensions.onPreAuth = Ext.combine(this, 'onPreAuth');
this._extensions.onCredentials = Ext.combine(this, 'onCredentials');
this._extensions.onPostAuth = Ext.combine(this, 'onPostAuth');
this._extensions.onPreHandler = Ext.combine(this, 'onPreHandler');
this._extensions.onPostHandler = Ext.combine(this, 'onPostHandler');
this.rebuild();
}
extensions.forEach(function (extension) {
var config = engines[extension];
var engine = {};
if (config.compile &&
typeof config.compile === 'function') {
engine.module = config;
engine.config = defaults;
}
else {
Schema.assert('view', config);
engine.module = config.module;
engine.config = Hoek.applyToDefaultsWithShallow(defaults, config, ['module']);
}
engine.suffix = '.' + extension;
engine.compileFunc = engine.module.compile;
if (engine.config.compileMode === 'sync') {
engine.compileFunc = function (str, opt, next) {
var compiled = null;
try {
compiled = engine.module.compile(str, opt);
}
catch (err) {
return next(err);
}
var renderer = function (context, runtimeOptions, renderNext) {
var rendered = null;
try {
rendered = compiled(context, runtimeOptions);
}
catch (err) {
return renderNext(err);
}
renderNext(null, rendered);
};
next(null, renderer);
};
}
if (engine.config.isCached) {
engine.cache = {};
}
// Load partials and helpers
self._loadPartials(engine);
self._loadHelpers(engine);
// Set engine
self._engines[extension] = engine;
});
exports.Manager = internals.Manager = function (options, _override) {
var self = this;
// Save non-defaults values
var engines = options.engines;
var defaultExtension = options.defaultExtension;
// Clone options
var defaults = Hoek.applyToDefaultsWithShallow(Defaults.views, options, ['engines']);
if (_override) {
Hoek.merge(defaults, _override); // _override cannot contain non-clonable objects
}
delete defaults.engines;
delete defaults.defaultExtension;
// Prepare manager state
var extensions = Object.keys(engines);
Hoek.assert(extensions.length, 'Views manager requires at least one registered extension handler');
this._engines = {};
this._defaultExtension = defaultExtension || (extensions.length === 1 ? extensions[0] : '');
// Load engines
extensions.forEach(function (extension) {
var config = engines[extension];
var engine = {};
if (config.compile &&
typeof config.compile === 'function') {
engine.module = config;
engine.config = defaults;
}
else {
Schema.assert('view', config);
engine.module = config.module;
engine.config = Hoek.applyToDefaultsWithShallow(defaults, config, ['module']);
}
engine.suffix = '.' + extension;
engine.compileFunc = engine.module.compile;
if (engine.config.compileMode === 'sync') {
engine.compileFunc = function (str, opt, next) {
var compiled = null;
try {
compiled = engine.module.compile(str, opt);
}
catch (err) {
return next(err);
}
var renderer = function (context, runtimeOptions, renderNext) {
var rendered = null;
try {
rendered = compiled(context, runtimeOptions);
}
catch (err) {
return renderNext(err);
}
renderNext(null, rendered);
};
next(null, renderer);
};
}
if (engine.config.isCached) {
engine.cache = {};
}
// Load partials and helpers
self._loadPartials(engine);
self._loadHelpers(engine);
// Set engine
self._engines[extension] = engine;
});
};
internals.Client.prototype._read = function (res, options, callback) {
options = Hoek.applyToDefaultsWithShallow(this._defaults, options, internals.shallowOptions);
// Finish once
let clientTimeoutId = null;
const finish = (err, buffer) => {
clearTimeout(clientTimeoutId);
reader.removeListener('error', onReaderError);
reader.removeListener('finish', onReaderFinish);
res.removeListener('error', onResError);
res.removeListener('close', onResAborted);
res.removeListener('aborted', onResAborted);
res.on('error', Hoek.ignore);
if (err) {
return callback(err);
}
if (!options.json) {
return callback(null, buffer);
}
// Parse JSON
if (buffer.length === 0) {
return callback(null, null);
}
if (options.json === 'force') {
return internals.tryParseBuffer(buffer, callback);
}
// mode is "smart", "strict" or true
const contentType = (res.headers && internals.findHeader('content-type', res.headers)) || '';
const mime = contentType.split(';')[0].trim().toLowerCase();
if (!internals.jsonRegex.test(mime)) {
if (options.json === 'strict') {
return callback(Boom.notAcceptable('The content-type is not JSON compatible'));
}
return callback(null, buffer);
}
return internals.tryParseBuffer(buffer, callback);
};
const finishOnce = Hoek.once(finish);
const clientTimeout = options.timeout;
if (clientTimeout &&
clientTimeout > 0) {
clientTimeoutId = setTimeout(() => {
finishOnce(Boom.clientTimeout());
}, clientTimeout);
}
// Hander errors
const onResError = (err) => {
return finishOnce(err.isBoom ? err : Boom.internal('Payload stream error', err));
};
const onResAborted = () => {
return finishOnce(Boom.internal('Payload stream closed prematurely'));
};
res.once('error', onResError);
res.once('close', onResAborted);
res.once('aborted', onResAborted);
// Read payload
const reader = new Recorder({ maxBytes: options.maxBytes });
const onReaderError = (err) => {
if (res.destroy) { // GZip stream has no destroy() method
res.destroy();
}
return finishOnce(err);
};
reader.once('error', onReaderError);
const onReaderFinish = () => {
return finishOnce(null, reader.collect());
};
reader.once('finish', onReaderFinish);
if (options.gunzip) {
const contentEncoding = options.gunzip === 'force' ?
'gzip' :
(res.headers && internals.findHeader('content-encoding', res.headers)) || '';
if (/^(x-)?gzip(\s*,\s*identity)?$/.test(contentEncoding)) {
const gunzip = Zlib.createGunzip();
gunzip.once('error', onReaderError);
res.pipe(gunzip).pipe(reader);
return;
}
}
res.pipe(reader);
};