Upload 799 files

748250d almost 3 years ago

6.06 kB

/*!
 * raw-body
 * Copyright(c) 2013-2014 Jonathan Ong
 * Copyright(c) 2014-2015 Douglas Christopher Wilson
 * MIT Licensed
 */
'use strict'

/**
 * Module dependencies.
 * @private
 */

var bytes = require('bytes')
var createError = require('http-errors')
var iconv = require('iconv-lite')
var unpipe = require('unpipe')

/**
 * Module exports.
 * @public
 */

module.exports = getRawBody

/**
 * Module variables.
 * @private
 */

var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /

/**
 * Get the decoder for a given encoding.
 *
 * @param {string} encoding
 * @private
 */

function getDecoder (encoding) {
  if (!encoding) return null

  try {
    return iconv.getDecoder(encoding)
  } catch (e) {
    // error getting decoder
    if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e

    // the encoding was not found
    throw createError(415, 'specified encoding unsupported', {
      encoding: encoding,
      type: 'encoding.unsupported'
    })
  }
}

/**
 * Get the raw body of a stream (typically HTTP).
 *
 * @param {object} stream
 * @param {object|string|function} [options]
 * @param {function} [callback]
 * @public
 */

function getRawBody (stream, options, callback) {
  var done = callback
  var opts = options || {}

  if (options === true || typeof options === 'string') {
    // short cut for encoding
    opts = {
      encoding: options
    }
  }

  if (typeof options === 'function') {
    done = options
    opts = {}
  }

  // validate callback is a function, if provided
  if (done !== undefined && typeof done !== 'function') {
    throw new TypeError('argument callback must be a function')
  }

  // require the callback without promises
  if (!done && !global.Promise) {
    throw new TypeError('argument callback is required')
  }

  // get encoding
  var encoding = opts.encoding !== true
    ? opts.encoding
    : 'utf-8'

  // convert the limit to an integer
  var limit = bytes.parse(opts.limit)

  // convert the expected length to an integer
  var length = opts.length != null && !isNaN(opts.length)
    ? parseInt(opts.length, 10)
    : null

  if (done) {
    // classic callback style
    return readStream(stream, encoding, length, limit, done)
  }

  return new Promise(function executor (resolve, reject) {
    readStream(stream, encoding, length, limit, function onRead (err, buf) {
      if (err) return reject(err)
      resolve(buf)
    })
  })
}

/**
 * Halt a stream.
 *
 * @param {Object} stream
 * @private
 */

function halt (stream) {
  // unpipe everything from the stream
  unpipe(stream)

  // pause stream
  if (typeof stream.pause === 'function') {
    stream.pause()
  }
}

/**
 * Read the data from the stream.
 *
 * @param {object} stream
 * @param {string} encoding
 * @param {number} length
 * @param {number} limit
 * @param {function} callback
 * @public
 */

function readStream (stream, encoding, length, limit, callback) {
  var complete = false
  var sync = true

  // check the length and limit options.
  // note: we intentionally leave the stream paused,
  // so users should handle the stream themselves.
  if (limit !== null && length !== null && length > limit) {
    return done(createError(413, 'request entity too large', {
      expected: length,
      length: length,
      limit: limit,
      type: 'entity.too.large'
    }))
  }

  // streams1: assert request encoding is buffer.
  // streams2+: assert the stream encoding is buffer.
  //   stream._decoder: streams1
  //   state.encoding: streams2
  //   state.decoder: streams2, specifically < 0.10.6
  var state = stream._readableState
  if (stream._decoder || (state && (state.encoding || state.decoder))) {
    // developer error
    return done(createError(500, 'stream encoding should not be set', {
      type: 'stream.encoding.set'
    }))
  }

  var received = 0
  var decoder

  try {
    decoder = getDecoder(encoding)
  } catch (err) {
    return done(err)
  }

  var buffer = decoder
    ? ''
    : []

  // attach listeners
  stream.on('aborted', onAborted)
  stream.on('close', cleanup)
  stream.on('data', onData)
  stream.on('end', onEnd)
  stream.on('error', onEnd)

  // mark sync section complete
  sync = false

  function done () {
    var args = new Array(arguments.length)

    // copy arguments
    for (var i = 0; i < args.length; i++) {
      args[i] = arguments[i]
    }

    // mark complete
    complete = true

    if (sync) {
      process.nextTick(invokeCallback)
    } else {
      invokeCallback()
    }

    function invokeCallback () {
      cleanup()

      if (args[0]) {
        // halt the stream on error
        halt(stream)
      }

      callback.apply(null, args)
    }
  }

  function onAborted () {
    if (complete) return

    done(createError(400, 'request aborted', {
      code: 'ECONNABORTED',
      expected: length,
      length: length,
      received: received,
      type: 'request.aborted'
    }))
  }

  function onData (chunk) {
    if (complete) return

    received += chunk.length

    if (limit !== null && received > limit) {
      done(createError(413, 'request entity too large', {
        limit: limit,
        received: received,
        type: 'entity.too.large'
      }))
    } else if (decoder) {
      buffer += decoder.write(chunk)
    } else {
      buffer.push(chunk)
    }
  }

  function onEnd (err) {
    if (complete) return
    if (err) return done(err)

    if (length !== null && received !== length) {
      done(createError(400, 'request size did not match content length', {
        expected: length,
        length: length,
        received: received,
        type: 'request.size.invalid'
      }))
    } else {
      var string = decoder
        ? buffer + (decoder.end() || '')
        : Buffer.concat(buffer)
      done(null, string)
    }
  }

  function cleanup () {
    buffer = null

    stream.removeListener('aborted', onAborted)
    stream.removeListener('data', onData)
    stream.removeListener('end', onEnd)
    stream.removeListener('error', onEnd)
    stream.removeListener('close', cleanup)
  }
}

	/*!
	* raw-body
	* Copyright(c) 2013-2014 Jonathan Ong
	* Copyright(c) 2014-2015 Douglas Christopher Wilson
	* MIT Licensed
	*/

	'use strict'

	/**
	* Module dependencies.
	* @private
	*/

	var bytes = require('bytes')
	var createError = require('http-errors')
	var iconv = require('iconv-lite')
	var unpipe = require('unpipe')

	/**
	* Module exports.
	* @public
	*/

	module.exports = getRawBody

	/**
	* Module variables.
	* @private
	*/

	var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /

	/**
	* Get the decoder for a given encoding.
	*
	* @param {string} encoding
	* @private
	*/

	function getDecoder (encoding) {
	if (!encoding) return null

	try {
	return iconv.getDecoder(encoding)
	} catch (e) {
	// error getting decoder
	if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e

	// the encoding was not found
	throw createError(415, 'specified encoding unsupported', {
	encoding: encoding,
	type: 'encoding.unsupported'
	})
	}
	}

	/**
	* Get the raw body of a stream (typically HTTP).
	*
	* @param {object} stream
	* @param {object\|string\|function} [options]
	* @param {function} [callback]
	* @public
	*/

	function getRawBody (stream, options, callback) {
	var done = callback
	var opts = options \|\| {}

	if (options === true \|\| typeof options === 'string') {
	// short cut for encoding
	opts = {
	encoding: options
	}
	}

	if (typeof options === 'function') {
	done = options
	opts = {}
	}

	// validate callback is a function, if provided
	if (done !== undefined && typeof done !== 'function') {
	throw new TypeError('argument callback must be a function')
	}

	// require the callback without promises
	if (!done && !global.Promise) {
	throw new TypeError('argument callback is required')
	}

	// get encoding
	var encoding = opts.encoding !== true
	? opts.encoding
	: 'utf-8'

	// convert the limit to an integer
	var limit = bytes.parse(opts.limit)

	// convert the expected length to an integer
	var length = opts.length != null && !isNaN(opts.length)
	? parseInt(opts.length, 10)
	: null

	if (done) {
	// classic callback style
	return readStream(stream, encoding, length, limit, done)
	}

	return new Promise(function executor (resolve, reject) {
	readStream(stream, encoding, length, limit, function onRead (err, buf) {
	if (err) return reject(err)
	resolve(buf)
	})
	})
	}

	/**
	* Halt a stream.
	*
	* @param {Object} stream
	* @private
	*/

	function halt (stream) {
	// unpipe everything from the stream
	unpipe(stream)

	// pause stream
	if (typeof stream.pause === 'function') {
	stream.pause()
	}
	}

	/**
	* Read the data from the stream.
	*
	* @param {object} stream
	* @param {string} encoding
	* @param {number} length
	* @param {number} limit
	* @param {function} callback
	* @public
	*/

	function readStream (stream, encoding, length, limit, callback) {
	var complete = false
	var sync = true

	// check the length and limit options.
	// note: we intentionally leave the stream paused,
	// so users should handle the stream themselves.
	if (limit !== null && length !== null && length > limit) {
	return done(createError(413, 'request entity too large', {
	expected: length,
	length: length,
	limit: limit,
	type: 'entity.too.large'
	}))
	}

	// streams1: assert request encoding is buffer.
	// streams2+: assert the stream encoding is buffer.
	// stream._decoder: streams1
	// state.encoding: streams2
	// state.decoder: streams2, specifically < 0.10.6
	var state = stream._readableState
	if (stream._decoder \|\| (state && (state.encoding \|\| state.decoder))) {
	// developer error
	return done(createError(500, 'stream encoding should not be set', {
	type: 'stream.encoding.set'
	}))
	}

	var received = 0
	var decoder

	try {
	decoder = getDecoder(encoding)
	} catch (err) {
	return done(err)
	}

	var buffer = decoder
	? ''
	: []

	// attach listeners
	stream.on('aborted', onAborted)
	stream.on('close', cleanup)
	stream.on('data', onData)
	stream.on('end', onEnd)
	stream.on('error', onEnd)

	// mark sync section complete
	sync = false

	function done () {
	var args = new Array(arguments.length)

	// copy arguments
	for (var i = 0; i < args.length; i++) {
	args[i] = arguments[i]
	}

	// mark complete
	complete = true

	if (sync) {
	process.nextTick(invokeCallback)
	} else {
	invokeCallback()
	}

	function invokeCallback () {
	cleanup()

	if (args[0]) {
	// halt the stream on error
	halt(stream)
	}

	callback.apply(null, args)
	}
	}

	function onAborted () {
	if (complete) return

	done(createError(400, 'request aborted', {
	code: 'ECONNABORTED',
	expected: length,
	length: length,
	received: received,
	type: 'request.aborted'
	}))
	}

	function onData (chunk) {
	if (complete) return

	received += chunk.length

	if (limit !== null && received > limit) {
	done(createError(413, 'request entity too large', {
	limit: limit,
	received: received,
	type: 'entity.too.large'
	}))
	} else if (decoder) {
	buffer += decoder.write(chunk)
	} else {
	buffer.push(chunk)
	}
	}

	function onEnd (err) {
	if (complete) return
	if (err) return done(err)

	if (length !== null && received !== length) {
	done(createError(400, 'request size did not match content length', {
	expected: length,
	length: length,
	received: received,
	type: 'request.size.invalid'
	}))
	} else {
	var string = decoder
	? buffer + (decoder.end() \|\| '')
	: Buffer.concat(buffer)
	done(null, string)
	}
	}

	function cleanup () {
	buffer = null

	stream.removeListener('aborted', onAborted)
	stream.removeListener('data', onData)
	stream.removeListener('end', onEnd)
	stream.removeListener('error', onEnd)
	stream.removeListener('close', cleanup)
	}
	}