text: 'use strict'
  
  var http = require('http')
    , https = require('https')
    , url = require('url')
    , util = require('util')
    , stream = require('stream')
    , zlib = require('zlib')
    , hawk = require('hawk')
    , aws2 = require('aws-sign2')
    , aws4 = require('aws4')
    , httpSignature = require('http-signature')
    , mime = require('mime-types')
    , stringstream = require('stringstream')
    , caseless = require('caseless')
    , ForeverAgent = require('forever-agent')
    , FormData = require('form-data')
    , extend = require('extend')
    , isstream = require('isstream')
    , isTypedArray = require('is-typedarray').strict
    , helpers = require('./lib/helpers')
    , cookies = require('./lib/cookies')
    , getProxyFromURI = require('./lib/getProxyFromURI')
    , Querystring = require('./lib/querystring').Querystring
    , Har = require('./lib/har').Har
    , Auth = require('./lib/auth').Auth
    , OAuth = require('./lib/oauth').OAuth
    , Multipart = require('./lib/multipart').Multipart
    , Redirect = require('./lib/redirect').Redirect
    , Tunnel = require('./lib/tunnel').Tunnel
  
  var safeStringify = helpers.safeStringify
    , isReadStream = helpers.isReadStream
    , toBase64 = helpers.toBase64
    , defer = helpers.defer
    , copy = helpers.copy
    , version = helpers.version
    , 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.hostname)
      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.getHeader('host') + (':' + self.uri.port) )
        }
      }
      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
      self.elapsedTime = self.elapsedTime || 0
    }
  
    function setContentLength () {
      if (isTypedArray(self.body)) {
        self.body = new Buffer(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
      , defaultModules = {'http:':http, 'https:':https}
      , 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._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 = new Date().getTime()
    }
  
    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
      // 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 (timeout !== undefined && isConnecting) {
        var onReqSockConnect = function() {
          socket.removeListener('connect', onReqSockConnect)
          clearTimeout(self.timeoutTimer)
          self.timeoutTimer = null
          // Set an additional timeout on the socket, via the `setsockopt` syscall.
          // 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)
            }
          })
        }
  
        socket.on('connect', onReqSockConnect)
  
        self.req.on('error', function(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)
      }
      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
    }
    if (self.timeout && self.timeoutTimer) {
      clearTimeout(self.timeoutTimer)
      self.timeoutTimer = null
    }
    self.emit('error', error)
  }
  
  Request.prototype.onRequestResponse = function (response) {
    var self = this
    debug('onRequestResponse', self.uri.href, response.statusCode, response.headers)
    response.on('end', function() {
      if (self.timing) {
        self.elapsedTime += (new Date().getTime() - self.startTime)
        debug('elapsed time', self.elapsedTime)
        response.elapsedTime = self.elapsedTime
      }
      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')
    }
    if (self.timeout && self.timeoutTimer) {
      clearTimeout(self.timeoutTimer)
      self.timeoutTimer = null
    }
  
    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()
  
        if (contentEncoding === 'gzip') {
          responseContent = zlib.createGunzip()
          response.pipe(responseContent)
        } else if (contentEncoding === 'deflate') {
          responseContent = zlib.createInflate()
          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 if (responseContent.setEncoding) {
          responseContent.setEncoding(self.encoding)
        } else {
          // Should only occur on node pre-v0.9.4 (joyent/node@9b5abe5) with
          // zlib streams.
          // If/When support for 0.9.4 is dropped, this should be unnecessary.
          responseContent = responseContent.pipe(stringstream(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()
          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)
      }
      //if no callback
      else {
        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 = []
      , bufferLength = 0
      , 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 ? new Buffer(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.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(':')
      , host = unixParts[0]
      , 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: {
          'content-type': self.getHeader('content-type') || ''
        },
        body: self.body
      }
      var signRes = aws4.sign(options, {
        accessKeyId: opts.key,
        secretAccessKey: opts.secret
      })
      self.setHeader('authorization', signRes.headers.Authorization)
      self.setHeader('x-amz-date', signRes.headers['X-Amz-Date'])
    }
    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.client.header(self.uri, self.method, opts).field)
  }
  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 && 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
    if (!self._ended) {
      self.end()
    } else if (self.response) {
      self.response.destroy()
    }
  }
  
  Request.defaultProxyHeaderWhiteList =
    Tunnel.defaultProxyHeaderWhiteList.slice()
  
  Request.defaultProxyHeaderExclusiveList =
    Tunnel.defaultProxyHeaderExclusiveList.slice()
  
  // Exports
  
  Request.prototype.toJSON = requestToJSON
  module.exports = Request
  