github.com/cloudcredo/cloudrocker@v0.0.0-20160108110610-1320f8cc2dfd/sample-apps/node/node_modules/express/lib/request.js (about)

     1  /**
     2   * Module dependencies.
     3   */
     4  
     5  var accepts = require('accepts');
     6  var deprecate = require('depd')('express');
     7  var typeis = require('type-is');
     8  var http = require('http');
     9  var fresh = require('fresh');
    10  var parseRange = require('range-parser');
    11  var parse = require('parseurl');
    12  var proxyaddr = require('proxy-addr');
    13  
    14  /**
    15   * Request prototype.
    16   */
    17  
    18  var req = exports = module.exports = {
    19    __proto__: http.IncomingMessage.prototype
    20  };
    21  
    22  /**
    23   * Return request header.
    24   *
    25   * The `Referrer` header field is special-cased,
    26   * both `Referrer` and `Referer` are interchangeable.
    27   *
    28   * Examples:
    29   *
    30   *     req.get('Content-Type');
    31   *     // => "text/plain"
    32   *
    33   *     req.get('content-type');
    34   *     // => "text/plain"
    35   *
    36   *     req.get('Something');
    37   *     // => undefined
    38   *
    39   * Aliased as `req.header()`.
    40   *
    41   * @param {String} name
    42   * @return {String}
    43   * @api public
    44   */
    45  
    46  req.get =
    47  req.header = function(name){
    48    switch (name = name.toLowerCase()) {
    49      case 'referer':
    50      case 'referrer':
    51        return this.headers.referrer
    52          || this.headers.referer;
    53      default:
    54        return this.headers[name];
    55    }
    56  };
    57  
    58  /**
    59   * To do: update docs.
    60   *
    61   * Check if the given `type(s)` is acceptable, returning
    62   * the best match when true, otherwise `undefined`, in which
    63   * case you should respond with 406 "Not Acceptable".
    64   *
    65   * The `type` value may be a single mime type string
    66   * such as "application/json", the extension name
    67   * such as "json", a comma-delimted list such as "json, html, text/plain",
    68   * an argument list such as `"json", "html", "text/plain"`,
    69   * or an array `["json", "html", "text/plain"]`. When a list
    70   * or array is given the _best_ match, if any is returned.
    71   *
    72   * Examples:
    73   *
    74   *     // Accept: text/html
    75   *     req.accepts('html');
    76   *     // => "html"
    77   *
    78   *     // Accept: text/*, application/json
    79   *     req.accepts('html');
    80   *     // => "html"
    81   *     req.accepts('text/html');
    82   *     // => "text/html"
    83   *     req.accepts('json, text');
    84   *     // => "json"
    85   *     req.accepts('application/json');
    86   *     // => "application/json"
    87   *
    88   *     // Accept: text/*, application/json
    89   *     req.accepts('image/png');
    90   *     req.accepts('png');
    91   *     // => undefined
    92   *
    93   *     // Accept: text/*;q=.5, application/json
    94   *     req.accepts(['html', 'json']);
    95   *     req.accepts('html', 'json');
    96   *     req.accepts('html, json');
    97   *     // => "json"
    98   *
    99   * @param {String|Array} type(s)
   100   * @return {String}
   101   * @api public
   102   */
   103  
   104  req.accepts = function(){
   105    var accept = accepts(this);
   106    return accept.types.apply(accept, arguments);
   107  };
   108  
   109  /**
   110   * Check if the given `encoding`s are accepted.
   111   *
   112   * @param {String} ...encoding
   113   * @return {Boolean}
   114   * @api public
   115   */
   116  
   117  req.acceptsEncodings = function(){
   118    var accept = accepts(this);
   119    return accept.encodings.apply(accept, arguments);
   120  };
   121  
   122  req.acceptsEncoding = deprecate.function(req.acceptsEncodings,
   123    'req.acceptsEncoding: Use acceptsEncodings instead');
   124  
   125  /**
   126   * Check if the given `charset`s are acceptable,
   127   * otherwise you should respond with 406 "Not Acceptable".
   128   *
   129   * @param {String} ...charset
   130   * @return {Boolean}
   131   * @api public
   132   */
   133  
   134  req.acceptsCharsets = function(){
   135    var accept = accepts(this);
   136    return accept.charsets.apply(accept, arguments);
   137  };
   138  
   139  req.acceptsCharset = deprecate.function(req.acceptsCharsets,
   140    'req.acceptsCharset: Use acceptsCharsets instead');
   141  
   142  /**
   143   * Check if the given `lang`s are acceptable,
   144   * otherwise you should respond with 406 "Not Acceptable".
   145   *
   146   * @param {String} ...lang
   147   * @return {Boolean}
   148   * @api public
   149   */
   150  
   151  req.acceptsLanguages = function(){
   152    var accept = accepts(this);
   153    return accept.languages.apply(accept, arguments);
   154  };
   155  
   156  req.acceptsLanguage = deprecate.function(req.acceptsLanguages,
   157    'req.acceptsLanguage: Use acceptsLanguages instead');
   158  
   159  /**
   160   * Parse Range header field,
   161   * capping to the given `size`.
   162   *
   163   * Unspecified ranges such as "0-" require
   164   * knowledge of your resource length. In
   165   * the case of a byte range this is of course
   166   * the total number of bytes. If the Range
   167   * header field is not given `null` is returned,
   168   * `-1` when unsatisfiable, `-2` when syntactically invalid.
   169   *
   170   * NOTE: remember that ranges are inclusive, so
   171   * for example "Range: users=0-3" should respond
   172   * with 4 users when available, not 3.
   173   *
   174   * @param {Number} size
   175   * @return {Array}
   176   * @api public
   177   */
   178  
   179  req.range = function(size){
   180    var range = this.get('Range');
   181    if (!range) return;
   182    return parseRange(size, range);
   183  };
   184  
   185  /**
   186   * Return the value of param `name` when present or `defaultValue`.
   187   *
   188   *  - Checks route placeholders, ex: _/user/:id_
   189   *  - Checks body params, ex: id=12, {"id":12}
   190   *  - Checks query string params, ex: ?id=12
   191   *
   192   * To utilize request bodies, `req.body`
   193   * should be an object. This can be done by using
   194   * the `bodyParser()` middleware.
   195   *
   196   * @param {String} name
   197   * @param {Mixed} [defaultValue]
   198   * @return {String}
   199   * @api public
   200   */
   201  
   202  req.param = function(name, defaultValue){
   203    var params = this.params || {};
   204    var body = this.body || {};
   205    var query = this.query || {};
   206    if (null != params[name] && params.hasOwnProperty(name)) return params[name];
   207    if (null != body[name]) return body[name];
   208    if (null != query[name]) return query[name];
   209    return defaultValue;
   210  };
   211  
   212  /**
   213   * Check if the incoming request contains the "Content-Type"
   214   * header field, and it contains the give mime `type`.
   215   *
   216   * Examples:
   217   *
   218   *      // With Content-Type: text/html; charset=utf-8
   219   *      req.is('html');
   220   *      req.is('text/html');
   221   *      req.is('text/*');
   222   *      // => true
   223   *
   224   *      // When Content-Type is application/json
   225   *      req.is('json');
   226   *      req.is('application/json');
   227   *      req.is('application/*');
   228   *      // => true
   229   *
   230   *      req.is('html');
   231   *      // => false
   232   *
   233   * @param {String} type
   234   * @return {Boolean}
   235   * @api public
   236   */
   237  
   238  req.is = function(types){
   239    if (!Array.isArray(types)) types = [].slice.call(arguments);
   240    return typeis(this, types);
   241  };
   242  
   243  /**
   244   * Return the protocol string "http" or "https"
   245   * when requested with TLS. When the "trust proxy"
   246   * setting trusts the socket address, the
   247   * "X-Forwarded-Proto" header field will be trusted
   248   * and used if present.
   249   *
   250   * If you're running behind a reverse proxy that
   251   * supplies https for you this may be enabled.
   252   *
   253   * @return {String}
   254   * @api public
   255   */
   256  
   257  defineGetter(req, 'protocol', function protocol(){
   258    var proto = this.connection.encrypted
   259      ? 'https'
   260      : 'http';
   261    var trust = this.app.get('trust proxy fn');
   262  
   263    if (!trust(this.connection.remoteAddress)) {
   264      return proto;
   265    }
   266  
   267    // Note: X-Forwarded-Proto is normally only ever a
   268    //       single value, but this is to be safe.
   269    proto = this.get('X-Forwarded-Proto') || proto;
   270    return proto.split(/\s*,\s*/)[0];
   271  });
   272  
   273  /**
   274   * Short-hand for:
   275   *
   276   *    req.protocol == 'https'
   277   *
   278   * @return {Boolean}
   279   * @api public
   280   */
   281  
   282  defineGetter(req, 'secure', function secure(){
   283    return 'https' == this.protocol;
   284  });
   285  
   286  /**
   287   * Return the remote address from the trusted proxy.
   288   *
   289   * The is the remote address on the socket unless
   290   * "trust proxy" is set.
   291   *
   292   * @return {String}
   293   * @api public
   294   */
   295  
   296  defineGetter(req, 'ip', function ip(){
   297    var trust = this.app.get('trust proxy fn');
   298    return proxyaddr(this, trust);
   299  });
   300  
   301  /**
   302   * When "trust proxy" is set, trusted proxy addresses + client.
   303   *
   304   * For example if the value were "client, proxy1, proxy2"
   305   * you would receive the array `["client", "proxy1", "proxy2"]`
   306   * where "proxy2" is the furthest down-stream and "proxy1" and
   307   * "proxy2" were trusted.
   308   *
   309   * @return {Array}
   310   * @api public
   311   */
   312  
   313  defineGetter(req, 'ips', function ips() {
   314    var trust = this.app.get('trust proxy fn');
   315    var addrs = proxyaddr.all(this, trust);
   316    return addrs.slice(1).reverse();
   317  });
   318  
   319  /**
   320   * Return subdomains as an array.
   321   *
   322   * Subdomains are the dot-separated parts of the host before the main domain of
   323   * the app. By default, the domain of the app is assumed to be the last two
   324   * parts of the host. This can be changed by setting "subdomain offset".
   325   *
   326   * For example, if the domain is "tobi.ferrets.example.com":
   327   * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
   328   * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
   329   *
   330   * @return {Array}
   331   * @api public
   332   */
   333  
   334  defineGetter(req, 'subdomains', function subdomains() {
   335    var offset = this.app.get('subdomain offset');
   336    return (this.hostname || '')
   337      .split('.')
   338      .reverse()
   339      .slice(offset);
   340  });
   341  
   342  /**
   343   * Short-hand for `url.parse(req.url).pathname`.
   344   *
   345   * @return {String}
   346   * @api public
   347   */
   348  
   349  defineGetter(req, 'path', function path() {
   350    return parse(this).pathname;
   351  });
   352  
   353  /**
   354   * Parse the "Host" header field to a hostname.
   355   *
   356   * When the "trust proxy" setting trusts the socket
   357   * address, the "X-Forwarded-Host" header field will
   358   * be trusted.
   359   *
   360   * @return {String}
   361   * @api public
   362   */
   363  
   364  defineGetter(req, 'hostname', function hostname(){
   365    var trust = this.app.get('trust proxy fn');
   366    var host = this.get('X-Forwarded-Host');
   367  
   368    if (!host || !trust(this.connection.remoteAddress)) {
   369      host = this.get('Host');
   370    }
   371  
   372    if (!host) return;
   373  
   374    // IPv6 literal support
   375    var offset = host[0] === '['
   376      ? host.indexOf(']') + 1
   377      : 0;
   378    var index = host.indexOf(':', offset);
   379  
   380    return ~index
   381      ? host.substring(0, index)
   382      : host;
   383  });
   384  
   385  // TODO: change req.host to return host in next major
   386  
   387  defineGetter(req, 'host', deprecate.function(function host(){
   388    return this.hostname;
   389  }, 'req.host: Use req.hostname instead'));
   390  
   391  /**
   392   * Check if the request is fresh, aka
   393   * Last-Modified and/or the ETag
   394   * still match.
   395   *
   396   * @return {Boolean}
   397   * @api public
   398   */
   399  
   400  defineGetter(req, 'fresh', function(){
   401    var method = this.method;
   402    var s = this.res.statusCode;
   403  
   404    // GET or HEAD for weak freshness validation only
   405    if ('GET' != method && 'HEAD' != method) return false;
   406  
   407    // 2xx or 304 as per rfc2616 14.26
   408    if ((s >= 200 && s < 300) || 304 == s) {
   409      return fresh(this.headers, this.res._headers);
   410    }
   411  
   412    return false;
   413  });
   414  
   415  /**
   416   * Check if the request is stale, aka
   417   * "Last-Modified" and / or the "ETag" for the
   418   * resource has changed.
   419   *
   420   * @return {Boolean}
   421   * @api public
   422   */
   423  
   424  defineGetter(req, 'stale', function stale(){
   425    return !this.fresh;
   426  });
   427  
   428  /**
   429   * Check if the request was an _XMLHttpRequest_.
   430   *
   431   * @return {Boolean}
   432   * @api public
   433   */
   434  
   435  defineGetter(req, 'xhr', function xhr(){
   436    var val = this.get('X-Requested-With') || '';
   437    return 'xmlhttprequest' == val.toLowerCase();
   438  });
   439  
   440  /**
   441   * Helper function for creating a getter on an object.
   442   *
   443   * @param {Object} obj
   444   * @param {String} name
   445   * @param {Function} getter
   446   * @api private
   447   */
   448  function defineGetter(obj, name, getter) {
   449    Object.defineProperty(obj, name, {
   450      configurable: true,
   451      enumerable: true,
   452      get: getter
   453    });
   454  };