mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
633 lines
17 KiB
633 lines
17 KiB
var sys = require('sys');
|
|
var events = require('events');
|
|
|
|
var CRLF = "\r\n";
|
|
var STATUS_CODES = exports.STATUS_CODES = {
|
|
100 : 'Continue',
|
|
101 : 'Switching Protocols',
|
|
200 : 'OK',
|
|
201 : 'Created',
|
|
202 : 'Accepted',
|
|
203 : 'Non-Authoritative Information',
|
|
204 : 'No Content',
|
|
205 : 'Reset Content',
|
|
206 : 'Partial Content',
|
|
300 : 'Multiple Choices',
|
|
301 : 'Moved Permanently',
|
|
302 : 'Moved Temporarily',
|
|
303 : 'See Other',
|
|
304 : 'Not Modified',
|
|
305 : 'Use Proxy',
|
|
400 : 'Bad Request',
|
|
401 : 'Unauthorized',
|
|
402 : 'Payment Required',
|
|
403 : 'Forbidden',
|
|
404 : 'Not Found',
|
|
405 : 'Method Not Allowed',
|
|
406 : 'Not Acceptable',
|
|
407 : 'Proxy Authentication Required',
|
|
408 : 'Request Time-out',
|
|
409 : 'Conflict',
|
|
410 : 'Gone',
|
|
411 : 'Length Required',
|
|
412 : 'Precondition Failed',
|
|
413 : 'Request Entity Too Large',
|
|
414 : 'Request-URI Too Large',
|
|
415 : 'Unsupported Media Type',
|
|
500 : 'Internal Server Error',
|
|
501 : 'Not Implemented',
|
|
502 : 'Bad Gateway',
|
|
503 : 'Service Unavailable',
|
|
504 : 'Gateway Time-out',
|
|
505 : 'HTTP Version not supported'
|
|
};
|
|
|
|
var connection_expression = /Connection/i;
|
|
var transfer_encoding_expression = /Transfer-Encoding/i;
|
|
var close_expression = /close/i;
|
|
var chunk_expression = /chunk/i;
|
|
var content_length_expression = /Content-Length/i;
|
|
|
|
|
|
/* Abstract base class for ServerRequest and ClientResponse. */
|
|
function IncomingMessage (connection) {
|
|
events.EventEmitter.call(this);
|
|
|
|
this.connection = connection;
|
|
this.httpVersion = null;
|
|
this.headers = {};
|
|
|
|
// request (server) only
|
|
this.url = "";
|
|
|
|
this.method = null;
|
|
|
|
// response (client) only
|
|
this.statusCode = null;
|
|
this.client = this.connection;
|
|
}
|
|
sys.inherits(IncomingMessage, events.EventEmitter);
|
|
exports.IncomingMessage = IncomingMessage;
|
|
|
|
IncomingMessage.prototype._parseQueryString = function () {
|
|
throw new Error("_parseQueryString is deprecated. Use require(\"querystring\") to parse query strings.\n");
|
|
};
|
|
|
|
IncomingMessage.prototype.setBodyEncoding = function (enc) {
|
|
// TODO: Find a cleaner way of doing this.
|
|
this.connection.setEncoding(enc);
|
|
};
|
|
|
|
IncomingMessage.prototype.pause = function () {
|
|
this.connection.pause();
|
|
};
|
|
|
|
IncomingMessage.prototype.resume = function () {
|
|
this.connection.resume();
|
|
};
|
|
|
|
IncomingMessage.prototype._addHeaderLine = function (field, value) {
|
|
if (field in this.headers) {
|
|
// TODO Certain headers like 'Content-Type' should not be concatinated.
|
|
// See https://www.google.com/reader/view/?tab=my#overview-page
|
|
this.headers[field] += ", " + value;
|
|
} else {
|
|
this.headers[field] = value;
|
|
}
|
|
};
|
|
|
|
function OutgoingMessage () {
|
|
events.EventEmitter.call(this);
|
|
|
|
this.output = [];
|
|
this.outputEncodings = [];
|
|
|
|
this.closeOnFinish = false;
|
|
this.chunked_encoding = false;
|
|
this.should_keep_alive = true;
|
|
this.use_chunked_encoding_by_default = true;
|
|
|
|
this.flushing = false;
|
|
|
|
this.finished = false;
|
|
}
|
|
sys.inherits(OutgoingMessage, events.EventEmitter);
|
|
exports.OutgoingMessage = OutgoingMessage;
|
|
|
|
OutgoingMessage.prototype._send = function (data, encoding) {
|
|
var length = this.output.length;
|
|
|
|
if (length === 0) {
|
|
this.output.push(data);
|
|
encoding = encoding || "ascii";
|
|
this.outputEncodings.push(encoding);
|
|
return;
|
|
}
|
|
|
|
var lastEncoding = this.outputEncodings[length-1];
|
|
var lastData = this.output[length-1];
|
|
|
|
if ((lastEncoding === encoding) ||
|
|
(!encoding && data.constructor === lastData.constructor)) {
|
|
if (lastData.constructor === String) {
|
|
this.output[length-1] = lastData + data;
|
|
} else {
|
|
this.output[length-1] = lastData.concat(data);
|
|
}
|
|
return;
|
|
}
|
|
|
|
this.output.push(data);
|
|
encoding = encoding || "ascii";
|
|
this.outputEncodings.push(encoding);
|
|
};
|
|
|
|
OutgoingMessage.prototype.sendHeaderLines = function (first_line, headers) {
|
|
var sent_connection_header = false;
|
|
var sent_content_length_header = false;
|
|
var sent_transfer_encoding_header = false;
|
|
|
|
// first_line 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 message_header = first_line;
|
|
var field, value;
|
|
for (var i in headers) {
|
|
if (headers[i] instanceof Array) {
|
|
field = headers[i][0];
|
|
value = headers[i][1];
|
|
} else {
|
|
if (!headers.hasOwnProperty(i)) continue;
|
|
field = i;
|
|
value = headers[i];
|
|
}
|
|
|
|
message_header += field + ": " + value + CRLF;
|
|
|
|
if (connection_expression.test(field)) {
|
|
sent_connection_header = true;
|
|
if (close_expression.test(value)) this.closeOnFinish = true;
|
|
|
|
} else if (transfer_encoding_expression.test(field)) {
|
|
sent_transfer_encoding_header = true;
|
|
if (chunk_expression.test(value)) this.chunked_encoding = true;
|
|
|
|
} else if (content_length_expression.test(field)) {
|
|
sent_content_length_header = true;
|
|
|
|
}
|
|
}
|
|
|
|
// keep-alive logic
|
|
if (sent_connection_header == false) {
|
|
if (this.should_keep_alive &&
|
|
(sent_content_length_header || this.use_chunked_encoding_by_default)) {
|
|
message_header += "Connection: keep-alive\r\n";
|
|
} else {
|
|
this.closeOnFinish = true;
|
|
message_header += "Connection: close\r\n";
|
|
}
|
|
}
|
|
|
|
if (sent_content_length_header == false && sent_transfer_encoding_header == false) {
|
|
if (this.use_chunked_encoding_by_default) {
|
|
message_header += "Transfer-Encoding: chunked\r\n";
|
|
this.chunked_encoding = true;
|
|
}
|
|
else {
|
|
this.closeOnFinish = true;
|
|
}
|
|
}
|
|
|
|
message_header += CRLF;
|
|
|
|
this._send(message_header);
|
|
// wait until the first body chunk, or close(), is sent to flush.
|
|
};
|
|
|
|
|
|
OutgoingMessage.prototype.sendBody = function () {
|
|
throw new Error("sendBody() has been renamed to write(). " +
|
|
"The 'body' event has been renamed to 'data' and " +
|
|
"the 'complete' event has been renamed to 'end'.");
|
|
};
|
|
|
|
|
|
OutgoingMessage.prototype.write = function (chunk, encoding) {
|
|
encoding = encoding || "ascii";
|
|
if (this.chunked_encoding) {
|
|
this._send(process._byteLength(chunk, encoding).toString(16));
|
|
this._send(CRLF);
|
|
this._send(chunk, encoding);
|
|
this._send(CRLF);
|
|
} else {
|
|
this._send(chunk, encoding);
|
|
}
|
|
|
|
if (this.flushing) {
|
|
this.flush();
|
|
} else {
|
|
this.flushing = true;
|
|
}
|
|
};
|
|
|
|
OutgoingMessage.prototype.flush = function () {
|
|
this.emit("flush");
|
|
};
|
|
|
|
OutgoingMessage.prototype.finish = function () {
|
|
throw new Error("finish() has been renamed to close().");
|
|
};
|
|
|
|
OutgoingMessage.prototype.close = function () {
|
|
if (this.chunked_encoding) this._send("0\r\n\r\n"); // last chunk
|
|
this.finished = true;
|
|
this.flush();
|
|
};
|
|
|
|
|
|
function ServerResponse (req) {
|
|
OutgoingMessage.call(this);
|
|
|
|
if (req.httpVersionMajor < 1 || req.httpVersionMinor < 1) {
|
|
this.use_chunked_encoding_by_default = false;
|
|
this.should_keep_alive = false;
|
|
}
|
|
}
|
|
sys.inherits(ServerResponse, OutgoingMessage);
|
|
exports.ServerResponse = ServerResponse;
|
|
|
|
|
|
ServerResponse.prototype.writeHeader = function (statusCode) {
|
|
var reasonPhrase, headers, headerIndex;
|
|
|
|
if (typeof arguments[1] == 'string') {
|
|
reasonPhrase = arguments[1];
|
|
headerIndex = 2;
|
|
} else {
|
|
reasonPhrase = STATUS_CODES[statusCode] || "unknown";
|
|
headerIndex = 1;
|
|
}
|
|
|
|
if (typeof arguments[headerIndex] == 'object') {
|
|
headers = arguments[headerIndex];
|
|
} else {
|
|
headers = {};
|
|
}
|
|
|
|
var status_line = "HTTP/1.1 " + statusCode.toString() + " "
|
|
+ reasonPhrase + CRLF;
|
|
this.sendHeaderLines(status_line, headers);
|
|
};
|
|
|
|
// TODO eventually remove sendHeader()
|
|
ServerResponse.prototype.sendHeader = ServerResponse.prototype.writeHeader;
|
|
|
|
function ClientRequest (method, url, headers) {
|
|
OutgoingMessage.call(this);
|
|
|
|
this.should_keep_alive = false;
|
|
if (method === "GET" || method === "HEAD") {
|
|
this.use_chunked_encoding_by_default = false;
|
|
} else {
|
|
this.use_chunked_encoding_by_default = true;
|
|
}
|
|
this.closeOnFinish = true;
|
|
|
|
this.sendHeaderLines(method + " " + url + " HTTP/1.1\r\n", headers);
|
|
}
|
|
sys.inherits(ClientRequest, OutgoingMessage);
|
|
exports.ClientRequest = ClientRequest;
|
|
|
|
ClientRequest.prototype.finish = function () {
|
|
throw new Error( "finish() has been renamed to close() and no longer takes "
|
|
+ "a response handler as an argument. Manually add a 'response' listener "
|
|
+ "to the request object."
|
|
);
|
|
};
|
|
|
|
ClientRequest.prototype.close = function () {
|
|
if (arguments.length > 0) {
|
|
throw new Error( "ClientRequest.prototype.close does not take any arguments. "
|
|
+ "Add a response listener manually to the request object."
|
|
);
|
|
}
|
|
OutgoingMessage.prototype.close.call(this);
|
|
};
|
|
|
|
|
|
function createIncomingMessageStream (connection, incoming_listener) {
|
|
var stream = new events.EventEmitter();
|
|
|
|
stream.addListener("incoming", incoming_listener);
|
|
|
|
var incoming, field, value;
|
|
|
|
connection.addListener("messageBegin", function () {
|
|
incoming = new IncomingMessage(connection);
|
|
field = null;
|
|
value = null;
|
|
});
|
|
|
|
// Only servers will get URL events.
|
|
connection.addListener("url", function (data) {
|
|
incoming.url += data;
|
|
});
|
|
|
|
connection.addListener("headerField", function (data) {
|
|
if (value) {
|
|
incoming._addHeaderLine(field, value);
|
|
field = null;
|
|
value = null;
|
|
}
|
|
if (field) {
|
|
field += data;
|
|
} else {
|
|
field = data;
|
|
}
|
|
});
|
|
|
|
connection.addListener("headerValue", function (data) {
|
|
if (value) {
|
|
value += data;
|
|
} else {
|
|
value = data;
|
|
}
|
|
});
|
|
|
|
connection.addListener("headerComplete", function (info) {
|
|
if (field && value) {
|
|
incoming._addHeaderLine(field, value);
|
|
}
|
|
|
|
incoming.httpVersion = info.httpVersion;
|
|
incoming.httpVersionMajor = info.versionMajor;
|
|
incoming.httpVersionMinor = info.versionMinor;
|
|
|
|
if (info.method) {
|
|
// server only
|
|
incoming.method = info.method;
|
|
} else {
|
|
// client only
|
|
incoming.statusCode = info.statusCode;
|
|
}
|
|
|
|
stream.emit("incoming", incoming, info.should_keep_alive);
|
|
});
|
|
|
|
connection.addListener("body", function (chunk) {
|
|
incoming.emit('data', chunk);
|
|
});
|
|
|
|
connection.addListener("messageComplete", function () {
|
|
incoming.emit('end');
|
|
});
|
|
|
|
return stream;
|
|
}
|
|
|
|
/* Returns true if the message queue is finished and the connection
|
|
* should be closed. */
|
|
function flushMessageQueue (connection, queue) {
|
|
while (queue[0]) {
|
|
var message = queue[0];
|
|
|
|
while (message.output.length > 0) {
|
|
if (connection.readyState !== "open" && connection.readyState !== "writeOnly") {
|
|
return true;
|
|
}
|
|
|
|
var data = message.output.shift();
|
|
var encoding = message.outputEncodings.shift();
|
|
|
|
connection.write(data, encoding);
|
|
}
|
|
|
|
if (!message.finished) break;
|
|
|
|
message.emit("sent");
|
|
queue.shift();
|
|
|
|
if (message.closeOnFinish) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
exports.createServer = function (requestListener, options) {
|
|
var server = new process.http.Server();
|
|
//server.setOptions(options);
|
|
server.addListener("request", requestListener);
|
|
server.addListener("connection", connectionListener);
|
|
return server;
|
|
};
|
|
|
|
function connectionListener (connection) {
|
|
// An array of responses for each connection. In pipelined connections
|
|
// we need to keep track of the order they were sent.
|
|
var responses = [];
|
|
|
|
connection.resetParser();
|
|
|
|
// is this really needed?
|
|
connection.addListener("end", function () {
|
|
if (responses.length == 0) {
|
|
connection.close();
|
|
} else {
|
|
responses[responses.length-1].closeOnFinish = true;
|
|
}
|
|
});
|
|
|
|
|
|
createIncomingMessageStream(connection, function (incoming, should_keep_alive) {
|
|
var req = incoming;
|
|
|
|
var res = new ServerResponse(req);
|
|
res.should_keep_alive = should_keep_alive;
|
|
res.addListener("flush", function () {
|
|
if (flushMessageQueue(connection, responses)) {
|
|
connection.close();
|
|
}
|
|
});
|
|
responses.push(res);
|
|
|
|
connection.server.emit("request", req, res);
|
|
});
|
|
}
|
|
|
|
|
|
exports.createClient = function (port, host) {
|
|
var client = new process.http.Client();
|
|
var secure_credentials={ secure : false };
|
|
|
|
var requests = [];
|
|
var currentRequest;
|
|
|
|
client._pushRequest = function (req) {
|
|
req.addListener("flush", function () {
|
|
if (client.readyState == "closed") {
|
|
//sys.debug("HTTP CLIENT request flush. reconnect. readyState = " + client.readyState);
|
|
client.connect(port, host); // reconnect
|
|
if (secure_credentials.secure) {
|
|
client.tcpSetSecure(secure_credentials.format_type,
|
|
secure_credentials.ca_certs,
|
|
secure_credentials.crl_list,
|
|
secure_credentials.private_key,
|
|
secure_credentials.certificate);
|
|
}
|
|
return;
|
|
}
|
|
//sys.debug("client flush readyState = " + client.readyState);
|
|
if (req == currentRequest) flushMessageQueue(client, [req]);
|
|
});
|
|
requests.push(req);
|
|
};
|
|
|
|
client.tcpSetSecure = client.setSecure;
|
|
client.setSecure = function(format_type, ca_certs, crl_list, private_key, certificate) {
|
|
secure_credentials.secure = true;
|
|
secure_credentials.format_type = format_type;
|
|
secure_credentials.ca_certs = ca_certs;
|
|
secure_credentials.crl_list = crl_list;
|
|
secure_credentials.private_key = private_key;
|
|
secure_credentials.certificate = certificate;
|
|
}
|
|
|
|
client.addListener("connect", function () {
|
|
client.resetParser();
|
|
currentRequest = requests.shift();
|
|
currentRequest.flush();
|
|
});
|
|
|
|
client.addListener("end", function () {
|
|
//sys.debug("client got end closing. readyState = " + client.readyState);
|
|
client.close();
|
|
});
|
|
|
|
client.addListener("close", function (had_error) {
|
|
if (had_error) {
|
|
client.emit("error");
|
|
return;
|
|
}
|
|
|
|
//sys.debug("HTTP CLIENT onClose. readyState = " + client.readyState);
|
|
|
|
// If there are more requests to handle, reconnect.
|
|
if (requests.length > 0 && client.readyState != "opening") {
|
|
//sys.debug("HTTP CLIENT: reconnecting readyState = " + client.readyState);
|
|
client.connect(port, host); // reconnect
|
|
if (secure_credentials.secure) {
|
|
client.tcpSetSecure(secure_credentials.format_type,
|
|
secure_credentials.ca_certs,
|
|
secure_credentials.crl_list,
|
|
secure_credentials.private_key,
|
|
secure_credentials.certificate);
|
|
}
|
|
}
|
|
});
|
|
|
|
createIncomingMessageStream(client, function (res) {
|
|
//sys.debug("incoming response!");
|
|
|
|
res.addListener('end', function ( ) {
|
|
//sys.debug("request complete disconnecting. readyState = " + client.readyState);
|
|
client.close();
|
|
});
|
|
|
|
currentRequest.emit("response", res);
|
|
});
|
|
|
|
return client;
|
|
};
|
|
|
|
process.http.Client.prototype.get = function () {
|
|
throw new Error("client.get(...) is now client.request('GET', ...)");
|
|
};
|
|
|
|
process.http.Client.prototype.head = function () {
|
|
throw new Error("client.head(...) is now client.request('HEAD', ...)");
|
|
};
|
|
|
|
process.http.Client.prototype.post = function () {
|
|
throw new Error("client.post(...) is now client.request('POST', ...)");
|
|
};
|
|
|
|
process.http.Client.prototype.del = function () {
|
|
throw new Error("client.del(...) is now client.request('DELETE', ...)");
|
|
};
|
|
|
|
process.http.Client.prototype.put = function () {
|
|
throw new Error("client.put(...) is now client.request('PUT', ...)");
|
|
};
|
|
|
|
process.http.Client.prototype.request = function (method, url, headers) {
|
|
if (typeof(url) != "string") { // assume method was omitted, shift arguments
|
|
headers = url;
|
|
url = method;
|
|
method = null;
|
|
}
|
|
var req = new ClientRequest(method || "GET", url, headers);
|
|
this._pushRequest(req);
|
|
return req;
|
|
};
|
|
|
|
|
|
exports.cat = function (url, encoding_, headers_) {
|
|
var encoding = 'utf8',
|
|
headers = {},
|
|
callback = null;
|
|
|
|
// parse the arguments for the various options... very ugly
|
|
if (typeof(arguments[1]) == 'string') {
|
|
encoding = arguments[1];
|
|
if (typeof(arguments[2]) == 'object') {
|
|
headers = arguments[2];
|
|
if (typeof(arguments[3]) == 'function') callback = arguments[3];
|
|
} else {
|
|
if (typeof(arguments[2]) == 'function') callback = arguments[2];
|
|
}
|
|
} else {
|
|
// didn't specify encoding
|
|
if (typeof(arguments[1]) == 'object') {
|
|
headers = arguments[1];
|
|
callback = arguments[2];
|
|
} else {
|
|
callback = arguments[1];
|
|
}
|
|
}
|
|
|
|
var url = require("url").parse(url);
|
|
|
|
var hasHost = false;
|
|
for (var i in headers) {
|
|
if (i.toLowerCase() === "host") {
|
|
hasHost = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasHost) headers["Host"] = url.hostname;
|
|
|
|
var content = "";
|
|
|
|
var client = exports.createClient(url.port || 80, url.hostname);
|
|
var req = client.request((url.pathname || "/")+(url.search || "")+(url.hash || ""), headers);
|
|
|
|
req.addListener('response', function (res) {
|
|
if (res.statusCode < 200 || res.statusCode >= 300) {
|
|
if (callback) callback(res.statusCode);
|
|
client.close();
|
|
return;
|
|
}
|
|
res.setBodyEncoding(encoding);
|
|
res.addListener('data', function (chunk) { content += chunk; });
|
|
res.addListener('end', function () {
|
|
if (callback) callback(null, content);
|
|
});
|
|
});
|
|
|
|
client.addListener("error", function (err) {
|
|
// todo an error should actually be passed here...
|
|
if (callback) callback(new Error('Connection error'));
|
|
});
|
|
|
|
req.close();
|
|
};
|
|
|