"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/request/request.js" (8 Mar 2017, 42946 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Javascript source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file.

    1 'use strict'
    2 
    3 var http = require('http')
    4   , https = require('https')
    5   , url = require('url')
    6   , util = require('util')
    7   , stream = require('stream')
    8   , zlib = require('zlib')
    9   , hawk = require('hawk')
   10   , aws2 = require('aws-sign2')
   11   , aws4 = require('aws4')
   12   , httpSignature = require('http-signature')
   13   , mime = require('mime-types')
   14   , stringstream = require('stringstream')
   15   , caseless = require('caseless')
   16   , ForeverAgent = require('forever-agent')
   17   , FormData = require('form-data')
   18   , extend = require('extend')
   19   , isstream = require('isstream')
   20   , isTypedArray = require('is-typedarray').strict
   21   , helpers = require('./lib/helpers')
   22   , cookies = require('./lib/cookies')
   23   , getProxyFromURI = require('./lib/getProxyFromURI')
   24   , Querystring = require('./lib/querystring').Querystring
   25   , Har = require('./lib/har').Har
   26   , Auth = require('./lib/auth').Auth
   27   , OAuth = require('./lib/oauth').OAuth
   28   , Multipart = require('./lib/multipart').Multipart
   29   , Redirect = require('./lib/redirect').Redirect
   30   , Tunnel = require('./lib/tunnel').Tunnel
   31   , now = require('performance-now')
   32 
   33 var safeStringify = helpers.safeStringify
   34   , isReadStream = helpers.isReadStream
   35   , toBase64 = helpers.toBase64
   36   , defer = helpers.defer
   37   , copy = helpers.copy
   38   , version = helpers.version
   39   , globalCookieJar = cookies.jar()
   40 
   41 
   42 var globalPool = {}
   43 
   44 function filterForNonReserved(reserved, options) {
   45   // Filter out properties that are not reserved.
   46   // Reserved values are passed in at call site.
   47 
   48   var object = {}
   49   for (var i in options) {
   50     var notReserved = (reserved.indexOf(i) === -1)
   51     if (notReserved) {
   52       object[i] = options[i]
   53     }
   54   }
   55   return object
   56 }
   57 
   58 function filterOutReservedFunctions(reserved, options) {
   59   // Filter out properties that are functions and are reserved.
   60   // Reserved values are passed in at call site.
   61 
   62   var object = {}
   63   for (var i in options) {
   64     var isReserved = !(reserved.indexOf(i) === -1)
   65     var isFunction = (typeof options[i] === 'function')
   66     if (!(isReserved && isFunction)) {
   67       object[i] = options[i]
   68     }
   69   }
   70   return object
   71 
   72 }
   73 
   74 // Return a simpler request object to allow serialization
   75 function requestToJSON() {
   76   var self = this
   77   return {
   78     uri: self.uri,
   79     method: self.method,
   80     headers: self.headers
   81   }
   82 }
   83 
   84 // Return a simpler response object to allow serialization
   85 function responseToJSON() {
   86   var self = this
   87   return {
   88     statusCode: self.statusCode,
   89     body: self.body,
   90     headers: self.headers,
   91     request: requestToJSON.call(self.request)
   92   }
   93 }
   94 
   95 function Request (options) {
   96   // if given the method property in options, set property explicitMethod to true
   97 
   98   // extend the Request instance with any non-reserved properties
   99   // remove any reserved functions from the options object
  100   // set Request instance to be readable and writable
  101   // call init
  102 
  103   var self = this
  104 
  105   // start with HAR, then override with additional options
  106   if (options.har) {
  107     self._har = new Har(self)
  108     options = self._har.options(options)
  109   }
  110 
  111   stream.Stream.call(self)
  112   var reserved = Object.keys(Request.prototype)
  113   var nonReserved = filterForNonReserved(reserved, options)
  114 
  115   extend(self, nonReserved)
  116   options = filterOutReservedFunctions(reserved, options)
  117 
  118   self.readable = true
  119   self.writable = true
  120   if (options.method) {
  121     self.explicitMethod = true
  122   }
  123   self._qs = new Querystring(self)
  124   self._auth = new Auth(self)
  125   self._oauth = new OAuth(self)
  126   self._multipart = new Multipart(self)
  127   self._redirect = new Redirect(self)
  128   self._tunnel = new Tunnel(self)
  129   self.init(options)
  130 }
  131 
  132 util.inherits(Request, stream.Stream)
  133 
  134 // Debugging
  135 Request.debug = process.env.NODE_DEBUG && /\brequest\b/.test(process.env.NODE_DEBUG)
  136 function debug() {
  137   if (Request.debug) {
  138     console.error('REQUEST %s', util.format.apply(util, arguments))
  139   }
  140 }
  141 Request.prototype.debug = debug
  142 
  143 Request.prototype.init = function (options) {
  144   // init() contains all the code to setup the request object.
  145   // the actual outgoing request is not started until start() is called
  146   // this function is called from both the constructor and on redirect.
  147   var self = this
  148   if (!options) {
  149     options = {}
  150   }
  151   self.headers = self.headers ? copy(self.headers) : {}
  152 
  153   // Delete headers with value undefined since they break
  154   // ClientRequest.OutgoingMessage.setHeader in node 0.12
  155   for (var headerName in self.headers) {
  156     if (typeof self.headers[headerName] === 'undefined') {
  157       delete self.headers[headerName]
  158     }
  159   }
  160 
  161   caseless.httpify(self, self.headers)
  162 
  163   if (!self.method) {
  164     self.method = options.method || 'GET'
  165   }
  166   if (!self.localAddress) {
  167     self.localAddress = options.localAddress
  168   }
  169 
  170   self._qs.init(options)
  171 
  172   debug(options)
  173   if (!self.pool && self.pool !== false) {
  174     self.pool = globalPool
  175   }
  176   self.dests = self.dests || []
  177   self.__isRequestRequest = true
  178 
  179   // Protect against double callback
  180   if (!self._callback && self.callback) {
  181     self._callback = self.callback
  182     self.callback = function () {
  183       if (self._callbackCalled) {
  184         return // Print a warning maybe?
  185       }
  186       self._callbackCalled = true
  187       self._callback.apply(self, arguments)
  188     }
  189     self.on('error', self.callback.bind())
  190     self.on('complete', self.callback.bind(self, null))
  191   }
  192 
  193   // People use this property instead all the time, so support it
  194   if (!self.uri && self.url) {
  195     self.uri = self.url
  196     delete self.url
  197   }
  198 
  199   // If there's a baseUrl, then use it as the base URL (i.e. uri must be
  200   // specified as a relative path and is appended to baseUrl).
  201   if (self.baseUrl) {
  202     if (typeof self.baseUrl !== 'string') {
  203       return self.emit('error', new Error('options.baseUrl must be a string'))
  204     }
  205 
  206     if (typeof self.uri !== 'string') {
  207       return self.emit('error', new Error('options.uri must be a string when using options.baseUrl'))
  208     }
  209 
  210     if (self.uri.indexOf('//') === 0 || self.uri.indexOf('://') !== -1) {
  211       return self.emit('error', new Error('options.uri must be a path when using options.baseUrl'))
  212     }
  213 
  214     // Handle all cases to make sure that there's only one slash between
  215     // baseUrl and uri.
  216     var baseUrlEndsWithSlash = self.baseUrl.lastIndexOf('/') === self.baseUrl.length - 1
  217     var uriStartsWithSlash = self.uri.indexOf('/') === 0
  218 
  219     if (baseUrlEndsWithSlash && uriStartsWithSlash) {
  220       self.uri = self.baseUrl + self.uri.slice(1)
  221     } else if (baseUrlEndsWithSlash || uriStartsWithSlash) {
  222       self.uri = self.baseUrl + self.uri
  223     } else if (self.uri === '') {
  224       self.uri = self.baseUrl
  225     } else {
  226       self.uri = self.baseUrl + '/' + self.uri
  227     }
  228     delete self.baseUrl
  229   }
  230 
  231   // A URI is needed by this point, emit error if we haven't been able to get one
  232   if (!self.uri) {
  233     return self.emit('error', new Error('options.uri is a required argument'))
  234   }
  235 
  236   // If a string URI/URL was given, parse it into a URL object
  237   if (typeof self.uri === 'string') {
  238     self.uri = url.parse(self.uri)
  239   }
  240 
  241   // Some URL objects are not from a URL parsed string and need href added
  242   if (!self.uri.href) {
  243     self.uri.href = url.format(self.uri)
  244   }
  245 
  246   // DEPRECATED: Warning for users of the old Unix Sockets URL Scheme
  247   if (self.uri.protocol === 'unix:') {
  248     return self.emit('error', new Error('`unix://` URL scheme is no longer supported. Please use the format `http://unix:SOCKET:PATH`'))
  249   }
  250 
  251   // Support Unix Sockets
  252   if (self.uri.host === 'unix') {
  253     self.enableUnixSocket()
  254   }
  255 
  256   if (self.strictSSL === false) {
  257     self.rejectUnauthorized = false
  258   }
  259 
  260   if (!self.uri.pathname) {self.uri.pathname = '/'}
  261 
  262   if (!(self.uri.host || (self.uri.hostname && self.uri.port)) && !self.uri.isUnix) {
  263     // Invalid URI: it may generate lot of bad errors, like 'TypeError: Cannot call method `indexOf` of undefined' in CookieJar
  264     // Detect and reject it as soon as possible
  265     var faultyUri = url.format(self.uri)
  266     var message = 'Invalid URI "' + faultyUri + '"'
  267     if (Object.keys(options).length === 0) {
  268       // No option ? This can be the sign of a redirect
  269       // As this is a case where the user cannot do anything (they didn't call request directly with this URL)
  270       // they should be warned that it can be caused by a redirection (can save some hair)
  271       message += '. This can be caused by a crappy redirection.'
  272     }
  273     // This error was fatal
  274     self.abort()
  275     return self.emit('error', new Error(message))
  276   }
  277 
  278   if (!self.hasOwnProperty('proxy')) {
  279     self.proxy = getProxyFromURI(self.uri)
  280   }
  281 
  282   self.tunnel = self._tunnel.isEnabled()
  283   if (self.proxy) {
  284     self._tunnel.setup(options)
  285   }
  286 
  287   self._redirect.onRequest(options)
  288 
  289   self.setHost = false
  290   if (!self.hasHeader('host')) {
  291     var hostHeaderName = self.originalHostHeaderName || 'host'
  292     // When used with an IPv6 address, `host` will provide
  293     // the correct bracketed format, unlike using `hostname` and
  294     // optionally adding the `port` when necessary.
  295     self.setHeader(hostHeaderName, self.uri.host)
  296     self.setHost = true
  297   }
  298 
  299   self.jar(self._jar || options.jar)
  300 
  301   if (!self.uri.port) {
  302     if (self.uri.protocol === 'http:') {self.uri.port = 80}
  303     else if (self.uri.protocol === 'https:') {self.uri.port = 443}
  304   }
  305 
  306   if (self.proxy && !self.tunnel) {
  307     self.port = self.proxy.port
  308     self.host = self.proxy.hostname
  309   } else {
  310     self.port = self.uri.port
  311     self.host = self.uri.hostname
  312   }
  313 
  314   if (options.form) {
  315     self.form(options.form)
  316   }
  317 
  318   if (options.formData) {
  319     var formData = options.formData
  320     var requestForm = self.form()
  321     var appendFormValue = function (key, value) {
  322       if (value && value.hasOwnProperty('value') && value.hasOwnProperty('options')) {
  323         requestForm.append(key, value.value, value.options)
  324       } else {
  325         requestForm.append(key, value)
  326       }
  327     }
  328     for (var formKey in formData) {
  329       if (formData.hasOwnProperty(formKey)) {
  330         var formValue = formData[formKey]
  331         if (formValue instanceof Array) {
  332           for (var j = 0; j < formValue.length; j++) {
  333             appendFormValue(formKey, formValue[j])
  334           }
  335         } else {
  336           appendFormValue(formKey, formValue)
  337         }
  338       }
  339     }
  340   }
  341 
  342   if (options.qs) {
  343     self.qs(options.qs)
  344   }
  345 
  346   if (self.uri.path) {
  347     self.path = self.uri.path
  348   } else {
  349     self.path = self.uri.pathname + (self.uri.search || '')
  350   }
  351 
  352   if (self.path.length === 0) {
  353     self.path = '/'
  354   }
  355 
  356   // Auth must happen last in case signing is dependent on other headers
  357   if (options.aws) {
  358     self.aws(options.aws)
  359   }
  360 
  361   if (options.hawk) {
  362     self.hawk(options.hawk)
  363   }
  364 
  365   if (options.httpSignature) {
  366     self.httpSignature(options.httpSignature)
  367   }
  368 
  369   if (options.auth) {
  370     if (Object.prototype.hasOwnProperty.call(options.auth, 'username')) {
  371       options.auth.user = options.auth.username
  372     }
  373     if (Object.prototype.hasOwnProperty.call(options.auth, 'password')) {
  374       options.auth.pass = options.auth.password
  375     }
  376 
  377     self.auth(
  378       options.auth.user,
  379       options.auth.pass,
  380       options.auth.sendImmediately,
  381       options.auth.bearer
  382     )
  383   }
  384 
  385   if (self.gzip && !self.hasHeader('accept-encoding')) {
  386     self.setHeader('accept-encoding', 'gzip, deflate')
  387   }
  388 
  389   if (self.uri.auth && !self.hasHeader('authorization')) {
  390     var uriAuthPieces = self.uri.auth.split(':').map(function(item) {return self._qs.unescape(item)})
  391     self.auth(uriAuthPieces[0], uriAuthPieces.slice(1).join(':'), true)
  392   }
  393 
  394   if (!self.tunnel && self.proxy && self.proxy.auth && !self.hasHeader('proxy-authorization')) {
  395     var proxyAuthPieces = self.proxy.auth.split(':').map(function(item) {return self._qs.unescape(item)})
  396     var authHeader = 'Basic ' + toBase64(proxyAuthPieces.join(':'))
  397     self.setHeader('proxy-authorization', authHeader)
  398   }
  399 
  400   if (self.proxy && !self.tunnel) {
  401     self.path = (self.uri.protocol + '//' + self.uri.host + self.path)
  402   }
  403 
  404   if (options.json) {
  405     self.json(options.json)
  406   }
  407   if (options.multipart) {
  408     self.multipart(options.multipart)
  409   }
  410 
  411   if (options.time) {
  412     self.timing = true
  413 
  414     // NOTE: elapsedTime is deprecated in favor of .timings
  415     self.elapsedTime = self.elapsedTime || 0
  416   }
  417 
  418   function setContentLength () {
  419     if (isTypedArray(self.body)) {
  420       self.body = new Buffer(self.body)
  421     }
  422 
  423     if (!self.hasHeader('content-length')) {
  424       var length
  425       if (typeof self.body === 'string') {
  426         length = Buffer.byteLength(self.body)
  427       }
  428       else if (Array.isArray(self.body)) {
  429         length = self.body.reduce(function (a, b) {return a + b.length}, 0)
  430       }
  431       else {
  432         length = self.body.length
  433       }
  434 
  435       if (length) {
  436         self.setHeader('content-length', length)
  437       } else {
  438         self.emit('error', new Error('Argument error, options.body.'))
  439       }
  440     }
  441   }
  442   if (self.body && !isstream(self.body)) {
  443     setContentLength()
  444   }
  445 
  446   if (options.oauth) {
  447     self.oauth(options.oauth)
  448   } else if (self._oauth.params && self.hasHeader('authorization')) {
  449     self.oauth(self._oauth.params)
  450   }
  451 
  452   var protocol = self.proxy && !self.tunnel ? self.proxy.protocol : self.uri.protocol
  453     , defaultModules = {'http:':http, 'https:':https}
  454     , httpModules = self.httpModules || {}
  455 
  456   self.httpModule = httpModules[protocol] || defaultModules[protocol]
  457 
  458   if (!self.httpModule) {
  459     return self.emit('error', new Error('Invalid protocol: ' + protocol))
  460   }
  461 
  462   if (options.ca) {
  463     self.ca = options.ca
  464   }
  465 
  466   if (!self.agent) {
  467     if (options.agentOptions) {
  468       self.agentOptions = options.agentOptions
  469     }
  470 
  471     if (options.agentClass) {
  472       self.agentClass = options.agentClass
  473     } else if (options.forever) {
  474       var v = version()
  475       // use ForeverAgent in node 0.10- only
  476       if (v.major === 0 && v.minor <= 10) {
  477         self.agentClass = protocol === 'http:' ? ForeverAgent : ForeverAgent.SSL
  478       } else {
  479         self.agentClass = self.httpModule.Agent
  480         self.agentOptions = self.agentOptions || {}
  481         self.agentOptions.keepAlive = true
  482       }
  483     } else {
  484       self.agentClass = self.httpModule.Agent
  485     }
  486   }
  487 
  488   if (self.pool === false) {
  489     self.agent = false
  490   } else {
  491     self.agent = self.agent || self.getNewAgent()
  492   }
  493 
  494   self.on('pipe', function (src) {
  495     if (self.ntick && self._started) {
  496       self.emit('error', new Error('You cannot pipe to this stream after the outbound request has started.'))
  497     }
  498     self.src = src
  499     if (isReadStream(src)) {
  500       if (!self.hasHeader('content-type')) {
  501         self.setHeader('content-type', mime.lookup(src.path))
  502       }
  503     } else {
  504       if (src.headers) {
  505         for (var i in src.headers) {
  506           if (!self.hasHeader(i)) {
  507             self.setHeader(i, src.headers[i])
  508           }
  509         }
  510       }
  511       if (self._json && !self.hasHeader('content-type')) {
  512         self.setHeader('content-type', 'application/json')
  513       }
  514       if (src.method && !self.explicitMethod) {
  515         self.method = src.method
  516       }
  517     }
  518 
  519     // self.on('pipe', function () {
  520     //   console.error('You have already piped to this stream. Pipeing twice is likely to break the request.')
  521     // })
  522   })
  523 
  524   defer(function () {
  525     if (self._aborted) {
  526       return
  527     }
  528 
  529     var end = function () {
  530       if (self._form) {
  531         if (!self._auth.hasAuth) {
  532           self._form.pipe(self)
  533         }
  534         else if (self._auth.hasAuth && self._auth.sentAuth) {
  535           self._form.pipe(self)
  536         }
  537       }
  538       if (self._multipart && self._multipart.chunked) {
  539         self._multipart.body.pipe(self)
  540       }
  541       if (self.body) {
  542         if (isstream(self.body)) {
  543           self.body.pipe(self)
  544         } else {
  545           setContentLength()
  546           if (Array.isArray(self.body)) {
  547             self.body.forEach(function (part) {
  548               self.write(part)
  549             })
  550           } else {
  551             self.write(self.body)
  552           }
  553           self.end()
  554         }
  555       } else if (self.requestBodyStream) {
  556         console.warn('options.requestBodyStream is deprecated, please pass the request object to stream.pipe.')
  557         self.requestBodyStream.pipe(self)
  558       } else if (!self.src) {
  559         if (self._auth.hasAuth && !self._auth.sentAuth) {
  560           self.end()
  561           return
  562         }
  563         if (self.method !== 'GET' && typeof self.method !== 'undefined') {
  564           self.setHeader('content-length', 0)
  565         }
  566         self.end()
  567       }
  568     }
  569 
  570     if (self._form && !self.hasHeader('content-length')) {
  571       // Before ending the request, we had to compute the length of the whole form, asyncly
  572       self.setHeader(self._form.getHeaders(), true)
  573       self._form.getLength(function (err, length) {
  574         if (!err && !isNaN(length)) {
  575           self.setHeader('content-length', length)
  576         }
  577         end()
  578       })
  579     } else {
  580       end()
  581     }
  582 
  583     self.ntick = true
  584   })
  585 
  586 }
  587 
  588 Request.prototype.getNewAgent = function () {
  589   var self = this
  590   var Agent = self.agentClass
  591   var options = {}
  592   if (self.agentOptions) {
  593     for (var i in self.agentOptions) {
  594       options[i] = self.agentOptions[i]
  595     }
  596   }
  597   if (self.ca) {
  598     options.ca = self.ca
  599   }
  600   if (self.ciphers) {
  601     options.ciphers = self.ciphers
  602   }
  603   if (self.secureProtocol) {
  604     options.secureProtocol = self.secureProtocol
  605   }
  606   if (self.secureOptions) {
  607     options.secureOptions = self.secureOptions
  608   }
  609   if (typeof self.rejectUnauthorized !== 'undefined') {
  610     options.rejectUnauthorized = self.rejectUnauthorized
  611   }
  612 
  613   if (self.cert && self.key) {
  614     options.key = self.key
  615     options.cert = self.cert
  616   }
  617 
  618   if (self.pfx) {
  619     options.pfx = self.pfx
  620   }
  621 
  622   if (self.passphrase) {
  623     options.passphrase = self.passphrase
  624   }
  625 
  626   var poolKey = ''
  627 
  628   // different types of agents are in different pools
  629   if (Agent !== self.httpModule.Agent) {
  630     poolKey += Agent.name
  631   }
  632 
  633   // ca option is only relevant if proxy or destination are https
  634   var proxy = self.proxy
  635   if (typeof proxy === 'string') {
  636     proxy = url.parse(proxy)
  637   }
  638   var isHttps = (proxy && proxy.protocol === 'https:') || this.uri.protocol === 'https:'
  639 
  640   if (isHttps) {
  641     if (options.ca) {
  642       if (poolKey) {
  643         poolKey += ':'
  644       }
  645       poolKey += options.ca
  646     }
  647 
  648     if (typeof options.rejectUnauthorized !== 'undefined') {
  649       if (poolKey) {
  650         poolKey += ':'
  651       }
  652       poolKey += options.rejectUnauthorized
  653     }
  654 
  655     if (options.cert) {
  656       if (poolKey) {
  657         poolKey += ':'
  658       }
  659       poolKey += options.cert.toString('ascii') + options.key.toString('ascii')
  660     }
  661 
  662     if (options.pfx) {
  663       if (poolKey) {
  664         poolKey += ':'
  665       }
  666       poolKey += options.pfx.toString('ascii')
  667     }
  668 
  669     if (options.ciphers) {
  670       if (poolKey) {
  671         poolKey += ':'
  672       }
  673       poolKey += options.ciphers
  674     }
  675 
  676     if (options.secureProtocol) {
  677       if (poolKey) {
  678         poolKey += ':'
  679       }
  680       poolKey += options.secureProtocol
  681     }
  682 
  683     if (options.secureOptions) {
  684       if (poolKey) {
  685         poolKey += ':'
  686       }
  687       poolKey += options.secureOptions
  688     }
  689   }
  690 
  691   if (self.pool === globalPool && !poolKey && Object.keys(options).length === 0 && self.httpModule.globalAgent) {
  692     // not doing anything special.  Use the globalAgent
  693     return self.httpModule.globalAgent
  694   }
  695 
  696   // we're using a stored agent.  Make sure it's protocol-specific
  697   poolKey = self.uri.protocol + poolKey
  698 
  699   // generate a new agent for this setting if none yet exists
  700   if (!self.pool[poolKey]) {
  701     self.pool[poolKey] = new Agent(options)
  702     // properly set maxSockets on new agents
  703     if (self.pool.maxSockets) {
  704       self.pool[poolKey].maxSockets = self.pool.maxSockets
  705     }
  706   }
  707 
  708   return self.pool[poolKey]
  709 }
  710 
  711 Request.prototype.start = function () {
  712   // start() is called once we are ready to send the outgoing HTTP request.
  713   // this is usually called on the first write(), end() or on nextTick()
  714   var self = this
  715 
  716   if (self.timing) {
  717     var startTime = now()
  718   }
  719 
  720   if (self._aborted) {
  721     return
  722   }
  723 
  724   self._started = true
  725   self.method = self.method || 'GET'
  726   self.href = self.uri.href
  727 
  728   if (self.src && self.src.stat && self.src.stat.size && !self.hasHeader('content-length')) {
  729     self.setHeader('content-length', self.src.stat.size)
  730   }
  731   if (self._aws) {
  732     self.aws(self._aws, true)
  733   }
  734 
  735   // We have a method named auth, which is completely different from the http.request
  736   // auth option.  If we don't remove it, we're gonna have a bad time.
  737   var reqOptions = copy(self)
  738   delete reqOptions.auth
  739 
  740   debug('make request', self.uri.href)
  741 
  742   // node v6.8.0 now supports a `timeout` value in `http.request()`, but we
  743   // should delete it for now since we handle timeouts manually for better
  744   // consistency with node versions before v6.8.0
  745   delete reqOptions.timeout
  746 
  747   try {
  748     self.req = self.httpModule.request(reqOptions)
  749   } catch (err) {
  750     self.emit('error', err)
  751     return
  752   }
  753 
  754   if (self.timing) {
  755     self.startTime = new Date().getTime()
  756     self.timings = {
  757       start: startTime
  758     }
  759   }
  760 
  761   var timeout
  762   if (self.timeout && !self.timeoutTimer) {
  763     if (self.timeout < 0) {
  764       timeout = 0
  765     } else if (typeof self.timeout === 'number' && isFinite(self.timeout)) {
  766       timeout = self.timeout
  767     }
  768   }
  769 
  770   self.req.on('response', self.onRequestResponse.bind(self))
  771   self.req.on('error', self.onRequestError.bind(self))
  772   self.req.on('drain', function() {
  773     self.emit('drain')
  774   })
  775   self.req.on('socket', function(socket) {
  776     if (self.timing) {
  777       self.timings.socket = now()
  778       socket.on('connect', function() {
  779         self.timings.connect = now()
  780       })
  781     }
  782 
  783     var setReqTimeout = function() {
  784       // This timeout sets the amount of time to wait *between* bytes sent
  785       // from the server once connected.
  786       //
  787       // In particular, it's useful for erroring if the server fails to send
  788       // data halfway through streaming a response.
  789       self.req.setTimeout(timeout, function () {
  790         if (self.req) {
  791           self.abort()
  792           var e = new Error('ESOCKETTIMEDOUT')
  793           e.code = 'ESOCKETTIMEDOUT'
  794           e.connect = false
  795           self.emit('error', e)
  796         }
  797       })
  798     }
  799     // `._connecting` was the old property which was made public in node v6.1.0
  800     var isConnecting = socket._connecting || socket.connecting
  801     if (timeout !== undefined) {
  802       // Only start the connection timer if we're actually connecting a new
  803       // socket, otherwise if we're already connected (because this is a
  804       // keep-alive connection) do not bother. This is important since we won't
  805       // get a 'connect' event for an already connected socket.
  806       if (isConnecting) {
  807         var onReqSockConnect = function() {
  808           socket.removeListener('connect', onReqSockConnect)
  809           clearTimeout(self.timeoutTimer)
  810           self.timeoutTimer = null
  811           setReqTimeout()
  812         }
  813 
  814         socket.on('connect', onReqSockConnect)
  815 
  816         self.req.on('error', function(err) {
  817           socket.removeListener('connect', onReqSockConnect)
  818         })
  819 
  820         // Set a timeout in memory - this block will throw if the server takes more
  821         // than `timeout` to write the HTTP status and headers (corresponding to
  822         // the on('response') event on the client). NB: this measures wall-clock
  823         // time, not the time between bytes sent by the server.
  824         self.timeoutTimer = setTimeout(function () {
  825           socket.removeListener('connect', onReqSockConnect)
  826           self.abort()
  827           var e = new Error('ETIMEDOUT')
  828           e.code = 'ETIMEDOUT'
  829           e.connect = true
  830           self.emit('error', e)
  831         }, timeout)
  832       } else {
  833         // We're already connected
  834         setReqTimeout()
  835       }
  836     }
  837     self.emit('socket', socket)
  838   })
  839 
  840   self.emit('request', self.req)
  841 }
  842 
  843 Request.prototype.onRequestError = function (error) {
  844   var self = this
  845   if (self._aborted) {
  846     return
  847   }
  848   if (self.req && self.req._reusedSocket && error.code === 'ECONNRESET'
  849       && self.agent.addRequestNoreuse) {
  850     self.agent = { addRequest: self.agent.addRequestNoreuse.bind(self.agent) }
  851     self.start()
  852     self.req.end()
  853     return
  854   }
  855   if (self.timeout && self.timeoutTimer) {
  856     clearTimeout(self.timeoutTimer)
  857     self.timeoutTimer = null
  858   }
  859   self.emit('error', error)
  860 }
  861 
  862 Request.prototype.onRequestResponse = function (response) {
  863   var self = this
  864 
  865   if (self.timing) {
  866     self.timings.response = now()
  867   }
  868 
  869   debug('onRequestResponse', self.uri.href, response.statusCode, response.headers)
  870   response.on('end', function() {
  871     if (self.timing) {
  872       self.timings.end = now()
  873 
  874       self.timings.dns = self.timings.socket - self.timings.start
  875       self.timings.tcp = self.timings.connect - self.timings.socket
  876       self.timings.firstByte = self.timings.response - self.timings.connect
  877       self.timings.download = self.timings.end - self.timings.response
  878       self.timings.total = self.timings.end - self.timings.start
  879 
  880       debug('elapsed time', self.timings.total)
  881 
  882       // elapsedTime includes all redirects
  883       self.elapsedTime += Math.round(self.timings.total)
  884 
  885       // NOTE: elapsedTime is deprecated in favor of .timings
  886       response.elapsedTime = self.elapsedTime
  887 
  888       // timings is just for the final fetch
  889       response.timings = self.timings
  890     }
  891     debug('response end', self.uri.href, response.statusCode, response.headers)
  892   })
  893 
  894   if (self._aborted) {
  895     debug('aborted', self.uri.href)
  896     response.resume()
  897     return
  898   }
  899 
  900   self.response = response
  901   response.request = self
  902   response.toJSON = responseToJSON
  903 
  904   // XXX This is different on 0.10, because SSL is strict by default
  905   if (self.httpModule === https &&
  906       self.strictSSL && (!response.hasOwnProperty('socket') ||
  907       !response.socket.authorized)) {
  908     debug('strict ssl error', self.uri.href)
  909     var sslErr = response.hasOwnProperty('socket') ? response.socket.authorizationError : self.uri.href + ' does not support SSL'
  910     self.emit('error', new Error('SSL Error: ' + sslErr))
  911     return
  912   }
  913 
  914   // Save the original host before any redirect (if it changes, we need to
  915   // remove any authorization headers).  Also remember the case of the header
  916   // name because lots of broken servers expect Host instead of host and we
  917   // want the caller to be able to specify this.
  918   self.originalHost = self.getHeader('host')
  919   if (!self.originalHostHeaderName) {
  920     self.originalHostHeaderName = self.hasHeader('host')
  921   }
  922   if (self.setHost) {
  923     self.removeHeader('host')
  924   }
  925   if (self.timeout && self.timeoutTimer) {
  926     clearTimeout(self.timeoutTimer)
  927     self.timeoutTimer = null
  928   }
  929 
  930   var targetCookieJar = (self._jar && self._jar.setCookie) ? self._jar : globalCookieJar
  931   var addCookie = function (cookie) {
  932     //set the cookie if it's domain in the href's domain.
  933     try {
  934       targetCookieJar.setCookie(cookie, self.uri.href, {ignoreError: true})
  935     } catch (e) {
  936       self.emit('error', e)
  937     }
  938   }
  939 
  940   response.caseless = caseless(response.headers)
  941 
  942   if (response.caseless.has('set-cookie') && (!self._disableCookies)) {
  943     var headerName = response.caseless.has('set-cookie')
  944     if (Array.isArray(response.headers[headerName])) {
  945       response.headers[headerName].forEach(addCookie)
  946     } else {
  947       addCookie(response.headers[headerName])
  948     }
  949   }
  950 
  951   if (self._redirect.onResponse(response)) {
  952     return // Ignore the rest of the response
  953   } else {
  954     // Be a good stream and emit end when the response is finished.
  955     // Hack to emit end on close because of a core bug that never fires end
  956     response.on('close', function () {
  957       if (!self._ended) {
  958         self.response.emit('end')
  959       }
  960     })
  961 
  962     response.once('end', function () {
  963       self._ended = true
  964     })
  965 
  966     var noBody = function (code) {
  967       return (
  968         self.method === 'HEAD'
  969         // Informational
  970         || (code >= 100 && code < 200)
  971         // No Content
  972         || code === 204
  973         // Not Modified
  974         || code === 304
  975       )
  976     }
  977 
  978     var responseContent
  979     if (self.gzip && !noBody(response.statusCode)) {
  980       var contentEncoding = response.headers['content-encoding'] || 'identity'
  981       contentEncoding = contentEncoding.trim().toLowerCase()
  982 
  983       // Be more lenient with decoding compressed responses, since (very rarely)
  984       // servers send slightly invalid gzip responses that are still accepted
  985       // by common browsers.
  986       // Always using Z_SYNC_FLUSH is what cURL does.
  987       var zlibOptions = {
  988         flush: zlib.Z_SYNC_FLUSH
  989       , finishFlush: zlib.Z_SYNC_FLUSH
  990       }
  991 
  992       if (contentEncoding === 'gzip') {
  993         responseContent = zlib.createGunzip(zlibOptions)
  994         response.pipe(responseContent)
  995       } else if (contentEncoding === 'deflate') {
  996         responseContent = zlib.createInflate(zlibOptions)
  997         response.pipe(responseContent)
  998       } else {
  999         // Since previous versions didn't check for Content-Encoding header,
 1000         // ignore any invalid values to preserve backwards-compatibility
 1001         if (contentEncoding !== 'identity') {
 1002           debug('ignoring unrecognized Content-Encoding ' + contentEncoding)
 1003         }
 1004         responseContent = response
 1005       }
 1006     } else {
 1007       responseContent = response
 1008     }
 1009 
 1010     if (self.encoding) {
 1011       if (self.dests.length !== 0) {
 1012         console.error('Ignoring encoding parameter as this stream is being piped to another stream which makes the encoding option invalid.')
 1013       } else if (responseContent.setEncoding) {
 1014         responseContent.setEncoding(self.encoding)
 1015       } else {
 1016         // Should only occur on node pre-v0.9.4 (joyent/node@9b5abe5) with
 1017         // zlib streams.
 1018         // If/When support for 0.9.4 is dropped, this should be unnecessary.
 1019         responseContent = responseContent.pipe(stringstream(self.encoding))
 1020       }
 1021     }
 1022 
 1023     if (self._paused) {
 1024       responseContent.pause()
 1025     }
 1026 
 1027     self.responseContent = responseContent
 1028 
 1029     self.emit('response', response)
 1030 
 1031     self.dests.forEach(function (dest) {
 1032       self.pipeDest(dest)
 1033     })
 1034 
 1035     responseContent.on('data', function (chunk) {
 1036       if (self.timing && !self.responseStarted) {
 1037         self.responseStartTime = (new Date()).getTime()
 1038 
 1039         // NOTE: responseStartTime is deprecated in favor of .timings
 1040         response.responseStartTime = self.responseStartTime
 1041       }
 1042       self._destdata = true
 1043       self.emit('data', chunk)
 1044     })
 1045     responseContent.once('end', function (chunk) {
 1046       self.emit('end', chunk)
 1047     })
 1048     responseContent.on('error', function (error) {
 1049       self.emit('error', error)
 1050     })
 1051     responseContent.on('close', function () {self.emit('close')})
 1052 
 1053     if (self.callback) {
 1054       self.readResponseBody(response)
 1055     }
 1056     //if no callback
 1057     else {
 1058       self.on('end', function () {
 1059         if (self._aborted) {
 1060           debug('aborted', self.uri.href)
 1061           return
 1062         }
 1063         self.emit('complete', response)
 1064       })
 1065     }
 1066   }
 1067   debug('finish init function', self.uri.href)
 1068 }
 1069 
 1070 Request.prototype.readResponseBody = function (response) {
 1071   var self = this
 1072   debug('reading response\'s body')
 1073   var buffers = []
 1074     , bufferLength = 0
 1075     , strings = []
 1076 
 1077   self.on('data', function (chunk) {
 1078     if (!Buffer.isBuffer(chunk)) {
 1079       strings.push(chunk)
 1080     } else if (chunk.length) {
 1081       bufferLength += chunk.length
 1082       buffers.push(chunk)
 1083     }
 1084   })
 1085   self.on('end', function () {
 1086     debug('end event', self.uri.href)
 1087     if (self._aborted) {
 1088       debug('aborted', self.uri.href)
 1089       // `buffer` is defined in the parent scope and used in a closure it exists for the life of the request.
 1090       // This can lead to leaky behavior if the user retains a reference to the request object.
 1091       buffers = []
 1092       bufferLength = 0
 1093       return
 1094     }
 1095 
 1096     if (bufferLength) {
 1097       debug('has body', self.uri.href, bufferLength)
 1098       response.body = Buffer.concat(buffers, bufferLength)
 1099       if (self.encoding !== null) {
 1100         response.body = response.body.toString(self.encoding)
 1101       }
 1102       // `buffer` is defined in the parent scope and used in a closure it exists for the life of the Request.
 1103       // This can lead to leaky behavior if the user retains a reference to the request object.
 1104       buffers = []
 1105       bufferLength = 0
 1106     } else if (strings.length) {
 1107       // The UTF8 BOM [0xEF,0xBB,0xBF] is converted to [0xFE,0xFF] in the JS UTC16/UCS2 representation.
 1108       // Strip this value out when the encoding is set to 'utf8', as upstream consumers won't expect it and it breaks JSON.parse().
 1109       if (self.encoding === 'utf8' && strings[0].length > 0 && strings[0][0] === '\uFEFF') {
 1110         strings[0] = strings[0].substring(1)
 1111       }
 1112       response.body = strings.join('')
 1113     }
 1114 
 1115     if (self._json) {
 1116       try {
 1117         response.body = JSON.parse(response.body, self._jsonReviver)
 1118       } catch (e) {
 1119         debug('invalid JSON received', self.uri.href)
 1120       }
 1121     }
 1122     debug('emitting complete', self.uri.href)
 1123     if (typeof response.body === 'undefined' && !self._json) {
 1124       response.body = self.encoding === null ? new Buffer(0) : ''
 1125     }
 1126     self.emit('complete', response, response.body)
 1127   })
 1128 }
 1129 
 1130 Request.prototype.abort = function () {
 1131   var self = this
 1132   self._aborted = true
 1133 
 1134   if (self.req) {
 1135     self.req.abort()
 1136   }
 1137   else if (self.response) {
 1138     self.response.destroy()
 1139   }
 1140 
 1141   self.emit('abort')
 1142 }
 1143 
 1144 Request.prototype.pipeDest = function (dest) {
 1145   var self = this
 1146   var response = self.response
 1147   // Called after the response is received
 1148   if (dest.headers && !dest.headersSent) {
 1149     if (response.caseless.has('content-type')) {
 1150       var ctname = response.caseless.has('content-type')
 1151       if (dest.setHeader) {
 1152         dest.setHeader(ctname, response.headers[ctname])
 1153       }
 1154       else {
 1155         dest.headers[ctname] = response.headers[ctname]
 1156       }
 1157     }
 1158 
 1159     if (response.caseless.has('content-length')) {
 1160       var clname = response.caseless.has('content-length')
 1161       if (dest.setHeader) {
 1162         dest.setHeader(clname, response.headers[clname])
 1163       } else {
 1164         dest.headers[clname] = response.headers[clname]
 1165       }
 1166     }
 1167   }
 1168   if (dest.setHeader && !dest.headersSent) {
 1169     for (var i in response.headers) {
 1170       // If the response content is being decoded, the Content-Encoding header
 1171       // of the response doesn't represent the piped content, so don't pass it.
 1172       if (!self.gzip || i !== 'content-encoding') {
 1173         dest.setHeader(i, response.headers[i])
 1174       }
 1175     }
 1176     dest.statusCode = response.statusCode
 1177   }
 1178   if (self.pipefilter) {
 1179     self.pipefilter(response, dest)
 1180   }
 1181 }
 1182 
 1183 Request.prototype.qs = function (q, clobber) {
 1184   var self = this
 1185   var base
 1186   if (!clobber && self.uri.query) {
 1187     base = self._qs.parse(self.uri.query)
 1188   } else {
 1189     base = {}
 1190   }
 1191 
 1192   for (var i in q) {
 1193     base[i] = q[i]
 1194   }
 1195 
 1196   var qs = self._qs.stringify(base)
 1197 
 1198   if (qs === '') {
 1199     return self
 1200   }
 1201 
 1202   self.uri = url.parse(self.uri.href.split('?')[0] + '?' + qs)
 1203   self.url = self.uri
 1204   self.path = self.uri.path
 1205 
 1206   if (self.uri.host === 'unix') {
 1207     self.enableUnixSocket()
 1208   }
 1209 
 1210   return self
 1211 }
 1212 Request.prototype.form = function (form) {
 1213   var self = this
 1214   if (form) {
 1215     if (!/^application\/x-www-form-urlencoded\b/.test(self.getHeader('content-type'))) {
 1216       self.setHeader('content-type', 'application/x-www-form-urlencoded')
 1217     }
 1218     self.body = (typeof form === 'string')
 1219       ? self._qs.rfc3986(form.toString('utf8'))
 1220       : self._qs.stringify(form).toString('utf8')
 1221     return self
 1222   }
 1223   // create form-data object
 1224   self._form = new FormData()
 1225   self._form.on('error', function(err) {
 1226     err.message = 'form-data: ' + err.message
 1227     self.emit('error', err)
 1228     self.abort()
 1229   })
 1230   return self._form
 1231 }
 1232 Request.prototype.multipart = function (multipart) {
 1233   var self = this
 1234 
 1235   self._multipart.onRequest(multipart)
 1236 
 1237   if (!self._multipart.chunked) {
 1238     self.body = self._multipart.body
 1239   }
 1240 
 1241   return self
 1242 }
 1243 Request.prototype.json = function (val) {
 1244   var self = this
 1245 
 1246   if (!self.hasHeader('accept')) {
 1247     self.setHeader('accept', 'application/json')
 1248   }
 1249 
 1250   if (typeof self.jsonReplacer === 'function') {
 1251     self._jsonReplacer = self.jsonReplacer
 1252   }
 1253 
 1254   self._json = true
 1255   if (typeof val === 'boolean') {
 1256     if (self.body !== undefined) {
 1257       if (!/^application\/x-www-form-urlencoded\b/.test(self.getHeader('content-type'))) {
 1258         self.body = safeStringify(self.body, self._jsonReplacer)
 1259       } else {
 1260         self.body = self._qs.rfc3986(self.body)
 1261       }
 1262       if (!self.hasHeader('content-type')) {
 1263         self.setHeader('content-type', 'application/json')
 1264       }
 1265     }
 1266   } else {
 1267     self.body = safeStringify(val, self._jsonReplacer)
 1268     if (!self.hasHeader('content-type')) {
 1269       self.setHeader('content-type', 'application/json')
 1270     }
 1271   }
 1272 
 1273   if (typeof self.jsonReviver === 'function') {
 1274     self._jsonReviver = self.jsonReviver
 1275   }
 1276 
 1277   return self
 1278 }
 1279 Request.prototype.getHeader = function (name, headers) {
 1280   var self = this
 1281   var result, re, match
 1282   if (!headers) {
 1283     headers = self.headers
 1284   }
 1285   Object.keys(headers).forEach(function (key) {
 1286     if (key.length !== name.length) {
 1287       return
 1288     }
 1289     re = new RegExp(name, 'i')
 1290     match = key.match(re)
 1291     if (match) {
 1292       result = headers[key]
 1293     }
 1294   })
 1295   return result
 1296 }
 1297 Request.prototype.enableUnixSocket = function () {
 1298   // Get the socket & request paths from the URL
 1299   var unixParts = this.uri.path.split(':')
 1300     , host = unixParts[0]
 1301     , path = unixParts[1]
 1302   // Apply unix properties to request
 1303   this.socketPath = host
 1304   this.uri.pathname = path
 1305   this.uri.path = path
 1306   this.uri.host = host
 1307   this.uri.hostname = host
 1308   this.uri.isUnix = true
 1309 }
 1310 
 1311 
 1312 Request.prototype.auth = function (user, pass, sendImmediately, bearer) {
 1313   var self = this
 1314 
 1315   self._auth.onRequest(user, pass, sendImmediately, bearer)
 1316 
 1317   return self
 1318 }
 1319 Request.prototype.aws = function (opts, now) {
 1320   var self = this
 1321 
 1322   if (!now) {
 1323     self._aws = opts
 1324     return self
 1325   }
 1326 
 1327   if (opts.sign_version == 4 || opts.sign_version == '4') {
 1328     // use aws4
 1329     var options = {
 1330       host: self.uri.host,
 1331       path: self.uri.path,
 1332       method: self.method,
 1333       headers: {
 1334         'content-type': self.getHeader('content-type') || ''
 1335       },
 1336       body: self.body
 1337     }
 1338     var signRes = aws4.sign(options, {
 1339       accessKeyId: opts.key,
 1340       secretAccessKey: opts.secret,
 1341       sessionToken: opts.session
 1342     })
 1343     self.setHeader('authorization', signRes.headers.Authorization)
 1344     self.setHeader('x-amz-date', signRes.headers['X-Amz-Date'])
 1345     if (signRes.headers['X-Amz-Security-Token']) {
 1346       self.setHeader('x-amz-security-token', signRes.headers['X-Amz-Security-Token'])
 1347     }
 1348   }
 1349   else {
 1350     // default: use aws-sign2
 1351     var date = new Date()
 1352     self.setHeader('date', date.toUTCString())
 1353     var auth =
 1354       { key: opts.key
 1355       , secret: opts.secret
 1356       , verb: self.method.toUpperCase()
 1357       , date: date
 1358       , contentType: self.getHeader('content-type') || ''
 1359       , md5: self.getHeader('content-md5') || ''
 1360       , amazonHeaders: aws2.canonicalizeHeaders(self.headers)
 1361       }
 1362     var path = self.uri.path
 1363     if (opts.bucket && path) {
 1364       auth.resource = '/' + opts.bucket + path
 1365     } else if (opts.bucket && !path) {
 1366       auth.resource = '/' + opts.bucket
 1367     } else if (!opts.bucket && path) {
 1368       auth.resource = path
 1369     } else if (!opts.bucket && !path) {
 1370       auth.resource = '/'
 1371     }
 1372     auth.resource = aws2.canonicalizeResource(auth.resource)
 1373     self.setHeader('authorization', aws2.authorization(auth))
 1374   }
 1375 
 1376   return self
 1377 }
 1378 Request.prototype.httpSignature = function (opts) {
 1379   var self = this
 1380   httpSignature.signRequest({
 1381     getHeader: function(header) {
 1382       return self.getHeader(header, self.headers)
 1383     },
 1384     setHeader: function(header, value) {
 1385       self.setHeader(header, value)
 1386     },
 1387     method: self.method,
 1388     path: self.path
 1389   }, opts)
 1390   debug('httpSignature authorization', self.getHeader('authorization'))
 1391 
 1392   return self
 1393 }
 1394 Request.prototype.hawk = function (opts) {
 1395   var self = this
 1396   self.setHeader('Authorization', hawk.client.header(self.uri, self.method, opts).field)
 1397 }
 1398 Request.prototype.oauth = function (_oauth) {
 1399   var self = this
 1400 
 1401   self._oauth.onRequest(_oauth)
 1402 
 1403   return self
 1404 }
 1405 
 1406 Request.prototype.jar = function (jar) {
 1407   var self = this
 1408   var cookies
 1409 
 1410   if (self._redirect.redirectsFollowed === 0) {
 1411     self.originalCookieHeader = self.getHeader('cookie')
 1412   }
 1413 
 1414   if (!jar) {
 1415     // disable cookies
 1416     cookies = false
 1417     self._disableCookies = true
 1418   } else {
 1419     var targetCookieJar = (jar && jar.getCookieString) ? jar : globalCookieJar
 1420     var urihref = self.uri.href
 1421     //fetch cookie in the Specified host
 1422     if (targetCookieJar) {
 1423       cookies = targetCookieJar.getCookieString(urihref)
 1424     }
 1425   }
 1426 
 1427   //if need cookie and cookie is not empty
 1428   if (cookies && cookies.length) {
 1429     if (self.originalCookieHeader) {
 1430       // Don't overwrite existing Cookie header
 1431       self.setHeader('cookie', self.originalCookieHeader + '; ' + cookies)
 1432     } else {
 1433       self.setHeader('cookie', cookies)
 1434     }
 1435   }
 1436   self._jar = jar
 1437   return self
 1438 }
 1439 
 1440 
 1441 // Stream API
 1442 Request.prototype.pipe = function (dest, opts) {
 1443   var self = this
 1444 
 1445   if (self.response) {
 1446     if (self._destdata) {
 1447       self.emit('error', new Error('You cannot pipe after data has been emitted from the response.'))
 1448     } else if (self._ended) {
 1449       self.emit('error', new Error('You cannot pipe after the response has been ended.'))
 1450     } else {
 1451       stream.Stream.prototype.pipe.call(self, dest, opts)
 1452       self.pipeDest(dest)
 1453       return dest
 1454     }
 1455   } else {
 1456     self.dests.push(dest)
 1457     stream.Stream.prototype.pipe.call(self, dest, opts)
 1458     return dest
 1459   }
 1460 }
 1461 Request.prototype.write = function () {
 1462   var self = this
 1463   if (self._aborted) {return}
 1464 
 1465   if (!self._started) {
 1466     self.start()
 1467   }
 1468   if (self.req) {
 1469     return self.req.write.apply(self.req, arguments)
 1470   }
 1471 }
 1472 Request.prototype.end = function (chunk) {
 1473   var self = this
 1474   if (self._aborted) {return}
 1475 
 1476   if (chunk) {
 1477     self.write(chunk)
 1478   }
 1479   if (!self._started) {
 1480     self.start()
 1481   }
 1482   if (self.req) {
 1483     self.req.end()
 1484   }
 1485 }
 1486 Request.prototype.pause = function () {
 1487   var self = this
 1488   if (!self.responseContent) {
 1489     self._paused = true
 1490   } else {
 1491     self.responseContent.pause.apply(self.responseContent, arguments)
 1492   }
 1493 }
 1494 Request.prototype.resume = function () {
 1495   var self = this
 1496   if (!self.responseContent) {
 1497     self._paused = false
 1498   } else {
 1499     self.responseContent.resume.apply(self.responseContent, arguments)
 1500   }
 1501 }
 1502 Request.prototype.destroy = function () {
 1503   var self = this
 1504   if (!self._ended) {
 1505     self.end()
 1506   } else if (self.response) {
 1507     self.response.destroy()
 1508   }
 1509 }
 1510 
 1511 Request.defaultProxyHeaderWhiteList =
 1512   Tunnel.defaultProxyHeaderWhiteList.slice()
 1513 
 1514 Request.defaultProxyHeaderExclusiveList =
 1515   Tunnel.defaultProxyHeaderExclusiveList.slice()
 1516 
 1517 // Exports
 1518 
 1519 Request.prototype.toJSON = requestToJSON
 1520 module.exports = Request