mirror of https://github.com/lukechilds/node.git
Timothy J Fontaine
12 years ago
committed by
Ben Noordhuis
Ben Noordhuis
4 changed files with 666 additions and 614 deletions
@ -0,0 +1,646 @@ |
|||
// Copyright Joyent, Inc. and other Node contributors.
|
|||
//
|
|||
// Permission is hereby granted, free of charge, to any person obtaining a
|
|||
// copy of this software and associated documentation files (the
|
|||
// "Software"), to deal in the Software without restriction, including
|
|||
// without limitation the rights to use, copy, modify, merge, publish,
|
|||
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|||
// persons to whom the Software is furnished to do so, subject to the
|
|||
// following conditions:
|
|||
//
|
|||
// The above copyright notice and this permission notice shall be included
|
|||
// in all copies or substantial portions of the Software.
|
|||
//
|
|||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|||
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|||
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|||
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|||
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|||
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|||
|
|||
var assert = require('assert').ok; |
|||
var Stream = require('stream'); |
|||
var util = require('util'); |
|||
|
|||
var common = require('_http_common'); |
|||
|
|||
var CRLF = common.CRLF; |
|||
var chunkExpression = common.chunkExpression; |
|||
var continueExpression = common.continueExpression; |
|||
var debug = common.debug; |
|||
|
|||
|
|||
var connectionExpression = /Connection/i; |
|||
var transferEncodingExpression = /Transfer-Encoding/i; |
|||
var closeExpression = /close/i; |
|||
var contentLengthExpression = /Content-Length/i; |
|||
var dateExpression = /Date/i; |
|||
var expectExpression = /Expect/i; |
|||
|
|||
|
|||
var dateCache; |
|||
function utcDate() { |
|||
if (!dateCache) { |
|||
var d = new Date(); |
|||
dateCache = d.toUTCString(); |
|||
setTimeout(function() { |
|||
dateCache = undefined; |
|||
}, 1000 - d.getMilliseconds()); |
|||
} |
|||
return dateCache; |
|||
} |
|||
|
|||
|
|||
function OutgoingMessage() { |
|||
Stream.call(this); |
|||
|
|||
this.output = []; |
|||
this.outputEncodings = []; |
|||
|
|||
this.writable = true; |
|||
|
|||
this._last = false; |
|||
this.chunkedEncoding = false; |
|||
this.shouldKeepAlive = true; |
|||
this.useChunkedEncodingByDefault = true; |
|||
this.sendDate = false; |
|||
|
|||
this._hasBody = true; |
|||
this._trailer = ''; |
|||
|
|||
this.finished = false; |
|||
this._hangupClose = false; |
|||
|
|||
this.socket = null; |
|||
this.connection = null; |
|||
} |
|||
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); |
|||
}; |
|||
|
|||
|
|||
OutgoingMessage.prototype.destroy = function(error) { |
|||
this.socket.destroy(error); |
|||
}; |
|||
|
|||
|
|||
// This abstract either writing directly to the socket or buffering it.
|
|||
OutgoingMessage.prototype._send = function(data, encoding) { |
|||
// 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') { |
|||
data = this._header + data; |
|||
} else { |
|||
this.output.unshift(this._header); |
|||
this.outputEncodings.unshift('ascii'); |
|||
} |
|||
this._headerSent = true; |
|||
} |
|||
return this._writeRaw(data, encoding); |
|||
}; |
|||
|
|||
|
|||
OutgoingMessage.prototype._writeRaw = function(data, encoding) { |
|||
if (data.length === 0) { |
|||
return true; |
|||
} |
|||
|
|||
if (this.connection && |
|||
this.connection._httpMessage === this && |
|||
this.connection.writable && |
|||
!this.connection.destroyed) { |
|||
// There might be pending data in the this.output buffer.
|
|||
while (this.output.length) { |
|||
if (!this.connection.writable) { |
|||
this._buffer(data, encoding); |
|||
return false; |
|||
} |
|||
var c = this.output.shift(); |
|||
var e = this.outputEncodings.shift(); |
|||
this.connection.write(c, e); |
|||
} |
|||
|
|||
// Directly write to socket.
|
|||
return this.connection.write(data, encoding); |
|||
} else if (this.connection && this.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.
|
|||
this._buffer(data, encoding); |
|||
return false; |
|||
} |
|||
}; |
|||
|
|||
|
|||
OutgoingMessage.prototype._buffer = function(data, encoding) { |
|||
if (data.length === 0) return; |
|||
|
|||
var length = this.output.length; |
|||
|
|||
if (length === 0 || typeof data != 'string') { |
|||
this.output.push(data); |
|||
this.outputEncodings.push(encoding); |
|||
return false; |
|||
} |
|||
|
|||
var lastEncoding = this.outputEncodings[length - 1]; |
|||
var lastData = this.output[length - 1]; |
|||
|
|||
if ((encoding && lastEncoding === encoding) || |
|||
(!encoding && data.constructor === lastData.constructor)) { |
|||
this.output[length - 1] = lastData + data; |
|||
return false; |
|||
} |
|||
|
|||
this.output.push(data); |
|||
this.outputEncodings.push(encoding); |
|||
|
|||
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, |
|||
messageHeader: firstLine |
|||
}; |
|||
|
|||
var field, value; |
|||
var self = this; |
|||
|
|||
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 (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) { |
|||
if (this.useChunkedEncodingByDefault) { |
|||
state.messageHeader += 'Transfer-Encoding: chunked\r\n'; |
|||
this.chunkedEncoding = true; |
|||
} else { |
|||
this._last = true; |
|||
} |
|||
} else { |
|||
// Make sure we don't end the 0\r\n\r\n at the end of the message.
|
|||
this.chunkedEncoding = false; |
|||
} |
|||
} |
|||
|
|||
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; |
|||
} |
|||
} |
|||
|
|||
|
|||
OutgoingMessage.prototype.setHeader = function(name, value) { |
|||
if (arguments.length < 2) { |
|||
throw new Error('`name` and `value` are required for setHeader().'); |
|||
} |
|||
|
|||
if (this._header) { |
|||
throw new Error('Can\'t set headers after they are sent.'); |
|||
} |
|||
|
|||
var key = name.toLowerCase(); |
|||
this._headers = this._headers || {}; |
|||
this._headerNames = this._headerNames || {}; |
|||
this._headers[key] = value; |
|||
this._headerNames[key] = name; |
|||
}; |
|||
|
|||
|
|||
OutgoingMessage.prototype.getHeader = function(name) { |
|||
if (arguments.length < 1) { |
|||
throw new Error('`name` is required for getHeader().'); |
|||
} |
|||
|
|||
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().'); |
|||
} |
|||
|
|||
if (this._header) { |
|||
throw new Error('Can\'t remove headers after they are sent.'); |
|||
} |
|||
|
|||
if (!this._headers) return; |
|||
|
|||
var key = name.toLowerCase(); |
|||
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.'); |
|||
} |
|||
|
|||
if (!this._headers) return {}; |
|||
|
|||
var headers = {}; |
|||
var keys = Object.keys(this._headers); |
|||
for (var i = 0, l = keys.length; i < l; i++) { |
|||
var key = keys[i]; |
|||
headers[this._headerNames[key]] = this._headers[key]; |
|||
} |
|||
return headers; |
|||
}; |
|||
|
|||
|
|||
Object.defineProperty(OutgoingMessage.prototype, 'headersSent', { |
|||
configurable: true, |
|||
enumerable: true, |
|||
get: function() { return !!this._header; } |
|||
}); |
|||
|
|||
|
|||
OutgoingMessage.prototype.write = function(chunk, encoding) { |
|||
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' && !Buffer.isBuffer(chunk)) { |
|||
throw new TypeError('first argument must be a string or Buffer'); |
|||
} |
|||
|
|||
if (chunk.length === 0) return false; |
|||
|
|||
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); |
|||
} else { |
|||
// buffer, or a non-toString-friendly encoding
|
|||
len = chunk.length; |
|||
this._send(len.toString(16) + CRLF); |
|||
this._send(chunk, encoding); |
|||
ret = this._send(CRLF); |
|||
} |
|||
} else { |
|||
ret = this._send(chunk, encoding); |
|||
} |
|||
|
|||
debug('write ret = ' + ret); |
|||
return ret; |
|||
}; |
|||
|
|||
|
|||
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; |
|||
} |
|||
}; |
|||
|
|||
|
|||
var zero_chunk_buf = new Buffer('\r\n0\r\n'); |
|||
var crlf_buf = new Buffer('\r\n'); |
|||
|
|||
|
|||
OutgoingMessage.prototype.end = function(data, encoding) { |
|||
if (this.finished) { |
|||
return false; |
|||
} |
|||
if (!this._header) { |
|||
this._implicitHeader(); |
|||
} |
|||
|
|||
if (data && !this._hasBody) { |
|||
debug('This type of response MUST NOT have a body. ' + |
|||
'Ignoring data passed to end().'); |
|||
data = false; |
|||
} |
|||
|
|||
var ret; |
|||
|
|||
var hot = this._headerSent === false && |
|||
(data && data.length > 0) && |
|||
this.output.length === 0 && |
|||
this.connection && |
|||
this.connection.writable && |
|||
this.connection._httpMessage === this; |
|||
|
|||
// The benefits of the hot-path optimization below start to fall
|
|||
// off when the buffer size gets up near 128KB, because the cost
|
|||
// of the copy is more than the cost of the extra write() call.
|
|||
// Switch to the write/end method at that point. Heuristics and
|
|||
// magic numbers are awful, but slow http responses are worse.
|
|||
if (hot && Buffer.isBuffer(data) && data.length > 120 * 1024) |
|||
hot = false; |
|||
|
|||
if (hot) { |
|||
// Hot path. They're doing
|
|||
// res.writeHead();
|
|||
// res.end(blah);
|
|||
// HACKY.
|
|||
|
|||
if (typeof data === 'string') { |
|||
if (this.chunkedEncoding) { |
|||
var l = Buffer.byteLength(data, encoding).toString(16); |
|||
ret = this.connection.write(this._header + l + CRLF + |
|||
data + '\r\n0\r\n' + |
|||
this._trailer + '\r\n', encoding); |
|||
} else { |
|||
ret = this.connection.write(this._header + data, encoding); |
|||
} |
|||
} else if (Buffer.isBuffer(data)) { |
|||
if (this.chunkedEncoding) { |
|||
var chunk_size = data.length.toString(16); |
|||
|
|||
// Skip expensive Buffer.byteLength() calls; only ISO-8859-1 characters
|
|||
// are allowed in HTTP headers. Therefore:
|
|||
//
|
|||
// this._header.length == Buffer.byteLength(this._header.length)
|
|||
// this._trailer.length == Buffer.byteLength(this._trailer.length)
|
|||
//
|
|||
var header_len = this._header.length; |
|||
var chunk_size_len = chunk_size.length; |
|||
var data_len = data.length; |
|||
var trailer_len = this._trailer.length; |
|||
|
|||
var len = header_len + |
|||
chunk_size_len + |
|||
2 + // '\r\n'.length
|
|||
data_len + |
|||
5 + // '\r\n0\r\n'.length
|
|||
trailer_len + |
|||
2; // '\r\n'.length
|
|||
|
|||
var buf = new Buffer(len); |
|||
var off = 0; |
|||
|
|||
buf.write(this._header, off, header_len, 'ascii'); |
|||
off += header_len; |
|||
|
|||
buf.write(chunk_size, off, chunk_size_len, 'ascii'); |
|||
off += chunk_size_len; |
|||
|
|||
crlf_buf.copy(buf, off); |
|||
off += 2; |
|||
|
|||
data.copy(buf, off); |
|||
off += data_len; |
|||
|
|||
zero_chunk_buf.copy(buf, off); |
|||
off += 5; |
|||
|
|||
if (trailer_len > 0) { |
|||
buf.write(this._trailer, off, trailer_len, 'ascii'); |
|||
off += trailer_len; |
|||
} |
|||
|
|||
crlf_buf.copy(buf, off); |
|||
|
|||
ret = this.connection.write(buf); |
|||
} else { |
|||
var header_len = this._header.length; |
|||
var buf = new Buffer(header_len + data.length); |
|||
buf.write(this._header, 0, header_len, 'ascii'); |
|||
data.copy(buf, header_len); |
|||
ret = this.connection.write(buf); |
|||
} |
|||
} else { |
|||
throw new TypeError('first argument must be a string or Buffer'); |
|||
} |
|||
this._headerSent = true; |
|||
|
|||
} else if (data) { |
|||
// Normal body write.
|
|||
ret = this.write(data, encoding); |
|||
} |
|||
|
|||
if (!hot) { |
|||
if (this.chunkedEncoding) { |
|||
ret = this._send('0\r\n' + this._trailer + '\r\n'); // Last chunk.
|
|||
} else { |
|||
// Force a flush, HACK.
|
|||
ret = this._send(''); |
|||
} |
|||
} |
|||
|
|||
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; |
|||
}; |
|||
|
|||
|
|||
var ServerResponse, ClientRequest; |
|||
|
|||
OutgoingMessage.prototype._finish = function() { |
|||
assert(this.connection); |
|||
|
|||
if (!ServerResponse) |
|||
ServerResponse = require('http').ServerResponse; |
|||
|
|||
if (!ClientRequest) |
|||
ClientRequest = require('http').ClientRequest; |
|||
|
|||
if (this instanceof ServerResponse) { |
|||
DTRACE_HTTP_SERVER_RESPONSE(this.connection); |
|||
COUNTER_HTTP_SERVER_RESPONSE(); |
|||
} else { |
|||
assert(this instanceof ClientRequest); |
|||
DTRACE_HTTP_CLIENT_REQUEST(this, this.connection); |
|||
COUNTER_HTTP_CLIENT_REQUEST(); |
|||
} |
|||
this.emit('finish'); |
|||
}; |
|||
|
|||
|
|||
OutgoingMessage.prototype._flush = function() { |
|||
// 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.
|
|||
|
|||
if (!this.socket) return; |
|||
|
|||
var ret; |
|||
while (this.output.length) { |
|||
|
|||
if (!this.socket.writable) return; // XXX Necessary?
|
|||
|
|||
var data = this.output.shift(); |
|||
var encoding = this.outputEncodings.shift(); |
|||
|
|||
ret = this.socket.write(data, encoding); |
|||
} |
|||
|
|||
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'); |
|||
} |
|||
}; |
|||
Loading…
Reference in new issue