lib/_http_outgoing.js - v8/node - Git at Google

 'use strict';

 const assert = require('assert').ok;
 const Stream = require('stream');
 const timers = require('timers');
 const util = require('util');
 const Buffer = require('buffer').Buffer;
 const common = require('_http_common');

 const CRLF = common.CRLF;
 const chunkExpression = common.chunkExpression;
 const debug = common.debug;

 const connectionExpression = /^Connection$/i;
 const transferEncodingExpression = /^Transfer-Encoding$/i;
 const closeExpression = /close/i;
 const contentLengthExpression = /^Content-Length$/i;
 const dateExpression = /^Date$/i;
 const expectExpression = /^Expect$/i;
 const trailerExpression = /^Trailer$/i;

 const automaticHeaders = {
   connection: true,
   'content-length': true,
   'transfer-encoding': true,
   date: true
 };


 var dateCache;
 function utcDate() {
   if (!dateCache) {
     var d = new Date();
     dateCache = d.toUTCString();
     timers.enroll(utcDate, 1000 - d.getMilliseconds());
     timers._unrefActive(utcDate);
   }
   return dateCache;
 }
 utcDate._onTimeout = function() {
   dateCache = undefined;
 };


 function OutgoingMessage() {
   Stream.call(this);

   this.output = [];
   this.outputEncodings = [];
   this.outputCallbacks = [];

   this.writable = true;

   this._last = false;
   this.chunkedEncoding = false;
   this.shouldKeepAlive = true;
   this.useChunkedEncodingByDefault = true;
   this.sendDate = false;
   this._removedHeader = {};

   this._contentLength = null;
   this._hasBody = true;
   this._trailer = '';

   this.finished = false;
   this._headerSent = false;

   this.socket = null;
   this.connection = null;
   this._header = null;
   this._headers = null;
   this._headerNames = {};
 }
 util.inherits(OutgoingMessage, Stream);


 exports.OutgoingMessage = OutgoingMessage;


 OutgoingMessage.prototype.setTimeout = function(msecs, callback) {
   if (callback)
     this.on('timeout', callback);

   if (!this.socket) {
     this.once('socket', function(socket) {
       socket.setTimeout(msecs);
     });
   } else {
     this.socket.setTimeout(msecs);
   }
   return this;
 };


 // It's possible that the socket will be destroyed, and removed from
 // any messages, before ever calling this.  In that case, just skip
 // it, since something else is destroying this connection anyway.
 OutgoingMessage.prototype.destroy = function(error) {
   if (this.socket)
     this.socket.destroy(error);
   else
     this.once('socket', function(socket) {
       socket.destroy(error);
     });
 };


 // This abstract either writing directly to the socket or buffering it.
 OutgoingMessage.prototype._send = function(data, encoding, callback) {
   // This is a shameful hack to get the headers and first body chunk onto
   // the same packet. Future versions of Node are going to take care of
   // this at a lower level and in a more general way.
   if (!this._headerSent) {
     if (typeof data === 'string' &&
         encoding !== 'hex' &&
         encoding !== 'base64') {
       data = this._header + data;
     } else {
       this.output.unshift(this._header);
       this.outputEncodings.unshift('binary');
       this.outputCallbacks.unshift(null);
     }
     this._headerSent = true;
   }
   return this._writeRaw(data, encoding, callback);
 };


 OutgoingMessage.prototype._writeRaw = function(data, encoding, callback) {
   if (typeof encoding === 'function') {
     callback = encoding;
     encoding = null;
   }

   if (data.length === 0) {
     if (typeof callback === 'function')
       process.nextTick(callback);
     return true;
   }

   var connection = this.connection;
   if (connection &&
       connection._httpMessage === this &&
       connection.writable &&
       !connection.destroyed) {
     // There might be pending data in the this.output buffer.
     var outputLength = this.output.length;
     if (outputLength > 0) {
       var output = this.output;
       var outputEncodings = this.outputEncodings;
       var outputCallbacks = this.outputCallbacks;
       for (var i = 0; i < outputLength; i++) {
         connection.write(output[i], outputEncodings[i],
                          outputCallbacks[i]);
       }

       this.output = [];
       this.outputEncodings = [];
       this.outputCallbacks = [];
     }

     // Directly write to socket.
     return connection.write(data, encoding, callback);
   } else if (connection && connection.destroyed) {
     // The socket was destroyed.  If we're still trying to write to it,
     // then we haven't gotten the 'close' event yet.
     return false;
   } else {
     // buffer, as long as we're not destroyed.
     return this._buffer(data, encoding, callback);
   }
 };


 OutgoingMessage.prototype._buffer = function(data, encoding, callback) {
   this.output.push(data);
   this.outputEncodings.push(encoding);
   this.outputCallbacks.push(callback);
   return false;
 };


 OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {
   // firstLine in the case of request is: 'GET /index.html HTTP/1.1\r\n'
   // in the case of response it is: 'HTTP/1.1 200 OK\r\n'
   var state = {
     sentConnectionHeader: false,
     sentContentLengthHeader: false,
     sentTransferEncodingHeader: false,
     sentDateHeader: false,
     sentExpect: false,
     sentTrailer: false,
     messageHeader: firstLine
   };

   if (headers) {
     var keys = Object.keys(headers);
     var isArray = Array.isArray(headers);
     var field, value;

     for (var i = 0, l = keys.length; i < l; i++) {
       var key = keys[i];
       if (isArray) {
         field = headers[key][0];
         value = headers[key][1];
       } else {
         field = key;
         value = headers[key];
       }

       if (Array.isArray(value)) {
         for (var j = 0; j < value.length; j++) {
           storeHeader(this, state, field, value[j]);
         }
       } else {
         storeHeader(this, state, field, value);
       }
     }
   }

   // Date header
   if (this.sendDate === true && state.sentDateHeader === false) {
     state.messageHeader += 'Date: ' + utcDate() + CRLF;
   }

   // Force the connection to close when the response is a 204 No Content or
   // a 304 Not Modified and the user has set a "Transfer-Encoding: chunked"
   // header.
   //
   // RFC 2616 mandates that 204 and 304 responses MUST NOT have a body but
   // node.js used to send out a zero chunk anyway to accommodate clients
   // that don't have special handling for those responses.
   //
   // It was pointed out that this might confuse reverse proxies to the point
   // of creating security liabilities, so suppress the zero chunk and force
   // the connection to close.
   var statusCode = this.statusCode;
   if ((statusCode === 204 || statusCode === 304) &&
       this.chunkedEncoding === true) {
     debug(statusCode + ' response should not use chunked encoding,' +
           ' closing connection.');
     this.chunkedEncoding = false;
     this.shouldKeepAlive = false;
   }

   // keep-alive logic
   if (this._removedHeader.connection) {
     this._last = true;
     this.shouldKeepAlive = false;
   } else if (state.sentConnectionHeader === false) {
     var shouldSendKeepAlive = this.shouldKeepAlive &&
         (state.sentContentLengthHeader ||
          this.useChunkedEncodingByDefault ||
          this.agent);
     if (shouldSendKeepAlive) {
       state.messageHeader += 'Connection: keep-alive\r\n';
     } else {
       this._last = true;
       state.messageHeader += 'Connection: close\r\n';
     }
   }

   if (state.sentContentLengthHeader === false &&
       state.sentTransferEncodingHeader === false) {
     if (!this._hasBody) {
       // Make sure we don't end the 0\r\n\r\n at the end of the message.
       this.chunkedEncoding = false;
     } else if (!this.useChunkedEncodingByDefault) {
       this._last = true;
     } else {
       if (!state.sentTrailer &&
           !this._removedHeader['content-length'] &&
           typeof this._contentLength === 'number') {
         state.messageHeader += 'Content-Length: ' + this._contentLength +
                                '\r\n';
       } else if (!this._removedHeader['transfer-encoding']) {
         state.messageHeader += 'Transfer-Encoding: chunked\r\n';
         this.chunkedEncoding = true;
       } else {
         // We should only be able to get here if both Content-Length and
         // Transfer-Encoding are removed by the user.
         // See: test/parallel/test-http-remove-header-stays-removed.js
         debug('Both Content-Length and Transfer-Encoding are removed');
       }
     }
   }

   this._header = state.messageHeader + CRLF;
   this._headerSent = false;

   // wait until the first body chunk, or close(), is sent to flush,
   // UNLESS we're sending Expect: 100-continue.
   if (state.sentExpect) this._send('');
 };

 function storeHeader(self, state, field, value) {
   // Protect against response splitting. The if statement is there to
   // minimize the performance impact in the common case.
   if (/[\r\n]/.test(value))
     value = value.replace(/[\r\n]+[ \t]*/g, '');

   state.messageHeader += field + ': ' + value + CRLF;

   if (connectionExpression.test(field)) {
     state.sentConnectionHeader = true;
     if (closeExpression.test(value)) {
       self._last = true;
     } else {
       self.shouldKeepAlive = true;
     }

   } else if (transferEncodingExpression.test(field)) {
     state.sentTransferEncodingHeader = true;
     if (chunkExpression.test(value)) self.chunkedEncoding = true;

   } else if (contentLengthExpression.test(field)) {
     state.sentContentLengthHeader = true;
   } else if (dateExpression.test(field)) {
     state.sentDateHeader = true;
   } else if (expectExpression.test(field)) {
     state.sentExpect = true;
   } else if (trailerExpression.test(field)) {
     state.sentTrailer = true;
   }
 }


 OutgoingMessage.prototype.setHeader = function(name, value) {
   if (typeof name !== 'string')
     throw new TypeError('`name` should be a string in setHeader(name, value).');
   if (value === undefined)
     throw new Error('`value` required in setHeader("' + name + '", value).');
   if (this._header)
     throw new Error('Can\'t set headers after they are sent.');

   if (this._headers === null)
     this._headers = {};

   var key = name.toLowerCase();
   this._headers[key] = value;
   this._headerNames[key] = name;

   if (automaticHeaders[key])
     this._removedHeader[key] = false;
 };


 OutgoingMessage.prototype.getHeader = function(name) {
   if (arguments.length < 1) {
     throw new Error('`name` is required for getHeader(name).');
   }

   if (!this._headers) return;

   var key = name.toLowerCase();
   return this._headers[key];
 };


 OutgoingMessage.prototype.removeHeader = function(name) {
   if (arguments.length < 1) {
     throw new Error('`name` is required for removeHeader(name).');
   }

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

   var key = name.toLowerCase();

   if (key === 'date')
     this.sendDate = false;
   else if (automaticHeaders[key])
     this._removedHeader[key] = true;

   if (this._headers) {
     delete this._headers[key];
     delete this._headerNames[key];
   }
 };


 OutgoingMessage.prototype._renderHeaders = function() {
   if (this._header) {
     throw new Error('Can\'t render headers after they are sent to the client.');
   }

   var headersMap = this._headers;
   if (!headersMap) return {};

   var headers = {};
   var keys = Object.keys(headersMap);
   var headerNames = this._headerNames;

   for (var i = 0, l = keys.length; i < l; i++) {
     var key = keys[i];
     headers[headerNames[key]] = headersMap[key];
   }
   return headers;
 };


 Object.defineProperty(OutgoingMessage.prototype, 'headersSent', {
   configurable: true,
   enumerable: true,
   get: function() { return !!this._header; }
 });


 OutgoingMessage.prototype.write = function(chunk, encoding, callback) {
   if (this.finished) {
     var err = new Error('write after end');
     process.nextTick(writeAfterEndNT, this, err, callback);

     return true;
   }

   if (!this._header) {
     this._implicitHeader();
   }

   if (!this._hasBody) {
     debug('This type of response MUST NOT have a body. ' +
           'Ignoring write() calls.');
     return true;
   }

   if (typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
     throw new TypeError('first argument must be a string or Buffer');
   }


   // If we get an empty string or buffer, then just do nothing, and
   // signal the user to keep writing.
   if (chunk.length === 0) return true;

   var len, ret;
   if (this.chunkedEncoding) {
     if (typeof chunk === 'string' &&
         encoding !== 'hex' &&
         encoding !== 'base64' &&
         encoding !== 'binary') {
       len = Buffer.byteLength(chunk, encoding);
       chunk = len.toString(16) + CRLF + chunk + CRLF;
       ret = this._send(chunk, encoding, callback);
     } else {
       // buffer, or a non-toString-friendly encoding
       if (typeof chunk === 'string')
         len = Buffer.byteLength(chunk, encoding);
       else
         len = chunk.length;

       if (this.connection && !this.connection.corked) {
         this.connection.cork();
         process.nextTick(connectionCorkNT, this.connection);
       }
       this._send(len.toString(16), 'binary', null);
       this._send(crlf_buf, null, null);
       this._send(chunk, encoding, null);
       ret = this._send(crlf_buf, null, callback);
     }
   } else {
     ret = this._send(chunk, encoding, callback);
   }

   debug('write ret = ' + ret);
   return ret;
 };


 function writeAfterEndNT(self, err, callback) {
   self.emit('error', err);
   if (callback) callback(err);
 }


 function connectionCorkNT(conn) {
   if (conn)
     conn.uncork();
 }


 OutgoingMessage.prototype.addTrailers = function(headers) {
   this._trailer = '';
   var keys = Object.keys(headers);
   var isArray = Array.isArray(headers);
   var field, value;
   for (var i = 0, l = keys.length; i < l; i++) {
     var key = keys[i];
     if (isArray) {
       field = headers[key][0];
       value = headers[key][1];
     } else {
       field = key;
       value = headers[key];
     }

     this._trailer += field + ': ' + value + CRLF;
   }
 };


 const crlf_buf = new Buffer('\r\n');


 OutgoingMessage.prototype.end = function(data, encoding, callback) {
   if (typeof data === 'function') {
     callback = data;
     data = null;
   } else if (typeof encoding === 'function') {
     callback = encoding;
     encoding = null;
   }

   if (data && typeof data !== 'string' && !(data instanceof Buffer)) {
     throw new TypeError('first argument must be a string or Buffer');
   }

   if (this.finished) {
     return false;
   }

   var self = this;
   function finish() {
     self.emit('finish');
   }

   if (typeof callback === 'function')
     this.once('finish', callback);

   if (!this._header) {
     if (data) {
       if (typeof data === 'string')
         this._contentLength = Buffer.byteLength(data, encoding);
       else
         this._contentLength = data.length;
     } else {
       this._contentLength = 0;
     }
     this._implicitHeader();
   }

   if (data && !this._hasBody) {
     debug('This type of response MUST NOT have a body. ' +
           'Ignoring data passed to end().');
     data = null;
   }

   if (this.connection && data)
     this.connection.cork();

   var ret;
   if (data) {
     // Normal body write.
     ret = this.write(data, encoding);
   }

   if (this._hasBody && this.chunkedEncoding) {
     ret = this._send('0\r\n' + this._trailer + '\r\n', 'binary', finish);
   } else {
     // Force a flush, HACK.
     ret = this._send('', 'binary', finish);
   }

   if (this.connection && data)
     this.connection.uncork();

   this.finished = true;

   // There is the first message on the outgoing queue, and we've sent
   // everything to the socket.
   debug('outgoing message end.');
   if (this.output.length === 0 && this.connection._httpMessage === this) {
     this._finish();
   }

   return ret;
 };


 OutgoingMessage.prototype._finish = function() {
   assert(this.connection);
   this.emit('prefinish');
 };


 // This logic is probably a bit confusing. Let me explain a bit:
 //
 // In both HTTP servers and clients it is possible to queue up several
 // outgoing messages. This is easiest to imagine in the case of a client.
 // Take the following situation:
 //
 //    req1 = client.request('GET', '/');
 //    req2 = client.request('POST', '/');
 //
 // When the user does
 //
 //   req2.write('hello world\n');
 //
 // it's possible that the first request has not been completely flushed to
 // the socket yet. Thus the outgoing messages need to be prepared to queue
 // up data internally before sending it on further to the socket's queue.
 //
 // This function, outgoingFlush(), is called by both the Server and Client
 // to attempt to flush any pending messages out to the socket.
 OutgoingMessage.prototype._flush = function() {
   var socket = this.socket;
   var outputLength, ret;

   if (socket && socket.writable) {
     // There might be remaining data in this.output; write it out
     outputLength = this.output.length;
     if (outputLength > 0) {
       var output = this.output;
       var outputEncodings = this.outputEncodings;
       var outputCallbacks = this.outputCallbacks;
       for (var i = 0; i < outputLength; i++) {
         ret = socket.write(output[i], outputEncodings[i],
                            outputCallbacks[i]);
       }

       this.output = [];
       this.outputEncodings = [];
       this.outputCallbacks = [];
     }

     if (this.finished) {
       // This is a queue to the server or client to bring in the next this.
       this._finish();
     } else if (ret) {
       // This is necessary to prevent https from breaking
       this.emit('drain');
     }
   }
 };


 OutgoingMessage.prototype.flushHeaders = function() {
   if (!this._header) {
     this._implicitHeader();
   }

   // Force-flush the headers.
   this._send('');
 };

 OutgoingMessage.prototype.flush = util.deprecate(function() {
   this.flushHeaders();
 }, 'flush is deprecated. Use flushHeaders instead.');
	'use strict';

	const assert = require('assert').ok;
	const Stream = require('stream');
	const timers = require('timers');
	const util = require('util');
	const Buffer = require('buffer').Buffer;
	const common = require('_http_common');

	const CRLF = common.CRLF;
	const chunkExpression = common.chunkExpression;
	const debug = common.debug;

	const connectionExpression = /^Connection$/i;
	const transferEncodingExpression = /^Transfer-Encoding$/i;
	const closeExpression = /close/i;
	const contentLengthExpression = /^Content-Length$/i;
	const dateExpression = /^Date$/i;
	const expectExpression = /^Expect$/i;
	const trailerExpression = /^Trailer$/i;

	const automaticHeaders = {
	connection: true,
	'content-length': true,
	'transfer-encoding': true,
	date: true
	};


	var dateCache;
	function utcDate() {
	if (!dateCache) {
	var d = new Date();
	dateCache = d.toUTCString();
	timers.enroll(utcDate, 1000 - d.getMilliseconds());
	timers._unrefActive(utcDate);
	}
	return dateCache;
	}
	utcDate._onTimeout = function() {
	dateCache = undefined;
	};


	function OutgoingMessage() {
	Stream.call(this);

	this.output = [];
	this.outputEncodings = [];
	this.outputCallbacks = [];

	this.writable = true;

	this._last = false;
	this.chunkedEncoding = false;
	this.shouldKeepAlive = true;
	this.useChunkedEncodingByDefault = true;
	this.sendDate = false;
	this._removedHeader = {};

	this._contentLength = null;
	this._hasBody = true;
	this._trailer = '';

	this.finished = false;
	this._headerSent = false;

	this.socket = null;
	this.connection = null;
	this._header = null;
	this._headers = null;
	this._headerNames = {};
	}
	util.inherits(OutgoingMessage, Stream);


	exports.OutgoingMessage = OutgoingMessage;


	OutgoingMessage.prototype.setTimeout = function(msecs, callback) {
	if (callback)
	this.on('timeout', callback);

	if (!this.socket) {
	this.once('socket', function(socket) {
	socket.setTimeout(msecs);
	});
	} else {
	this.socket.setTimeout(msecs);
	}
	return this;
	};


	// It's possible that the socket will be destroyed, and removed from
	// any messages, before ever calling this. In that case, just skip
	// it, since something else is destroying this connection anyway.
	OutgoingMessage.prototype.destroy = function(error) {
	if (this.socket)
	this.socket.destroy(error);
	else
	this.once('socket', function(socket) {
	socket.destroy(error);
	});
	};


	// This abstract either writing directly to the socket or buffering it.
	OutgoingMessage.prototype._send = function(data, encoding, callback) {
	// This is a shameful hack to get the headers and first body chunk onto
	// the same packet. Future versions of Node are going to take care of
	// this at a lower level and in a more general way.
	if (!this._headerSent) {
	if (typeof data === 'string' &&
	encoding !== 'hex' &&
	encoding !== 'base64') {
	data = this._header + data;
	} else {
	this.output.unshift(this._header);
	this.outputEncodings.unshift('binary');
	this.outputCallbacks.unshift(null);
	}
	this._headerSent = true;
	}
	return this._writeRaw(data, encoding, callback);
	};


	OutgoingMessage.prototype._writeRaw = function(data, encoding, callback) {
	if (typeof encoding === 'function') {
	callback = encoding;
	encoding = null;
	}

	if (data.length === 0) {
	if (typeof callback === 'function')
	process.nextTick(callback);
	return true;
	}

	var connection = this.connection;
	if (connection &&
	connection._httpMessage === this &&
	connection.writable &&
	!connection.destroyed) {
	// There might be pending data in the this.output buffer.
	var outputLength = this.output.length;
	if (outputLength > 0) {
	var output = this.output;
	var outputEncodings = this.outputEncodings;
	var outputCallbacks = this.outputCallbacks;
	for (var i = 0; i < outputLength; i++) {
	connection.write(output[i], outputEncodings[i],
	outputCallbacks[i]);
	}

	this.output = [];
	this.outputEncodings = [];
	this.outputCallbacks = [];
	}

	// Directly write to socket.
	return connection.write(data, encoding, callback);
	} else if (connection && connection.destroyed) {
	// The socket was destroyed. If we're still trying to write to it,
	// then we haven't gotten the 'close' event yet.
	return false;
	} else {
	// buffer, as long as we're not destroyed.
	return this._buffer(data, encoding, callback);
	}
	};


	OutgoingMessage.prototype._buffer = function(data, encoding, callback) {
	this.output.push(data);
	this.outputEncodings.push(encoding);
	this.outputCallbacks.push(callback);
	return false;
	};


	OutgoingMessage.prototype._storeHeader = function(firstLine, headers) {
	// firstLine in the case of request is: 'GET /index.html HTTP/1.1\r\n'
	// in the case of response it is: 'HTTP/1.1 200 OK\r\n'
	var state = {
	sentConnectionHeader: false,
	sentContentLengthHeader: false,
	sentTransferEncodingHeader: false,
	sentDateHeader: false,
	sentExpect: false,
	sentTrailer: false,
	messageHeader: firstLine
	};

	if (headers) {
	var keys = Object.keys(headers);
	var isArray = Array.isArray(headers);
	var field, value;

	for (var i = 0, l = keys.length; i < l; i++) {
	var key = keys[i];
	if (isArray) {
	field = headers[key][0];
	value = headers[key][1];
	} else {
	field = key;
	value = headers[key];
	}

	if (Array.isArray(value)) {
	for (var j = 0; j < value.length; j++) {
	storeHeader(this, state, field, value[j]);
	}
	} else {
	storeHeader(this, state, field, value);
	}
	}
	}

	// Date header
	if (this.sendDate === true && state.sentDateHeader === false) {
	state.messageHeader += 'Date: ' + utcDate() + CRLF;
	}

	// Force the connection to close when the response is a 204 No Content or
	// a 304 Not Modified and the user has set a "Transfer-Encoding: chunked"
	// header.
	//
	// RFC 2616 mandates that 204 and 304 responses MUST NOT have a body but
	// node.js used to send out a zero chunk anyway to accommodate clients
	// that don't have special handling for those responses.
	//
	// It was pointed out that this might confuse reverse proxies to the point
	// of creating security liabilities, so suppress the zero chunk and force
	// the connection to close.
	var statusCode = this.statusCode;
	if ((statusCode === 204 \|\| statusCode === 304) &&
	this.chunkedEncoding === true) {
	debug(statusCode + ' response should not use chunked encoding,' +
	' closing connection.');
	this.chunkedEncoding = false;
	this.shouldKeepAlive = false;
	}

	// keep-alive logic
	if (this._removedHeader.connection) {
	this._last = true;
	this.shouldKeepAlive = false;
	} else if (state.sentConnectionHeader === false) {
	var shouldSendKeepAlive = this.shouldKeepAlive &&
	(state.sentContentLengthHeader \|\|
	this.useChunkedEncodingByDefault \|\|
	this.agent);
	if (shouldSendKeepAlive) {
	state.messageHeader += 'Connection: keep-alive\r\n';
	} else {
	this._last = true;
	state.messageHeader += 'Connection: close\r\n';
	}
	}

	if (state.sentContentLengthHeader === false &&
	state.sentTransferEncodingHeader === false) {
	if (!this._hasBody) {
	// Make sure we don't end the 0\r\n\r\n at the end of the message.
	this.chunkedEncoding = false;
	} else if (!this.useChunkedEncodingByDefault) {
	this._last = true;
	} else {
	if (!state.sentTrailer &&
	!this._removedHeader['content-length'] &&
	typeof this._contentLength === 'number') {
	state.messageHeader += 'Content-Length: ' + this._contentLength +
	'\r\n';
	} else if (!this._removedHeader['transfer-encoding']) {
	state.messageHeader += 'Transfer-Encoding: chunked\r\n';
	this.chunkedEncoding = true;
	} else {
	// We should only be able to get here if both Content-Length and
	// Transfer-Encoding are removed by the user.
	// See: test/parallel/test-http-remove-header-stays-removed.js
	debug('Both Content-Length and Transfer-Encoding are removed');
	}
	}
	}

	this._header = state.messageHeader + CRLF;
	this._headerSent = false;

	// wait until the first body chunk, or close(), is sent to flush,
	// UNLESS we're sending Expect: 100-continue.
	if (state.sentExpect) this._send('');
	};

	function storeHeader(self, state, field, value) {
	// Protect against response splitting. The if statement is there to
	// minimize the performance impact in the common case.
	if (/[\r\n]/.test(value))
	value = value.replace(/[\r\n]+[ \t]*/g, '');

	state.messageHeader += field + ': ' + value + CRLF;

	if (connectionExpression.test(field)) {
	state.sentConnectionHeader = true;
	if (closeExpression.test(value)) {
	self._last = true;
	} else {
	self.shouldKeepAlive = true;
	}

	} else if (transferEncodingExpression.test(field)) {
	state.sentTransferEncodingHeader = true;
	if (chunkExpression.test(value)) self.chunkedEncoding = true;

	} else if (contentLengthExpression.test(field)) {
	state.sentContentLengthHeader = true;
	} else if (dateExpression.test(field)) {
	state.sentDateHeader = true;
	} else if (expectExpression.test(field)) {
	state.sentExpect = true;
	} else if (trailerExpression.test(field)) {
	state.sentTrailer = true;
	}
	}


	OutgoingMessage.prototype.setHeader = function(name, value) {
	if (typeof name !== 'string')
	throw new TypeError('`name` should be a string in setHeader(name, value).');
	if (value === undefined)
	throw new Error('`value` required in setHeader("' + name + '", value).');
	if (this._header)
	throw new Error('Can\'t set headers after they are sent.');

	if (this._headers === null)
	this._headers = {};

	var key = name.toLowerCase();
	this._headers[key] = value;
	this._headerNames[key] = name;

	if (automaticHeaders[key])
	this._removedHeader[key] = false;
	};


	OutgoingMessage.prototype.getHeader = function(name) {
	if (arguments.length < 1) {
	throw new Error('`name` is required for getHeader(name).');
	}

	if (!this._headers) return;

	var key = name.toLowerCase();
	return this._headers[key];
	};


	OutgoingMessage.prototype.removeHeader = function(name) {
	if (arguments.length < 1) {
	throw new Error('`name` is required for removeHeader(name).');
	}

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

	var key = name.toLowerCase();

	if (key === 'date')
	this.sendDate = false;
	else if (automaticHeaders[key])
	this._removedHeader[key] = true;

	if (this._headers) {
	delete this._headers[key];
	delete this._headerNames[key];
	}
	};


	OutgoingMessage.prototype._renderHeaders = function() {
	if (this._header) {
	throw new Error('Can\'t render headers after they are sent to the client.');
	}

	var headersMap = this._headers;
	if (!headersMap) return {};

	var headers = {};
	var keys = Object.keys(headersMap);
	var headerNames = this._headerNames;

	for (var i = 0, l = keys.length; i < l; i++) {
	var key = keys[i];
	headers[headerNames[key]] = headersMap[key];
	}
	return headers;
	};


	Object.defineProperty(OutgoingMessage.prototype, 'headersSent', {
	configurable: true,
	enumerable: true,
	get: function() { return !!this._header; }
	});


	OutgoingMessage.prototype.write = function(chunk, encoding, callback) {
	if (this.finished) {
	var err = new Error('write after end');
	process.nextTick(writeAfterEndNT, this, err, callback);

	return true;
	}

	if (!this._header) {
	this._implicitHeader();
	}

	if (!this._hasBody) {
	debug('This type of response MUST NOT have a body. ' +
	'Ignoring write() calls.');
	return true;
	}

	if (typeof chunk !== 'string' && !(chunk instanceof Buffer)) {
	throw new TypeError('first argument must be a string or Buffer');
	}


	// If we get an empty string or buffer, then just do nothing, and
	// signal the user to keep writing.
	if (chunk.length === 0) return true;

	var len, ret;
	if (this.chunkedEncoding) {
	if (typeof chunk === 'string' &&
	encoding !== 'hex' &&
	encoding !== 'base64' &&
	encoding !== 'binary') {
	len = Buffer.byteLength(chunk, encoding);
	chunk = len.toString(16) + CRLF + chunk + CRLF;
	ret = this._send(chunk, encoding, callback);
	} else {
	// buffer, or a non-toString-friendly encoding
	if (typeof chunk === 'string')
	len = Buffer.byteLength(chunk, encoding);
	else
	len = chunk.length;

	if (this.connection && !this.connection.corked) {
	this.connection.cork();
	process.nextTick(connectionCorkNT, this.connection);
	}
	this._send(len.toString(16), 'binary', null);
	this._send(crlf_buf, null, null);
	this._send(chunk, encoding, null);
	ret = this._send(crlf_buf, null, callback);
	}
	} else {
	ret = this._send(chunk, encoding, callback);
	}

	debug('write ret = ' + ret);
	return ret;
	};


	function writeAfterEndNT(self, err, callback) {
	self.emit('error', err);
	if (callback) callback(err);
	}


	function connectionCorkNT(conn) {
	if (conn)
	conn.uncork();
	}


	OutgoingMessage.prototype.addTrailers = function(headers) {
	this._trailer = '';
	var keys = Object.keys(headers);
	var isArray = Array.isArray(headers);
	var field, value;
	for (var i = 0, l = keys.length; i < l; i++) {
	var key = keys[i];
	if (isArray) {
	field = headers[key][0];
	value = headers[key][1];
	} else {
	field = key;
	value = headers[key];
	}

	this._trailer += field + ': ' + value + CRLF;
	}
	};


	const crlf_buf = new Buffer('\r\n');


	OutgoingMessage.prototype.end = function(data, encoding, callback) {
	if (typeof data === 'function') {
	callback = data;
	data = null;
	} else if (typeof encoding === 'function') {
	callback = encoding;
	encoding = null;
	}

	if (data && typeof data !== 'string' && !(data instanceof Buffer)) {
	throw new TypeError('first argument must be a string or Buffer');
	}

	if (this.finished) {
	return false;
	}

	var self = this;
	function finish() {
	self.emit('finish');
	}

	if (typeof callback === 'function')
	this.once('finish', callback);

	if (!this._header) {
	if (data) {
	if (typeof data === 'string')
	this._contentLength = Buffer.byteLength(data, encoding);
	else
	this._contentLength = data.length;
	} else {
	this._contentLength = 0;
	}
	this._implicitHeader();
	}

	if (data && !this._hasBody) {
	debug('This type of response MUST NOT have a body. ' +
	'Ignoring data passed to end().');
	data = null;
	}

	if (this.connection && data)
	this.connection.cork();

	var ret;
	if (data) {
	// Normal body write.
	ret = this.write(data, encoding);
	}

	if (this._hasBody && this.chunkedEncoding) {
	ret = this._send('0\r\n' + this._trailer + '\r\n', 'binary', finish);
	} else {
	// Force a flush, HACK.
	ret = this._send('', 'binary', finish);
	}

	if (this.connection && data)
	this.connection.uncork();

	this.finished = true;

	// There is the first message on the outgoing queue, and we've sent
	// everything to the socket.
	debug('outgoing message end.');
	if (this.output.length === 0 && this.connection._httpMessage === this) {
	this._finish();
	}

	return ret;
	};


	OutgoingMessage.prototype._finish = function() {
	assert(this.connection);
	this.emit('prefinish');
	};


	// This logic is probably a bit confusing. Let me explain a bit:
	//
	// In both HTTP servers and clients it is possible to queue up several
	// outgoing messages. This is easiest to imagine in the case of a client.
	// Take the following situation:
	//
	// req1 = client.request('GET', '/');
	// req2 = client.request('POST', '/');
	//
	// When the user does
	//
	// req2.write('hello world\n');
	//
	// it's possible that the first request has not been completely flushed to
	// the socket yet. Thus the outgoing messages need to be prepared to queue
	// up data internally before sending it on further to the socket's queue.
	//
	// This function, outgoingFlush(), is called by both the Server and Client
	// to attempt to flush any pending messages out to the socket.
	OutgoingMessage.prototype._flush = function() {
	var socket = this.socket;
	var outputLength, ret;

	if (socket && socket.writable) {
	// There might be remaining data in this.output; write it out
	outputLength = this.output.length;
	if (outputLength > 0) {
	var output = this.output;
	var outputEncodings = this.outputEncodings;
	var outputCallbacks = this.outputCallbacks;
	for (var i = 0; i < outputLength; i++) {
	ret = socket.write(output[i], outputEncodings[i],
	outputCallbacks[i]);
	}

	this.output = [];
	this.outputEncodings = [];
	this.outputCallbacks = [];
	}

	if (this.finished) {
	// This is a queue to the server or client to bring in the next this.
	this._finish();
	} else if (ret) {
	// This is necessary to prevent https from breaking
	this.emit('drain');
	}
	}
	};


	OutgoingMessage.prototype.flushHeaders = function() {
	if (!this._header) {
	this._implicitHeader();
	}

	// Force-flush the headers.
	this._send('');
	};

	OutgoingMessage.prototype.flush = util.deprecate(function() {
	this.flushHeaders();
	}, 'flush is deprecated. Use flushHeaders instead.');