| /*! |
| * express |
| * Copyright(c) 2009-2013 TJ Holowaychuk |
| * Copyright(c) 2014-2015 Douglas Christopher Wilson |
| * MIT Licensed |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Module dependencies. |
| * @api private |
| */ |
| |
| var Buffer = require('safe-buffer').Buffer |
| var contentDisposition = require('content-disposition'); |
| var contentType = require('content-type'); |
| var deprecate = require('depd')('express'); |
| var flatten = require('array-flatten'); |
| var mime = require('send').mime; |
| var etag = require('etag'); |
| var proxyaddr = require('proxy-addr'); |
| var qs = require('qs'); |
| var querystring = require('querystring'); |
| |
| /** |
| * Return strong ETag for `body`. |
| * |
| * @param {String|Buffer} body |
| * @param {String} [encoding] |
| * @return {String} |
| * @api private |
| */ |
| |
| exports.etag = createETagGenerator({ weak: false }) |
| |
| /** |
| * Return weak ETag for `body`. |
| * |
| * @param {String|Buffer} body |
| * @param {String} [encoding] |
| * @return {String} |
| * @api private |
| */ |
| |
| exports.wetag = createETagGenerator({ weak: true }) |
| |
| /** |
| * Check if `path` looks absolute. |
| * |
| * @param {String} path |
| * @return {Boolean} |
| * @api private |
| */ |
| |
| exports.isAbsolute = function(path){ |
| if ('/' === path[0]) return true; |
| if (':' === path[1] && ('\\' === path[2] || '/' === path[2])) return true; // Windows device path |
| if ('\\\\' === path.substring(0, 2)) return true; // Microsoft Azure absolute path |
| }; |
| |
| /** |
| * Flatten the given `arr`. |
| * |
| * @param {Array} arr |
| * @return {Array} |
| * @api private |
| */ |
| |
| exports.flatten = deprecate.function(flatten, |
| 'utils.flatten: use array-flatten npm module instead'); |
| |
| /** |
| * Normalize the given `type`, for example "html" becomes "text/html". |
| * |
| * @param {String} type |
| * @return {Object} |
| * @api private |
| */ |
| |
| exports.normalizeType = function(type){ |
| return ~type.indexOf('/') |
| ? acceptParams(type) |
| : { value: mime.lookup(type), params: {} }; |
| }; |
| |
| /** |
| * Normalize `types`, for example "html" becomes "text/html". |
| * |
| * @param {Array} types |
| * @return {Array} |
| * @api private |
| */ |
| |
| exports.normalizeTypes = function(types){ |
| var ret = []; |
| |
| for (var i = 0; i < types.length; ++i) { |
| ret.push(exports.normalizeType(types[i])); |
| } |
| |
| return ret; |
| }; |
| |
| /** |
| * Generate Content-Disposition header appropriate for the filename. |
| * non-ascii filenames are urlencoded and a filename* parameter is added |
| * |
| * @param {String} filename |
| * @return {String} |
| * @api private |
| */ |
| |
| exports.contentDisposition = deprecate.function(contentDisposition, |
| 'utils.contentDisposition: use content-disposition npm module instead'); |
| |
| /** |
| * Parse accept params `str` returning an |
| * object with `.value`, `.quality` and `.params`. |
| * also includes `.originalIndex` for stable sorting |
| * |
| * @param {String} str |
| * @return {Object} |
| * @api private |
| */ |
| |
| function acceptParams(str, index) { |
| var parts = str.split(/ *; */); |
| var ret = { value: parts[0], quality: 1, params: {}, originalIndex: index }; |
| |
| for (var i = 1; i < parts.length; ++i) { |
| var pms = parts[i].split(/ *= */); |
| if ('q' === pms[0]) { |
| ret.quality = parseFloat(pms[1]); |
| } else { |
| ret.params[pms[0]] = pms[1]; |
| } |
| } |
| |
| return ret; |
| } |
| |
| /** |
| * Compile "etag" value to function. |
| * |
| * @param {Boolean|String|Function} val |
| * @return {Function} |
| * @api private |
| */ |
| |
| exports.compileETag = function(val) { |
| var fn; |
| |
| if (typeof val === 'function') { |
| return val; |
| } |
| |
| switch (val) { |
| case true: |
| fn = exports.wetag; |
| break; |
| case false: |
| break; |
| case 'strong': |
| fn = exports.etag; |
| break; |
| case 'weak': |
| fn = exports.wetag; |
| break; |
| default: |
| throw new TypeError('unknown value for etag function: ' + val); |
| } |
| |
| return fn; |
| } |
| |
| /** |
| * Compile "query parser" value to function. |
| * |
| * @param {String|Function} val |
| * @return {Function} |
| * @api private |
| */ |
| |
| exports.compileQueryParser = function compileQueryParser(val) { |
| var fn; |
| |
| if (typeof val === 'function') { |
| return val; |
| } |
| |
| switch (val) { |
| case true: |
| fn = querystring.parse; |
| break; |
| case false: |
| fn = newObject; |
| break; |
| case 'extended': |
| fn = parseExtendedQueryString; |
| break; |
| case 'simple': |
| fn = querystring.parse; |
| break; |
| default: |
| throw new TypeError('unknown value for query parser function: ' + val); |
| } |
| |
| return fn; |
| } |
| |
| /** |
| * Compile "proxy trust" value to function. |
| * |
| * @param {Boolean|String|Number|Array|Function} val |
| * @return {Function} |
| * @api private |
| */ |
| |
| exports.compileTrust = function(val) { |
| if (typeof val === 'function') return val; |
| |
| if (val === true) { |
| // Support plain true/false |
| return function(){ return true }; |
| } |
| |
| if (typeof val === 'number') { |
| // Support trusting hop count |
| return function(a, i){ return i < val }; |
| } |
| |
| if (typeof val === 'string') { |
| // Support comma-separated values |
| val = val.split(/ *, */); |
| } |
| |
| return proxyaddr.compile(val || []); |
| } |
| |
| /** |
| * Set the charset in a given Content-Type string. |
| * |
| * @param {String} type |
| * @param {String} charset |
| * @return {String} |
| * @api private |
| */ |
| |
| exports.setCharset = function setCharset(type, charset) { |
| if (!type || !charset) { |
| return type; |
| } |
| |
| // parse type |
| var parsed = contentType.parse(type); |
| |
| // set charset |
| parsed.parameters.charset = charset; |
| |
| // format type |
| return contentType.format(parsed); |
| }; |
| |
| /** |
| * Create an ETag generator function, generating ETags with |
| * the given options. |
| * |
| * @param {object} options |
| * @return {function} |
| * @private |
| */ |
| |
| function createETagGenerator (options) { |
| return function generateETag (body, encoding) { |
| var buf = !Buffer.isBuffer(body) |
| ? Buffer.from(body, encoding) |
| : body |
| |
| return etag(buf, options) |
| } |
| } |
| |
| /** |
| * Parse an extended query string with qs. |
| * |
| * @return {Object} |
| * @private |
| */ |
| |
| function parseExtendedQueryString(str) { |
| return qs.parse(str, { |
| allowPrototypes: true |
| }); |
| } |
| |
| /** |
| * Return new empty object. |
| * |
| * @return {Object} |
| * @api private |
| */ |
| |
| function newObject() { |
| return {}; |
| } |