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 };