electron/lib/browser/api/net.js

'use strict'

const url = require('url')
const { EventEmitter } = require('events')
const { Readable, Writable } = require('stream')
const { app } = require('electron')
const { Session } = process.electronBinding('session')
const { net, Net, _isValidHeaderName, _isValidHeaderValue } = process.electronBinding('net')
const { URLLoader } = net

Object.setPrototypeOf(URLLoader.prototype, EventEmitter.prototype)

const kSupportedProtocols = new Set(['http:', 'https:'])

// set of headers that Node.js discards duplicates for
// see https://nodejs.org/api/http.html#http_message_headers
const discardableDuplicateHeaders = new Set([
  'content-type',
  'content-length',
  'user-agent',
  'referer',
  'host',
  'authorization',
  'proxy-authorization',
  'if-modified-since',
  'if-unmodified-since',
  'from',
  'location',
  'max-forwards',
  'retry-after',
  'etag',
  'last-modified',
  'server',
  'age',
  'expires'
])

class IncomingMessage extends Readable {
  constructor (responseHead) {
    super()
    this._shouldPush = false
    this._data = []
    this._responseHead = responseHead
  }

  get statusCode () {
    return this._responseHead.statusCode
  }

  get statusMessage () {
    return this._responseHead.statusMessage
  }

  get headers () {
    const filteredHeaders = {}
    const rawHeaders = this._responseHead.headers
    Object.keys(rawHeaders).forEach(header => {
      if (header in filteredHeaders && discardableDuplicateHeaders.has(header)) {
        // do nothing with discardable duplicate headers
      } else {
        if (header === 'set-cookie') {
          // keep set-cookie as an array per Node.js rules
          // see https://nodejs.org/api/http.html#http_message_headers
          filteredHeaders[header] = rawHeaders[header]
        } else {
          // for non-cookie headers, the values are joined together with ', '
          filteredHeaders[header] = rawHeaders[header].join(', ')
        }
      }
    })
    return filteredHeaders
  }

  get httpVersion () {
    return `${this.httpVersionMajor}.${this.httpVersionMinor}`
  }

  get httpVersionMajor () {
    return this._responseHead.httpVersion.major
  }

  get httpVersionMinor () {
    return this._responseHead.httpVersion.minor
  }

  get rawTrailers () {
    throw new Error('HTTP trailers are not supported')
  }

  get trailers () {
    throw new Error('HTTP trailers are not supported')
  }

  _storeInternalData (chunk) {
    this._data.push(chunk)
    this._pushInternalData()
  }

  _pushInternalData () {
    while (this._shouldPush && this._data.length > 0) {
      const chunk = this._data.shift()
      this._shouldPush = this.push(chunk)
    }
  }

  _read () {
    this._shouldPush = true
    this._pushInternalData()
  }
}

/** Writable stream that buffers up everything written to it. */
class SlurpStream extends Writable {
  constructor () {
    super()
    this._data = Buffer.alloc(0)
  }
  _write (chunk, encoding, callback) {
    this._data = Buffer.concat([this._data, chunk])
    callback()
  }
  data () { return this._data }
}

class ChunkedBodyStream extends Writable {
  constructor (clientRequest) {
    super()
    this._clientRequest = clientRequest
  }

  _write (chunk, encoding, callback) {
    if (this._downstream) {
      this._downstream.write(chunk).then(callback, callback)
    } else {
      // the contract of _write is that we won't be called again until we call
      // the callback, so we're good to just save a single chunk.
      this._pendingChunk = chunk
      this._pendingCallback = callback

      // The first write to a chunked body stream begins the request.
      this._clientRequest._startRequest()
    }
  }

  _final (callback) {
    this._downstream.done()
    callback()
  }

  startReading (pipe) {
    if (this._downstream) {
      throw new Error('two startReading calls???')
    }
    this._downstream = pipe
    if (this._pendingChunk) {
      const doneWriting = (maybeError) => {
        const cb = this._pendingCallback
        delete this._pendingCallback
        delete this._pendingChunk
        cb(maybeError)
      }
      this._downstream.write(this._pendingChunk).then(doneWriting, doneWriting)
    }
  }
}

function parseOptions (options) {
  if (typeof options === 'string') {
    options = url.parse(options)
  } else {
    options = { ...options }
  }

  const method = (options.method || 'GET').toUpperCase()
  let urlStr = options.url

  if (!urlStr) {
    const urlObj = {}
    const protocol = options.protocol || 'http:'
    if (!kSupportedProtocols.has(protocol)) {
      throw new Error('Protocol "' + protocol + '" not supported')
    }
    urlObj.protocol = protocol

    if (options.host) {
      urlObj.host = options.host
    } else {
      if (options.hostname) {
        urlObj.hostname = options.hostname
      } else {
        urlObj.hostname = 'localhost'
      }

      if (options.port) {
        urlObj.port = options.port
      }
    }

    if (options.path && / /.test(options.path)) {
      // The actual regex is more like /[^A-Za-z0-9\-._~!$&'()*+,;=/:@]/
      // with an additional rule for ignoring percentage-escaped characters
      // but that's a) hard to capture in a regular expression that performs
      // well, and b) possibly too restrictive for real-world usage. That's
      // why it only scans for spaces because those are guaranteed to create
      // an invalid request.
      throw new TypeError('Request path contains unescaped characters')
    }
    const pathObj = url.parse(options.path || '/')
    urlObj.pathname = pathObj.pathname
    urlObj.search = pathObj.search
    urlObj.hash = pathObj.hash
    urlStr = url.format(urlObj)
  }

  const redirectPolicy = options.redirect || 'follow'
  if (!['follow', 'error', 'manual'].includes(redirectPolicy)) {
    throw new Error('redirect mode should be one of follow, error or manual')
  }

  if (options.headers != null && typeof options.headers !== 'object') {
    throw new TypeError('headers must be an object')
  }

  const urlLoaderOptions = {
    method: method,
    url: urlStr,
    redirectPolicy,
    extraHeaders: options.headers || {}
  }
  for (const [name, value] of Object.entries(urlLoaderOptions.extraHeaders)) {
    if (!_isValidHeaderName(name)) {
      throw new Error(`Invalid header name: '${name}'`)
    }
    if (!_isValidHeaderValue(value.toString())) {
      throw new Error(`Invalid value for header '${name}': '${value}'`)
    }
  }
  if (options.session) {
    if (options.session instanceof Session) {
      urlLoaderOptions.session = options.session
    } else {
      throw new TypeError('`session` should be an instance of the Session class')
    }
  } else if (options.partition) {
    if (typeof options.partition === 'string') {
      urlLoaderOptions.partition = options.partition
    } else {
      throw new TypeError('`partition` should be a string')
    }
  }
  return urlLoaderOptions
}

class ClientRequest extends Writable {
  constructor (options, callback) {
    super({ autoDestroy: true })

    if (!app.isReady()) {
      throw new Error('net module can only be used after app is ready')
    }

    if (callback) {
      this.once('response', callback)
    }

    const { redirectPolicy, ...urlLoaderOptions } = parseOptions(options)
    this._urlLoaderOptions = urlLoaderOptions
    this._redirectPolicy = redirectPolicy
    this._started = false
  }

  set chunkedEncoding (value) {
    if (this._started) {
      throw new Error('chunkedEncoding can only be set before the request is started')
    }
    if (typeof this._chunkedEncoding !== 'undefined') {
      throw new Error('chunkedEncoding can only be set once')
    }
    this._chunkedEncoding = !!value
    if (this._chunkedEncoding) {
      this._body = new ChunkedBodyStream(this)
      this._urlLoaderOptions.body = (pipe) => {
        this._body.startReading(pipe)
      }
    }
  }

  setHeader (name, value) {
    if (typeof name !== 'string') {
      throw new TypeError('`name` should be a string in setHeader(name, value)')
    }
    if (value == null) {
      throw new Error('`value` required in setHeader("' + name + '", value)')
    }
    if (this._started || this._firstWrite) {
      throw new Error('Can\'t set headers after they are sent')
    }
    if (!_isValidHeaderName(name)) {
      throw new Error(`Invalid header name: '${name}'`)
    }
    if (!_isValidHeaderValue(value.toString())) {
      throw new Error(`Invalid value for header '${name}': '${value}'`)
    }

    const key = name.toLowerCase()
    this._urlLoaderOptions.extraHeaders[key] = value
  }

  getHeader (name) {
    if (name == null) {
      throw new Error('`name` is required for getHeader(name)')
    }

    const key = name.toLowerCase()
    return this._urlLoaderOptions.extraHeaders[key]
  }

  removeHeader (name) {
    if (name == null) {
      throw new Error('`name` is required for removeHeader(name)')
    }

    if (this._started || this._firstWrite) {
      throw new Error('Can\'t remove headers after they are sent')
    }

    const key = name.toLowerCase()
    delete this._urlLoaderOptions.extraHeaders[key]
  }

  _write (chunk, encoding, callback) {
    this._firstWrite = true
    if (!this._body) {
      this._body = new SlurpStream()
      this._body.on('finish', () => {
        this._urlLoaderOptions.body = this._body.data()
        this._startRequest()
      })
    }
    // TODO: is this the right way to forward to another stream?
    this._body.write(chunk, encoding, callback)
  }

  _final (callback) {
    if (this._body) {
      // TODO: is this the right way to forward to another stream?
      this._body.end(callback)
    } else {
      // end() called without a body, go ahead and start the request
      this._startRequest()
      callback()
    }
  }

  _startRequest () {
    this._started = true
    const stringifyValues = (obj) => {
      const ret = {}
      for (const k in obj) {
        ret[k] = obj[k].toString()
      }
      return ret
    }
    const opts = { ...this._urlLoaderOptions, extraHeaders: stringifyValues(this._urlLoaderOptions.extraHeaders) }
    this._urlLoader = new URLLoader(opts)
    this._urlLoader.on('response-started', (event, finalUrl, responseHead) => {
      const response = this._response = new IncomingMessage(responseHead)
      this.emit('response', response)
    })
    this._urlLoader.on('data', (event, data) => {
      this._response._storeInternalData(Buffer.from(data))
    })
    this._urlLoader.on('complete', () => {
      if (this._response) { this._response._storeInternalData(null) }
    })
    this._urlLoader.on('error', (event, netErrorString) => {
      const error = new Error(netErrorString)
      if (this._response) this._response.destroy(error)
      this._die(error)
    })

    this._urlLoader.on('login', (event, authInfo, callback) => {
      const handled = this.emit('login', authInfo, callback)
      if (!handled) {
        // If there were no listeners, cancel the authentication request.
        callback()
      }
    })

    this._urlLoader.on('redirect', (event, redirectInfo, headers) => {
      const { statusCode, newMethod, newUrl } = redirectInfo
      if (this._redirectPolicy === 'error') {
        this._die(new Error(`Attempted to redirect, but redirect policy was 'error'`))
      } else if (this._redirectPolicy === 'manual') {
        let _followRedirect = false
        this._followRedirectCb = () => { _followRedirect = true }
        try {
          this.emit('redirect', statusCode, newMethod, newUrl, headers)
        } finally {
          this._followRedirectCb = null
          if (!_followRedirect) {
            this._die(new Error('Redirect was cancelled'))
          }
        }
      } else if (this._redirectPolicy === 'follow') {
        // Calling followRedirect() when the redirect policy is 'follow' is
        // allowed but does nothing. (Perhaps it should throw an error
        // though...? Since the redirect will happen regardless.)
        try {
          this._followRedirectCb = () => {}
          this.emit('redirect', statusCode, newMethod, newUrl, headers)
        } finally {
          this._followRedirectCb = null
        }
      } else {
        this._die(new Error(`Unexpected redirect policy '${this._redirectPolicy}'`))
      }
    })

    this._urlLoader.on('upload-progress', (event, position, total) => {
      this._uploadProgress = { active: true, started: true, current: position, total }
      this.emit('upload-progress', position, total) // Undocumented, for now
    })

    this._urlLoader.on('download-progress', (event, current) => {
      if (this._response) {
        this._response.emit('download-progress', current) // Undocumented, for now
      }
    })
  }

  followRedirect () {
    if (this._followRedirectCb) {
      this._followRedirectCb()
    } else {
      throw new Error('followRedirect() called, but was not waiting for a redirect')
    }
  }

  abort () {
    if (!this._aborted) {
      process.nextTick(() => { this.emit('abort') })
    }
    this._aborted = true
    this._die()
  }

  _die (err) {
    this.destroy(err)
    if (this._urlLoader) {
      this._urlLoader.cancel()
      if (this._response) this._response.destroy(err)
    }
  }

  getUploadProgress () {
    return { ...this._uploadProgress } || { active: false }
  }
}

Net.prototype.request = function (options, callback) {
  return new ClientRequest(options, callback)
}

net.ClientRequest = ClientRequest

module.exports = net