twitst4tz

request.js (44466B)

---

 'use strict'
 
 var http = require('http')
 var https = require('https')
 var url = require('url')
 var util = require('util')
 var stream = require('stream')
 var zlib = require('zlib')
 var aws2 = require('aws-sign2')
 var aws4 = require('aws4')
 var httpSignature = require('http-signature')
 var mime = require('mime-types')
 var caseless = require('caseless')
 var ForeverAgent = require('forever-agent')
 var FormData = require('form-data')
 var extend = require('extend')
 var isstream = require('isstream')
 var isTypedArray = require('is-typedarray').strict
 var helpers = require('./lib/helpers')
 var cookies = require('./lib/cookies')
 var getProxyFromURI = require('./lib/getProxyFromURI')
 var Querystring = require('./lib/querystring').Querystring
 var Har = require('./lib/har').Har
 var Auth = require('./lib/auth').Auth
 var OAuth = require('./lib/oauth').OAuth
 var hawk = require('./lib/hawk')
 var Multipart = require('./lib/multipart').Multipart
 var Redirect = require('./lib/redirect').Redirect
 var Tunnel = require('./lib/tunnel').Tunnel
 var now = require('performance-now')
 var Buffer = require('safe-buffer').Buffer
 
 var safeStringify = helpers.safeStringify
 var isReadStream = helpers.isReadStream
 var toBase64 = helpers.toBase64
 var defer = helpers.defer
 var copy = helpers.copy
 var version = helpers.version
 var globalCookieJar = cookies.jar()
 
 var globalPool = {}
 
 function filterForNonReserved (reserved, options) {
   // Filter out properties that are not reserved.
   // Reserved values are passed in at call site.
 
   var object = {}
   for (var i in options) {
     var notReserved = (reserved.indexOf(i) === -1)
     if (notReserved) {
       object[i] = options[i]
     }
   }
   return object
 }
 
 function filterOutReservedFunctions (reserved, options) {
   // Filter out properties that are functions and are reserved.
   // Reserved values are passed in at call site.
 
   var object = {}
   for (var i in options) {
     var isReserved = !(reserved.indexOf(i) === -1)
     var isFunction = (typeof options[i] === 'function')
     if (!(isReserved && isFunction)) {
       object[i] = options[i]
     }
   }
   return object
 }
 
 // Return a simpler request object to allow serialization
 function requestToJSON () {
   var self = this
   return {
     uri: self.uri,
     method: self.method,
     headers: self.headers
   }
 }
 
 // Return a simpler response object to allow serialization
 function responseToJSON () {
   var self = this
   return {
     statusCode: self.statusCode,
     body: self.body,
     headers: self.headers,
     request: requestToJSON.call(self.request)
   }
 }
 
 function Request (options) {
   // if given the method property in options, set property explicitMethod to true
 
   // extend the Request instance with any non-reserved properties
   // remove any reserved functions from the options object
   // set Request instance to be readable and writable
   // call init
 
   var self = this
 
   // start with HAR, then override with additional options
   if (options.har) {
     self._har = new Har(self)
     options = self._har.options(options)
   }
 
   stream.Stream.call(self)
   var reserved = Object.keys(Request.prototype)
   var nonReserved = filterForNonReserved(reserved, options)
 
   extend(self, nonReserved)
   options = filterOutReservedFunctions(reserved, options)
 
   self.readable = true
   self.writable = true
   if (options.method) {
     self.explicitMethod = true
   }
   self._qs = new Querystring(self)
   self._auth = new Auth(self)
   self._oauth = new OAuth(self)
   self._multipart = new Multipart(self)
   self._redirect = new Redirect(self)
   self._tunnel = new Tunnel(self)
   self.init(options)
 }
 
 util.inherits(Request, stream.Stream)
 
 // Debugging
 Request.debug = process.env.NODE_DEBUG && /\brequest\b/.test(process.env.NODE_DEBUG)
 function debug () {
   if (Request.debug) {
     console.error('REQUEST %s', util.format.apply(util, arguments))
   }
 }
 Request.prototype.debug = debug
 
 Request.prototype.init = function (options) {
   // init() contains all the code to setup the request object.
   // the actual outgoing request is not started until start() is called
   // this function is called from both the constructor and on redirect.
   var self = this
   if (!options) {
     options = {}
   }
   self.headers = self.headers ? copy(self.headers) : {}
 
   // Delete headers with value undefined since they break
   // ClientRequest.OutgoingMessage.setHeader in node 0.12
   for (var headerName in self.headers) {
     if (typeof self.headers[headerName] === 'undefined') {
       delete self.headers[headerName]
     }
   }
 
   caseless.httpify(self, self.headers)
 
   if (!self.method) {
     self.method = options.method || 'GET'
   }
   if (!self.localAddress) {
     self.localAddress = options.localAddress
   }
 
   self._qs.init(options)
 
   debug(options)
   if (!self.pool && self.pool !== false) {
     self.pool = globalPool
   }
   self.dests = self.dests || []
   self.__isRequestRequest = true
 
   // Protect against double callback
   if (!self._callback && self.callback) {
     self._callback = self.callback
     self.callback = function () {
       if (self._callbackCalled) {
         return // Print a warning maybe?
       }
       self._callbackCalled = true
       self._callback.apply(self, arguments)
     }
     self.on('error', self.callback.bind())
     self.on('complete', self.callback.bind(self, null))
   }
 
   // People use this property instead all the time, so support it
   if (!self.uri && self.url) {
     self.uri = self.url
     delete self.url
   }
 
   // If there's a baseUrl, then use it as the base URL (i.e. uri must be
   // specified as a relative path and is appended to baseUrl).
   if (self.baseUrl) {
     if (typeof self.baseUrl !== 'string') {
       return self.emit('error', new Error('options.baseUrl must be a string'))
     }
 
     if (typeof self.uri !== 'string') {
       return self.emit('error', new Error('options.uri must be a string when using options.baseUrl'))
     }
 
     if (self.uri.indexOf('//') === 0 || self.uri.indexOf('://') !== -1) {
       return self.emit('error', new Error('options.uri must be a path when using options.baseUrl'))
     }
 
     // Handle all cases to make sure that there's only one slash between
     // baseUrl and uri.
     var baseUrlEndsWithSlash = self.baseUrl.lastIndexOf('/') === self.baseUrl.length - 1
     var uriStartsWithSlash = self.uri.indexOf('/') === 0
 
     if (baseUrlEndsWithSlash && uriStartsWithSlash) {
       self.uri = self.baseUrl + self.uri.slice(1)
     } else if (baseUrlEndsWithSlash || uriStartsWithSlash) {
       self.uri = self.baseUrl + self.uri
     } else if (self.uri === '') {
       self.uri = self.baseUrl
     } else {
       self.uri = self.baseUrl + '/' + self.uri
     }
     delete self.baseUrl
   }
 
   // A URI is needed by this point, emit error if we haven't been able to get one
   if (!self.uri) {
     return self.emit('error', new Error('options.uri is a required argument'))
   }
 
   // If a string URI/URL was given, parse it into a URL object
   if (typeof self.uri === 'string') {
     self.uri = url.parse(self.uri)
   }
 
   // Some URL objects are not from a URL parsed string and need href added
   if (!self.uri.href) {
     self.uri.href = url.format(self.uri)
   }
 
   // DEPRECATED: Warning for users of the old Unix Sockets URL Scheme
   if (self.uri.protocol === 'unix:') {
     return self.emit('error', new Error('`unix://` URL scheme is no longer supported. Please use the format `http://unix:SOCKET:PATH`'))
   }
 
   // Support Unix Sockets
   if (self.uri.host === 'unix') {
     self.enableUnixSocket()
   }
 
   if (self.strictSSL === false) {
     self.rejectUnauthorized = false
   }
 
   if (!self.uri.pathname) { self.uri.pathname = '/' }
 
   if (!(self.uri.host || (self.uri.hostname && self.uri.port)) && !self.uri.isUnix) {
     // Invalid URI: it may generate lot of bad errors, like 'TypeError: Cannot call method `indexOf` of undefined' in CookieJar
     // Detect and reject it as soon as possible
     var faultyUri = url.format(self.uri)
     var message = 'Invalid URI "' + faultyUri + '"'
     if (Object.keys(options).length === 0) {
       // No option ? This can be the sign of a redirect
       // As this is a case where the user cannot do anything (they didn't call request directly with this URL)
       // they should be warned that it can be caused by a redirection (can save some hair)
       message += '. This can be caused by a crappy redirection.'
     }
     // This error was fatal
     self.abort()
     return self.emit('error', new Error(message))
   }
 
   if (!self.hasOwnProperty('proxy')) {
     self.proxy = getProxyFromURI(self.uri)
   }
 
   self.tunnel = self._tunnel.isEnabled()
   if (self.proxy) {
     self._tunnel.setup(options)
   }
 
   self._redirect.onRequest(options)
 
   self.setHost = false
   if (!self.hasHeader('host')) {
     var hostHeaderName = self.originalHostHeaderName || 'host'
     self.setHeader(hostHeaderName, self.uri.host)
     // Drop :port suffix from Host header if known protocol.
     if (self.uri.port) {
       if ((self.uri.port === '80' && self.uri.protocol === 'http:') ||
           (self.uri.port === '443' && self.uri.protocol === 'https:')) {
         self.setHeader(hostHeaderName, self.uri.hostname)
       }
     }
     self.setHost = true
   }
 
   self.jar(self._jar || options.jar)
 
   if (!self.uri.port) {
     if (self.uri.protocol === 'http:') { self.uri.port = 80 } else if (self.uri.protocol === 'https:') { self.uri.port = 443 }
   }
 
   if (self.proxy && !self.tunnel) {
     self.port = self.proxy.port
     self.host = self.proxy.hostname
   } else {
     self.port = self.uri.port
     self.host = self.uri.hostname
   }
 
   if (options.form) {
     self.form(options.form)
   }
 
   if (options.formData) {
     var formData = options.formData
     var requestForm = self.form()
     var appendFormValue = function (key, value) {
       if (value && value.hasOwnProperty('value') && value.hasOwnProperty('options')) {
         requestForm.append(key, value.value, value.options)
       } else {
         requestForm.append(key, value)
       }
     }
     for (var formKey in formData) {
       if (formData.hasOwnProperty(formKey)) {
         var formValue = formData[formKey]
         if (formValue instanceof Array) {
           for (var j = 0; j < formValue.length; j++) {
             appendFormValue(formKey, formValue[j])
           }
         } else {
           appendFormValue(formKey, formValue)
         }
       }
     }
   }
 
   if (options.qs) {
     self.qs(options.qs)
   }
 
   if (self.uri.path) {
     self.path = self.uri.path
   } else {
     self.path = self.uri.pathname + (self.uri.search || '')
   }
 
   if (self.path.length === 0) {
     self.path = '/'
   }
 
   // Auth must happen last in case signing is dependent on other headers
   if (options.aws) {
     self.aws(options.aws)
   }
 
   if (options.hawk) {
     self.hawk(options.hawk)
   }
 
   if (options.httpSignature) {
     self.httpSignature(options.httpSignature)
   }
 
   if (options.auth) {
     if (Object.prototype.hasOwnProperty.call(options.auth, 'username')) {
       options.auth.user = options.auth.username
     }
     if (Object.prototype.hasOwnProperty.call(options.auth, 'password')) {
       options.auth.pass = options.auth.password
     }
 
     self.auth(
       options.auth.user,
       options.auth.pass,
       options.auth.sendImmediately,
       options.auth.bearer
     )
   }
 
   if (self.gzip && !self.hasHeader('accept-encoding')) {
     self.setHeader('accept-encoding', 'gzip, deflate')
   }
 
   if (self.uri.auth && !self.hasHeader('authorization')) {
     var uriAuthPieces = self.uri.auth.split(':').map(function (item) { return self._qs.unescape(item) })
     self.auth(uriAuthPieces[0], uriAuthPieces.slice(1).join(':'), true)
   }
 
   if (!self.tunnel && self.proxy && self.proxy.auth && !self.hasHeader('proxy-authorization')) {
     var proxyAuthPieces = self.proxy.auth.split(':').map(function (item) { return self._qs.unescape(item) })
     var authHeader = 'Basic ' + toBase64(proxyAuthPieces.join(':'))
     self.setHeader('proxy-authorization', authHeader)
   }
 
   if (self.proxy && !self.tunnel) {
     self.path = (self.uri.protocol + '//' + self.uri.host + self.path)
   }
 
   if (options.json) {
     self.json(options.json)
   }
   if (options.multipart) {
     self.multipart(options.multipart)
   }
 
   if (options.time) {
     self.timing = true
 
     // NOTE: elapsedTime is deprecated in favor of .timings
     self.elapsedTime = self.elapsedTime || 0
   }
 
   function setContentLength () {
     if (isTypedArray(self.body)) {
       self.body = Buffer.from(self.body)
     }
 
     if (!self.hasHeader('content-length')) {
       var length
       if (typeof self.body === 'string') {
         length = Buffer.byteLength(self.body)
       } else if (Array.isArray(self.body)) {
         length = self.body.reduce(function (a, b) { return a + b.length }, 0)
       } else {
         length = self.body.length
       }
 
       if (length) {
         self.setHeader('content-length', length)
       } else {
         self.emit('error', new Error('Argument error, options.body.'))
       }
     }
   }
   if (self.body && !isstream(self.body)) {
     setContentLength()
   }
 
   if (options.oauth) {
     self.oauth(options.oauth)
   } else if (self._oauth.params && self.hasHeader('authorization')) {
     self.oauth(self._oauth.params)
   }
 
   var protocol = self.proxy && !self.tunnel ? self.proxy.protocol : self.uri.protocol
   var defaultModules = {'http:': http, 'https:': https}
   var httpModules = self.httpModules || {}
 
   self.httpModule = httpModules[protocol] || defaultModules[protocol]
 
   if (!self.httpModule) {
     return self.emit('error', new Error('Invalid protocol: ' + protocol))
   }
 
   if (options.ca) {
     self.ca = options.ca
   }
 
   if (!self.agent) {
     if (options.agentOptions) {
       self.agentOptions = options.agentOptions
     }
 
     if (options.agentClass) {
       self.agentClass = options.agentClass
     } else if (options.forever) {
       var v = version()
       // use ForeverAgent in node 0.10- only
       if (v.major === 0 && v.minor <= 10) {
         self.agentClass = protocol === 'http:' ? ForeverAgent : ForeverAgent.SSL
       } else {
         self.agentClass = self.httpModule.Agent
         self.agentOptions = self.agentOptions || {}
         self.agentOptions.keepAlive = true
       }
     } else {
       self.agentClass = self.httpModule.Agent
     }
   }
 
   if (self.pool === false) {
     self.agent = false
   } else {
     self.agent = self.agent || self.getNewAgent()
   }
 
   self.on('pipe', function (src) {
     if (self.ntick && self._started) {
       self.emit('error', new Error('You cannot pipe to this stream after the outbound request has started.'))
     }
     self.src = src
     if (isReadStream(src)) {
       if (!self.hasHeader('content-type')) {
         self.setHeader('content-type', mime.lookup(src.path))
       }
     } else {
       if (src.headers) {
         for (var i in src.headers) {
           if (!self.hasHeader(i)) {
             self.setHeader(i, src.headers[i])
           }
         }
       }
       if (self._json && !self.hasHeader('content-type')) {
         self.setHeader('content-type', 'application/json')
       }
       if (src.method && !self.explicitMethod) {
         self.method = src.method
       }
     }
 
   // self.on('pipe', function () {
   //   console.error('You have already piped to this stream. Pipeing twice is likely to break the request.')
   // })
   })
 
   defer(function () {
     if (self._aborted) {
       return
     }
 
     var end = function () {
       if (self._form) {
         if (!self._auth.hasAuth) {
           self._form.pipe(self)
         } else if (self._auth.hasAuth && self._auth.sentAuth) {
           self._form.pipe(self)
         }
       }
       if (self._multipart && self._multipart.chunked) {
         self._multipart.body.pipe(self)
       }
       if (self.body) {
         if (isstream(self.body)) {
           self.body.pipe(self)
         } else {
           setContentLength()
           if (Array.isArray(self.body)) {
             self.body.forEach(function (part) {
               self.write(part)
             })
           } else {
             self.write(self.body)
           }
           self.end()
         }
       } else if (self.requestBodyStream) {
         console.warn('options.requestBodyStream is deprecated, please pass the request object to stream.pipe.')
         self.requestBodyStream.pipe(self)
       } else if (!self.src) {
         if (self._auth.hasAuth && !self._auth.sentAuth) {
           self.end()
           return
         }
         if (self.method !== 'GET' && typeof self.method !== 'undefined') {
           self.setHeader('content-length', 0)
         }
         self.end()
       }
     }
 
     if (self._form && !self.hasHeader('content-length')) {
       // Before ending the request, we had to compute the length of the whole form, asyncly
       self.setHeader(self._form.getHeaders(), true)
       self._form.getLength(function (err, length) {
         if (!err && !isNaN(length)) {
           self.setHeader('content-length', length)
         }
         end()
       })
     } else {
       end()
     }
 
     self.ntick = true
   })
 }
 
 Request.prototype.getNewAgent = function () {
   var self = this
   var Agent = self.agentClass
   var options = {}
   if (self.agentOptions) {
     for (var i in self.agentOptions) {
       options[i] = self.agentOptions[i]
     }
   }
   if (self.ca) {
     options.ca = self.ca
   }
   if (self.ciphers) {
     options.ciphers = self.ciphers
   }
   if (self.secureProtocol) {
     options.secureProtocol = self.secureProtocol
   }
   if (self.secureOptions) {
     options.secureOptions = self.secureOptions
   }
   if (typeof self.rejectUnauthorized !== 'undefined') {
     options.rejectUnauthorized = self.rejectUnauthorized
   }
 
   if (self.cert && self.key) {
     options.key = self.key
     options.cert = self.cert
   }
 
   if (self.pfx) {
     options.pfx = self.pfx
   }
 
   if (self.passphrase) {
     options.passphrase = self.passphrase
   }
 
   var poolKey = ''
 
   // different types of agents are in different pools
   if (Agent !== self.httpModule.Agent) {
     poolKey += Agent.name
   }
 
   // ca option is only relevant if proxy or destination are https
   var proxy = self.proxy
   if (typeof proxy === 'string') {
     proxy = url.parse(proxy)
   }
   var isHttps = (proxy && proxy.protocol === 'https:') || this.uri.protocol === 'https:'
 
   if (isHttps) {
     if (options.ca) {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.ca
     }
 
     if (typeof options.rejectUnauthorized !== 'undefined') {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.rejectUnauthorized
     }
 
     if (options.cert) {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.cert.toString('ascii') + options.key.toString('ascii')
     }
 
     if (options.pfx) {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.pfx.toString('ascii')
     }
 
     if (options.ciphers) {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.ciphers
     }
 
     if (options.secureProtocol) {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.secureProtocol
     }
 
     if (options.secureOptions) {
       if (poolKey) {
         poolKey += ':'
       }
       poolKey += options.secureOptions
     }
   }
 
   if (self.pool === globalPool && !poolKey && Object.keys(options).length === 0 && self.httpModule.globalAgent) {
     // not doing anything special.  Use the globalAgent
     return self.httpModule.globalAgent
   }
 
   // we're using a stored agent.  Make sure it's protocol-specific
   poolKey = self.uri.protocol + poolKey
 
   // generate a new agent for this setting if none yet exists
   if (!self.pool[poolKey]) {
     self.pool[poolKey] = new Agent(options)
     // properly set maxSockets on new agents
     if (self.pool.maxSockets) {
       self.pool[poolKey].maxSockets = self.pool.maxSockets
     }
   }
 
   return self.pool[poolKey]
 }
 
 Request.prototype.start = function () {
   // start() is called once we are ready to send the outgoing HTTP request.
   // this is usually called on the first write(), end() or on nextTick()
   var self = this
 
   if (self.timing) {
     // All timings will be relative to this request's startTime.  In order to do this,
     // we need to capture the wall-clock start time (via Date), immediately followed
     // by the high-resolution timer (via now()).  While these two won't be set
     // at the _exact_ same time, they should be close enough to be able to calculate
     // high-resolution, monotonically non-decreasing timestamps relative to startTime.
     var startTime = new Date().getTime()
     var startTimeNow = now()
   }
 
   if (self._aborted) {
     return
   }
 
   self._started = true
   self.method = self.method || 'GET'
   self.href = self.uri.href
 
   if (self.src && self.src.stat && self.src.stat.size && !self.hasHeader('content-length')) {
     self.setHeader('content-length', self.src.stat.size)
   }
   if (self._aws) {
     self.aws(self._aws, true)
   }
 
   // We have a method named auth, which is completely different from the http.request
   // auth option.  If we don't remove it, we're gonna have a bad time.
   var reqOptions = copy(self)
   delete reqOptions.auth
 
   debug('make request', self.uri.href)
 
   // node v6.8.0 now supports a `timeout` value in `http.request()`, but we
   // should delete it for now since we handle timeouts manually for better
   // consistency with node versions before v6.8.0
   delete reqOptions.timeout
 
   try {
     self.req = self.httpModule.request(reqOptions)
   } catch (err) {
     self.emit('error', err)
     return
   }
 
   if (self.timing) {
     self.startTime = startTime
     self.startTimeNow = startTimeNow
 
     // Timing values will all be relative to startTime (by comparing to startTimeNow
     // so we have an accurate clock)
     self.timings = {}
   }
 
   var timeout
   if (self.timeout && !self.timeoutTimer) {
     if (self.timeout < 0) {
       timeout = 0
     } else if (typeof self.timeout === 'number' && isFinite(self.timeout)) {
       timeout = self.timeout
     }
   }
 
   self.req.on('response', self.onRequestResponse.bind(self))
   self.req.on('error', self.onRequestError.bind(self))
   self.req.on('drain', function () {
     self.emit('drain')
   })
 
   self.req.on('socket', function (socket) {
     // `._connecting` was the old property which was made public in node v6.1.0
     var isConnecting = socket._connecting || socket.connecting
     if (self.timing) {
       self.timings.socket = now() - self.startTimeNow
 
       if (isConnecting) {
         var onLookupTiming = function () {
           self.timings.lookup = now() - self.startTimeNow
         }
 
         var onConnectTiming = function () {
           self.timings.connect = now() - self.startTimeNow
         }
 
         socket.once('lookup', onLookupTiming)
         socket.once('connect', onConnectTiming)
 
         // clean up timing event listeners if needed on error
         self.req.once('error', function () {
           socket.removeListener('lookup', onLookupTiming)
           socket.removeListener('connect', onConnectTiming)
         })
       }
     }
 
     var setReqTimeout = function () {
       // This timeout sets the amount of time to wait *between* bytes sent
       // from the server once connected.
       //
       // In particular, it's useful for erroring if the server fails to send
       // data halfway through streaming a response.
       self.req.setTimeout(timeout, function () {
         if (self.req) {
           self.abort()
           var e = new Error('ESOCKETTIMEDOUT')
           e.code = 'ESOCKETTIMEDOUT'
           e.connect = false
           self.emit('error', e)
         }
       })
     }
     if (timeout !== undefined) {
       // Only start the connection timer if we're actually connecting a new
       // socket, otherwise if we're already connected (because this is a
       // keep-alive connection) do not bother. This is important since we won't
       // get a 'connect' event for an already connected socket.
       if (isConnecting) {
         var onReqSockConnect = function () {
           socket.removeListener('connect', onReqSockConnect)
           self.clearTimeout()
           setReqTimeout()
         }
 
         socket.on('connect', onReqSockConnect)
 
         self.req.on('error', function (err) { // eslint-disable-line handle-callback-err
           socket.removeListener('connect', onReqSockConnect)
         })
 
         // Set a timeout in memory - this block will throw if the server takes more
         // than `timeout` to write the HTTP status and headers (corresponding to
         // the on('response') event on the client). NB: this measures wall-clock
         // time, not the time between bytes sent by the server.
         self.timeoutTimer = setTimeout(function () {
           socket.removeListener('connect', onReqSockConnect)
           self.abort()
           var e = new Error('ETIMEDOUT')
           e.code = 'ETIMEDOUT'
           e.connect = true
           self.emit('error', e)
         }, timeout)
       } else {
         // We're already connected
         setReqTimeout()
       }
     }
     self.emit('socket', socket)
   })
 
   self.emit('request', self.req)
 }
 
 Request.prototype.onRequestError = function (error) {
   var self = this
   if (self._aborted) {
     return
   }
   if (self.req && self.req._reusedSocket && error.code === 'ECONNRESET' &&
     self.agent.addRequestNoreuse) {
     self.agent = { addRequest: self.agent.addRequestNoreuse.bind(self.agent) }
     self.start()
     self.req.end()
     return
   }
   self.clearTimeout()
   self.emit('error', error)
 }
 
 Request.prototype.onRequestResponse = function (response) {
   var self = this
 
   if (self.timing) {
     self.timings.response = now() - self.startTimeNow
   }
 
   debug('onRequestResponse', self.uri.href, response.statusCode, response.headers)
   response.on('end', function () {
     if (self.timing) {
       self.timings.end = now() - self.startTimeNow
       response.timingStart = self.startTime
 
       // fill in the blanks for any periods that didn't trigger, such as
       // no lookup or connect due to keep alive
       if (!self.timings.socket) {
         self.timings.socket = 0
       }
       if (!self.timings.lookup) {
         self.timings.lookup = self.timings.socket
       }
       if (!self.timings.connect) {
         self.timings.connect = self.timings.lookup
       }
       if (!self.timings.response) {
         self.timings.response = self.timings.connect
       }
 
       debug('elapsed time', self.timings.end)
 
       // elapsedTime includes all redirects
       self.elapsedTime += Math.round(self.timings.end)
 
       // NOTE: elapsedTime is deprecated in favor of .timings
       response.elapsedTime = self.elapsedTime
 
       // timings is just for the final fetch
       response.timings = self.timings
 
       // pre-calculate phase timings as well
       response.timingPhases = {
         wait: self.timings.socket,
         dns: self.timings.lookup - self.timings.socket,
         tcp: self.timings.connect - self.timings.lookup,
         firstByte: self.timings.response - self.timings.connect,
         download: self.timings.end - self.timings.response,
         total: self.timings.end
       }
     }
     debug('response end', self.uri.href, response.statusCode, response.headers)
   })
 
   if (self._aborted) {
     debug('aborted', self.uri.href)
     response.resume()
     return
   }
 
   self.response = response
   response.request = self
   response.toJSON = responseToJSON
 
   // XXX This is different on 0.10, because SSL is strict by default
   if (self.httpModule === https &&
     self.strictSSL && (!response.hasOwnProperty('socket') ||
     !response.socket.authorized)) {
     debug('strict ssl error', self.uri.href)
     var sslErr = response.hasOwnProperty('socket') ? response.socket.authorizationError : self.uri.href + ' does not support SSL'
     self.emit('error', new Error('SSL Error: ' + sslErr))
     return
   }
 
   // Save the original host before any redirect (if it changes, we need to
   // remove any authorization headers).  Also remember the case of the header
   // name because lots of broken servers expect Host instead of host and we
   // want the caller to be able to specify this.
   self.originalHost = self.getHeader('host')
   if (!self.originalHostHeaderName) {
     self.originalHostHeaderName = self.hasHeader('host')
   }
   if (self.setHost) {
     self.removeHeader('host')
   }
   self.clearTimeout()
 
   var targetCookieJar = (self._jar && self._jar.setCookie) ? self._jar : globalCookieJar
   var addCookie = function (cookie) {
     // set the cookie if it's domain in the href's domain.
     try {
       targetCookieJar.setCookie(cookie, self.uri.href, {ignoreError: true})
     } catch (e) {
       self.emit('error', e)
     }
   }
 
   response.caseless = caseless(response.headers)
 
   if (response.caseless.has('set-cookie') && (!self._disableCookies)) {
     var headerName = response.caseless.has('set-cookie')
     if (Array.isArray(response.headers[headerName])) {
       response.headers[headerName].forEach(addCookie)
     } else {
       addCookie(response.headers[headerName])
     }
   }
 
   if (self._redirect.onResponse(response)) {
     return // Ignore the rest of the response
   } else {
     // Be a good stream and emit end when the response is finished.
     // Hack to emit end on close because of a core bug that never fires end
     response.on('close', function () {
       if (!self._ended) {
         self.response.emit('end')
       }
     })
 
     response.once('end', function () {
       self._ended = true
     })
 
     var noBody = function (code) {
       return (
         self.method === 'HEAD' ||
         // Informational
         (code >= 100 && code < 200) ||
         // No Content
         code === 204 ||
         // Not Modified
         code === 304
       )
     }
 
     var responseContent
     if (self.gzip && !noBody(response.statusCode)) {
       var contentEncoding = response.headers['content-encoding'] || 'identity'
       contentEncoding = contentEncoding.trim().toLowerCase()
 
       // Be more lenient with decoding compressed responses, since (very rarely)
       // servers send slightly invalid gzip responses that are still accepted
       // by common browsers.
       // Always using Z_SYNC_FLUSH is what cURL does.
       var zlibOptions = {
         flush: zlib.Z_SYNC_FLUSH,
         finishFlush: zlib.Z_SYNC_FLUSH
       }
 
       if (contentEncoding === 'gzip') {
         responseContent = zlib.createGunzip(zlibOptions)
         response.pipe(responseContent)
       } else if (contentEncoding === 'deflate') {
         responseContent = zlib.createInflate(zlibOptions)
         response.pipe(responseContent)
       } else {
         // Since previous versions didn't check for Content-Encoding header,
         // ignore any invalid values to preserve backwards-compatibility
         if (contentEncoding !== 'identity') {
           debug('ignoring unrecognized Content-Encoding ' + contentEncoding)
         }
         responseContent = response
       }
     } else {
       responseContent = response
     }
 
     if (self.encoding) {
       if (self.dests.length !== 0) {
         console.error('Ignoring encoding parameter as this stream is being piped to another stream which makes the encoding option invalid.')
       } else {
         responseContent.setEncoding(self.encoding)
       }
     }
 
     if (self._paused) {
       responseContent.pause()
     }
 
     self.responseContent = responseContent
 
     self.emit('response', response)
 
     self.dests.forEach(function (dest) {
       self.pipeDest(dest)
     })
 
     responseContent.on('data', function (chunk) {
       if (self.timing && !self.responseStarted) {
         self.responseStartTime = (new Date()).getTime()
 
         // NOTE: responseStartTime is deprecated in favor of .timings
         response.responseStartTime = self.responseStartTime
       }
       self._destdata = true
       self.emit('data', chunk)
     })
     responseContent.once('end', function (chunk) {
       self.emit('end', chunk)
     })
     responseContent.on('error', function (error) {
       self.emit('error', error)
     })
     responseContent.on('close', function () { self.emit('close') })
 
     if (self.callback) {
       self.readResponseBody(response)
     } else { // if no callback
       self.on('end', function () {
         if (self._aborted) {
           debug('aborted', self.uri.href)
           return
         }
         self.emit('complete', response)
       })
     }
   }
   debug('finish init function', self.uri.href)
 }
 
 Request.prototype.readResponseBody = function (response) {
   var self = this
   debug("reading response's body")
   var buffers = []
   var bufferLength = 0
   var strings = []
 
   self.on('data', function (chunk) {
     if (!Buffer.isBuffer(chunk)) {
       strings.push(chunk)
     } else if (chunk.length) {
       bufferLength += chunk.length
       buffers.push(chunk)
     }
   })
   self.on('end', function () {
     debug('end event', self.uri.href)
     if (self._aborted) {
       debug('aborted', self.uri.href)
       // `buffer` is defined in the parent scope and used in a closure it exists for the life of the request.
       // This can lead to leaky behavior if the user retains a reference to the request object.
       buffers = []
       bufferLength = 0
       return
     }
 
     if (bufferLength) {
       debug('has body', self.uri.href, bufferLength)
       response.body = Buffer.concat(buffers, bufferLength)
       if (self.encoding !== null) {
         response.body = response.body.toString(self.encoding)
       }
       // `buffer` is defined in the parent scope and used in a closure it exists for the life of the Request.
       // This can lead to leaky behavior if the user retains a reference to the request object.
       buffers = []
       bufferLength = 0
     } else if (strings.length) {
       // The UTF8 BOM [0xEF,0xBB,0xBF] is converted to [0xFE,0xFF] in the JS UTC16/UCS2 representation.
       // Strip this value out when the encoding is set to 'utf8', as upstream consumers won't expect it and it breaks JSON.parse().
       if (self.encoding === 'utf8' && strings[0].length > 0 && strings[0][0] === '\uFEFF') {
         strings[0] = strings[0].substring(1)
       }
       response.body = strings.join('')
     }
 
     if (self._json) {
       try {
         response.body = JSON.parse(response.body, self._jsonReviver)
       } catch (e) {
         debug('invalid JSON received', self.uri.href)
       }
     }
     debug('emitting complete', self.uri.href)
     if (typeof response.body === 'undefined' && !self._json) {
       response.body = self.encoding === null ? Buffer.alloc(0) : ''
     }
     self.emit('complete', response, response.body)
   })
 }
 
 Request.prototype.abort = function () {
   var self = this
   self._aborted = true
 
   if (self.req) {
     self.req.abort()
   } else if (self.response) {
     self.response.destroy()
   }
 
   self.clearTimeout()
   self.emit('abort')
 }
 
 Request.prototype.pipeDest = function (dest) {
   var self = this
   var response = self.response
   // Called after the response is received
   if (dest.headers && !dest.headersSent) {
     if (response.caseless.has('content-type')) {
       var ctname = response.caseless.has('content-type')
       if (dest.setHeader) {
         dest.setHeader(ctname, response.headers[ctname])
       } else {
         dest.headers[ctname] = response.headers[ctname]
       }
     }
 
     if (response.caseless.has('content-length')) {
       var clname = response.caseless.has('content-length')
       if (dest.setHeader) {
         dest.setHeader(clname, response.headers[clname])
       } else {
         dest.headers[clname] = response.headers[clname]
       }
     }
   }
   if (dest.setHeader && !dest.headersSent) {
     for (var i in response.headers) {
       // If the response content is being decoded, the Content-Encoding header
       // of the response doesn't represent the piped content, so don't pass it.
       if (!self.gzip || i !== 'content-encoding') {
         dest.setHeader(i, response.headers[i])
       }
     }
     dest.statusCode = response.statusCode
   }
   if (self.pipefilter) {
     self.pipefilter(response, dest)
   }
 }
 
 Request.prototype.qs = function (q, clobber) {
   var self = this
   var base
   if (!clobber && self.uri.query) {
     base = self._qs.parse(self.uri.query)
   } else {
     base = {}
   }
 
   for (var i in q) {
     base[i] = q[i]
   }
 
   var qs = self._qs.stringify(base)
 
   if (qs === '') {
     return self
   }
 
   self.uri = url.parse(self.uri.href.split('?')[0] + '?' + qs)
   self.url = self.uri
   self.path = self.uri.path
 
   if (self.uri.host === 'unix') {
     self.enableUnixSocket()
   }
 
   return self
 }
 Request.prototype.form = function (form) {
   var self = this
   if (form) {
     if (!/^application\/x-www-form-urlencoded\b/.test(self.getHeader('content-type'))) {
       self.setHeader('content-type', 'application/x-www-form-urlencoded')
     }
     self.body = (typeof form === 'string')
       ? self._qs.rfc3986(form.toString('utf8'))
       : self._qs.stringify(form).toString('utf8')
     return self
   }
   // create form-data object
   self._form = new FormData()
   self._form.on('error', function (err) {
     err.message = 'form-data: ' + err.message
     self.emit('error', err)
     self.abort()
   })
   return self._form
 }
 Request.prototype.multipart = function (multipart) {
   var self = this
 
   self._multipart.onRequest(multipart)
 
   if (!self._multipart.chunked) {
     self.body = self._multipart.body
   }
 
   return self
 }
 Request.prototype.json = function (val) {
   var self = this
 
   if (!self.hasHeader('accept')) {
     self.setHeader('accept', 'application/json')
   }
 
   if (typeof self.jsonReplacer === 'function') {
     self._jsonReplacer = self.jsonReplacer
   }
 
   self._json = true
   if (typeof val === 'boolean') {
     if (self.body !== undefined) {
       if (!/^application\/x-www-form-urlencoded\b/.test(self.getHeader('content-type'))) {
         self.body = safeStringify(self.body, self._jsonReplacer)
       } else {
         self.body = self._qs.rfc3986(self.body)
       }
       if (!self.hasHeader('content-type')) {
         self.setHeader('content-type', 'application/json')
       }
     }
   } else {
     self.body = safeStringify(val, self._jsonReplacer)
     if (!self.hasHeader('content-type')) {
       self.setHeader('content-type', 'application/json')
     }
   }
 
   if (typeof self.jsonReviver === 'function') {
     self._jsonReviver = self.jsonReviver
   }
 
   return self
 }
 Request.prototype.getHeader = function (name, headers) {
   var self = this
   var result, re, match
   if (!headers) {
     headers = self.headers
   }
   Object.keys(headers).forEach(function (key) {
     if (key.length !== name.length) {
       return
     }
     re = new RegExp(name, 'i')
     match = key.match(re)
     if (match) {
       result = headers[key]
     }
   })
   return result
 }
 Request.prototype.enableUnixSocket = function () {
   // Get the socket & request paths from the URL
   var unixParts = this.uri.path.split(':')
   var host = unixParts[0]
   var path = unixParts[1]
   // Apply unix properties to request
   this.socketPath = host
   this.uri.pathname = path
   this.uri.path = path
   this.uri.host = host
   this.uri.hostname = host
   this.uri.isUnix = true
 }
 
 Request.prototype.auth = function (user, pass, sendImmediately, bearer) {
   var self = this
 
   self._auth.onRequest(user, pass, sendImmediately, bearer)
 
   return self
 }
 Request.prototype.aws = function (opts, now) {
   var self = this
 
   if (!now) {
     self._aws = opts
     return self
   }
 
   if (opts.sign_version === 4 || opts.sign_version === '4') {
     // use aws4
     var options = {
       host: self.uri.host,
       path: self.uri.path,
       method: self.method,
       headers: self.headers,
       body: self.body
     }
     if (opts.service) {
       options.service = opts.service
     }
     var signRes = aws4.sign(options, {
       accessKeyId: opts.key,
       secretAccessKey: opts.secret,
       sessionToken: opts.session
     })
     self.setHeader('authorization', signRes.headers.Authorization)
     self.setHeader('x-amz-date', signRes.headers['X-Amz-Date'])
     if (signRes.headers['X-Amz-Security-Token']) {
       self.setHeader('x-amz-security-token', signRes.headers['X-Amz-Security-Token'])
     }
   } else {
     // default: use aws-sign2
     var date = new Date()
     self.setHeader('date', date.toUTCString())
     var auth = {
       key: opts.key,
       secret: opts.secret,
       verb: self.method.toUpperCase(),
       date: date,
       contentType: self.getHeader('content-type') || '',
       md5: self.getHeader('content-md5') || '',
       amazonHeaders: aws2.canonicalizeHeaders(self.headers)
     }
     var path = self.uri.path
     if (opts.bucket && path) {
       auth.resource = '/' + opts.bucket + path
     } else if (opts.bucket && !path) {
       auth.resource = '/' + opts.bucket
     } else if (!opts.bucket && path) {
       auth.resource = path
     } else if (!opts.bucket && !path) {
       auth.resource = '/'
     }
     auth.resource = aws2.canonicalizeResource(auth.resource)
     self.setHeader('authorization', aws2.authorization(auth))
   }
 
   return self
 }
 Request.prototype.httpSignature = function (opts) {
   var self = this
   httpSignature.signRequest({
     getHeader: function (header) {
       return self.getHeader(header, self.headers)
     },
     setHeader: function (header, value) {
       self.setHeader(header, value)
     },
     method: self.method,
     path: self.path
   }, opts)
   debug('httpSignature authorization', self.getHeader('authorization'))
 
   return self
 }
 Request.prototype.hawk = function (opts) {
   var self = this
   self.setHeader('Authorization', hawk.header(self.uri, self.method, opts))
 }
 Request.prototype.oauth = function (_oauth) {
   var self = this
 
   self._oauth.onRequest(_oauth)
 
   return self
 }
 
 Request.prototype.jar = function (jar) {
   var self = this
   var cookies
 
   if (self._redirect.redirectsFollowed === 0) {
     self.originalCookieHeader = self.getHeader('cookie')
   }
 
   if (!jar) {
     // disable cookies
     cookies = false
     self._disableCookies = true
   } else {
     var targetCookieJar = jar.getCookieString ? jar : globalCookieJar
     var urihref = self.uri.href
     // fetch cookie in the Specified host
     if (targetCookieJar) {
       cookies = targetCookieJar.getCookieString(urihref)
     }
   }
 
   // if need cookie and cookie is not empty
   if (cookies && cookies.length) {
     if (self.originalCookieHeader) {
       // Don't overwrite existing Cookie header
       self.setHeader('cookie', self.originalCookieHeader + '; ' + cookies)
     } else {
       self.setHeader('cookie', cookies)
     }
   }
   self._jar = jar
   return self
 }
 
 // Stream API
 Request.prototype.pipe = function (dest, opts) {
   var self = this
 
   if (self.response) {
     if (self._destdata) {
       self.emit('error', new Error('You cannot pipe after data has been emitted from the response.'))
     } else if (self._ended) {
       self.emit('error', new Error('You cannot pipe after the response has been ended.'))
     } else {
       stream.Stream.prototype.pipe.call(self, dest, opts)
       self.pipeDest(dest)
       return dest
     }
   } else {
     self.dests.push(dest)
     stream.Stream.prototype.pipe.call(self, dest, opts)
     return dest
   }
 }
 Request.prototype.write = function () {
   var self = this
   if (self._aborted) { return }
 
   if (!self._started) {
     self.start()
   }
   if (self.req) {
     return self.req.write.apply(self.req, arguments)
   }
 }
 Request.prototype.end = function (chunk) {
   var self = this
   if (self._aborted) { return }
 
   if (chunk) {
     self.write(chunk)
   }
   if (!self._started) {
     self.start()
   }
   if (self.req) {
     self.req.end()
   }
 }
 Request.prototype.pause = function () {
   var self = this
   if (!self.responseContent) {
     self._paused = true
   } else {
     self.responseContent.pause.apply(self.responseContent, arguments)
   }
 }
 Request.prototype.resume = function () {
   var self = this
   if (!self.responseContent) {
     self._paused = false
   } else {
     self.responseContent.resume.apply(self.responseContent, arguments)
   }
 }
 Request.prototype.destroy = function () {
   var self = this
   this.clearTimeout()
   if (!self._ended) {
     self.end()
   } else if (self.response) {
     self.response.destroy()
   }
 }
 
 Request.prototype.clearTimeout = function () {
   if (this.timeoutTimer) {
     clearTimeout(this.timeoutTimer)
     this.timeoutTimer = null
   }
 }
 
 Request.defaultProxyHeaderWhiteList =
   Tunnel.defaultProxyHeaderWhiteList.slice()
 
 Request.defaultProxyHeaderExclusiveList =
   Tunnel.defaultProxyHeaderExclusiveList.slice()
 
 // Exports
 
 Request.prototype.toJSON = requestToJSON
 module.exports = Request