Source code
Revision control
Copy as Markdown
Other Tools
/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
* An implementation of an HTTP server both as a loadable script and as an XPCOM
* component. See the accompanying README file for user documentation on
* httpd.js.
*/
const CC = Components.Constructor;
const PR_UINT32_MAX = Math.pow(2, 32) - 1;
/** True if debugging output is enabled, false otherwise. */
var DEBUG = false; // non-const *only* so tweakable in server tests
/** True if debugging output should be timestamped. */
var DEBUG_TIMESTAMP = false; // non-const so tweakable in server tests
/**
* Sets the debugging status, intended for tweaking in server tests.
*
* @param {boolean} debug
* Enables debugging output
* @param {boolean} debugTimestamp
* Enables timestamping of the debugging output.
*/
export function setDebuggingStatus(debug, debugTimestamp) {
DEBUG = debug;
DEBUG_TIMESTAMP = debugTimestamp;
}
/**
* Asserts that the given condition holds. If it doesn't, the given message is
* dumped, a stack trace is printed, and an exception is thrown to attempt to
* stop execution (which unfortunately must rely upon the exception not being
* accidentally swallowed by the code that uses it).
*/
function NS_ASSERT(cond, msg) {
if (DEBUG && !cond) {
dumpn("###!!!");
dumpn("###!!! ASSERTION" + (msg ? ": " + msg : "!"));
dumpn("###!!! Stack follows:");
var stack = new Error().stack.split(/\n/);
dumpn(
stack
.map(function (val) {
return "###!!! " + val;
})
.join("\n")
);
throw Components.Exception("", Cr.NS_ERROR_ABORT);
}
}
/** Constructs an HTTP error object. */
export function HttpError(code, description) {
this.code = code;
this.description = description;
}
HttpError.prototype = {
toString() {
return this.code + " " + this.description;
},
};
/**
* Errors thrown to trigger specific HTTP server responses.
*/
export var HTTP_400 = new HttpError(400, "Bad Request");
export var HTTP_401 = new HttpError(401, "Unauthorized");
export var HTTP_402 = new HttpError(402, "Payment Required");
export var HTTP_403 = new HttpError(403, "Forbidden");
export var HTTP_404 = new HttpError(404, "Not Found");
export var HTTP_405 = new HttpError(405, "Method Not Allowed");
export var HTTP_406 = new HttpError(406, "Not Acceptable");
export var HTTP_407 = new HttpError(407, "Proxy Authentication Required");
export var HTTP_408 = new HttpError(408, "Request Timeout");
export var HTTP_409 = new HttpError(409, "Conflict");
export var HTTP_410 = new HttpError(410, "Gone");
export var HTTP_411 = new HttpError(411, "Length Required");
export var HTTP_412 = new HttpError(412, "Precondition Failed");
export var HTTP_413 = new HttpError(413, "Request Entity Too Large");
export var HTTP_414 = new HttpError(414, "Request-URI Too Long");
export var HTTP_415 = new HttpError(415, "Unsupported Media Type");
export var HTTP_417 = new HttpError(417, "Expectation Failed");
export var HTTP_500 = new HttpError(500, "Internal Server Error");
export var HTTP_501 = new HttpError(501, "Not Implemented");
export var HTTP_502 = new HttpError(502, "Bad Gateway");
export var HTTP_503 = new HttpError(503, "Service Unavailable");
export var HTTP_504 = new HttpError(504, "Gateway Timeout");
export var HTTP_505 = new HttpError(505, "HTTP Version Not Supported");
/** Creates a hash with fields corresponding to the values in arr. */
function array2obj(arr) {
var obj = {};
for (var i = 0; i < arr.length; i++) {
obj[arr[i]] = arr[i];
}
return obj;
}
/** Returns an array of the integers x through y, inclusive. */
function range(x, y) {
var arr = [];
for (var i = x; i <= y; i++) {
arr.push(i);
}
return arr;
}
/** An object (hash) whose fields are the numbers of all HTTP error codes. */
const HTTP_ERROR_CODES = array2obj(range(400, 417).concat(range(500, 505)));
/**
* The character used to distinguish hidden files from non-hidden files, a la
* the leading dot in Apache. Since that mechanism also hides files from
* easy display in LXR, ls output, etc. however, we choose instead to use a
* suffix character. If a requested file ends with it, we append another
* when getting the file on the server. If it doesn't, we just look up that
* file. Therefore, any file whose name ends with exactly one of the character
* is "hidden" and available for use by the server.
*/
const HIDDEN_CHAR = "^";
/**
* The file name suffix indicating the file containing overridden headers for
* a requested file.
*/
const HEADERS_SUFFIX = HIDDEN_CHAR + "headers" + HIDDEN_CHAR;
const INFORMATIONAL_RESPONSE_SUFFIX =
HIDDEN_CHAR + "informationalResponse" + HIDDEN_CHAR;
/** Type used to denote SJS scripts for CGI-like functionality. */
const SJS_TYPE = "sjs";
/** Base for relative timestamps produced by dumpn(). */
var firstStamp = 0;
/** dump(str) with a trailing "\n" -- only outputs if DEBUG. */
export function dumpn(str) {
if (DEBUG) {
var prefix = "HTTPD-INFO | ";
if (DEBUG_TIMESTAMP) {
if (firstStamp === 0) {
firstStamp = Date.now();
}
var elapsed = Date.now() - firstStamp; // milliseconds
var min = Math.floor(elapsed / 60000);
var sec = (elapsed % 60000) / 1000;
if (sec < 10) {
prefix += min + ":0" + sec.toFixed(3) + " | ";
} else {
prefix += min + ":" + sec.toFixed(3) + " | ";
}
}
dump(prefix + str + "\n");
}
}
/** Dumps the current JS stack if DEBUG. */
function dumpStack() {
// peel off the frames for dumpStack() and Error()
var stack = new Error().stack.split(/\n/).slice(2);
stack.forEach(dumpn);
}
/**
* JavaScript constructors for commonly-used classes; precreating these is a
* speedup over doing the same from base principles. See the docs at
*/
const ServerSocket = CC(
"@mozilla.org/network/server-socket;1",
"nsIServerSocket",
"init"
);
const ServerSocketIPv6 = CC(
"@mozilla.org/network/server-socket;1",
"nsIServerSocket",
"initIPv6"
);
const ServerSocketDualStack = CC(
"@mozilla.org/network/server-socket;1",
"nsIServerSocket",
"initDualStack"
);
const ScriptableInputStream = CC(
"@mozilla.org/scriptableinputstream;1",
"nsIScriptableInputStream",
"init"
);
const Pipe = CC("@mozilla.org/pipe;1", "nsIPipe", "init");
const FileInputStream = CC(
"@mozilla.org/network/file-input-stream;1",
"nsIFileInputStream",
"init"
);
const ConverterInputStream = CC(
"@mozilla.org/intl/converter-input-stream;1",
"nsIConverterInputStream",
"init"
);
const WritablePropertyBag = CC(
"@mozilla.org/hash-property-bag;1",
"nsIWritablePropertyBag2"
);
const SupportsString = CC(
"@mozilla.org/supports-string;1",
"nsISupportsString"
);
/* These two are non-const only so a test can overwrite them. */
var BinaryInputStream = CC(
"@mozilla.org/binaryinputstream;1",
"nsIBinaryInputStream",
"setInputStream"
);
var BinaryOutputStream = CC(
"@mozilla.org/binaryoutputstream;1",
"nsIBinaryOutputStream",
"setOutputStream"
);
export function overrideBinaryStreamsForTests(
inputStream,
outputStream,
responseSegmentSize
) {
BinaryInputStream = inputStream;
BinaryOutputStream = outputStream;
Response.SEGMENT_SIZE = responseSegmentSize;
}
/**
* Returns the RFC 822/1123 representation of a date.
*
* @param date : Number
* the date, in milliseconds from midnight (00:00:00), January 1, 1970 GMT
* @returns string
* the representation of the given date
*/
function toDateString(date) {
//
// rfc1123-date = wkday "," SP date1 SP time SP "GMT"
// date1 = 2DIGIT SP month SP 4DIGIT
// ; day month year (e.g., 02 Jun 1982)
// time = 2DIGIT ":" 2DIGIT ":" 2DIGIT
// ; 00:00:00 - 23:59:59
// wkday = "Mon" | "Tue" | "Wed"
// | "Thu" | "Fri" | "Sat" | "Sun"
// month = "Jan" | "Feb" | "Mar" | "Apr"
// | "May" | "Jun" | "Jul" | "Aug"
// | "Sep" | "Oct" | "Nov" | "Dec"
//
const wkdayStrings = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
const monthStrings = [
"Jan",
"Feb",
"Mar",
"Apr",
"May",
"Jun",
"Jul",
"Aug",
"Sep",
"Oct",
"Nov",
"Dec",
];
/**
* Processes a date and returns the encoded UTC time as a string according to
* the format specified in RFC 2616.
*
* @param date : Date
* the date to process
* @returns string
* a string of the form "HH:MM:SS", ranging from "00:00:00" to "23:59:59"
*/
function toTime(date) {
var hrs = date.getUTCHours();
var rv = hrs < 10 ? "0" + hrs : hrs;
var mins = date.getUTCMinutes();
rv += ":";
rv += mins < 10 ? "0" + mins : mins;
var secs = date.getUTCSeconds();
rv += ":";
rv += secs < 10 ? "0" + secs : secs;
return rv;
}
/**
* Processes a date and returns the encoded UTC date as a string according to
* the date1 format specified in RFC 2616.
*
* @param date : Date
* the date to process
* @returns string
* a string of the form "HH:MM:SS", ranging from "00:00:00" to "23:59:59"
*/
function toDate1(date) {
var day = date.getUTCDate();
var month = date.getUTCMonth();
var year = date.getUTCFullYear();
var rv = day < 10 ? "0" + day : day;
rv += " " + monthStrings[month];
rv += " " + year;
return rv;
}
date = new Date(date);
const fmtString = "%wkday%, %date1% %time% GMT";
var rv = fmtString.replace("%wkday%", wkdayStrings[date.getUTCDay()]);
rv = rv.replace("%time%", toTime(date));
return rv.replace("%date1%", toDate1(date));
}
/**
* Instantiates a new HTTP server.
*/
export function nsHttpServer() {
/** The port on which this server listens. */
this._port = undefined;
/** The socket associated with this. */
this._socket = null;
/** The handler used to process requests to this server. */
this._handler = new ServerHandler(this);
/** Naming information for this server. */
this._identity = new ServerIdentity();
/**
* Indicates when the server is to be shut down at the end of the request.
*/
this._doQuit = false;
/**
* True if the socket in this is closed (and closure notifications have been
* sent and processed if the socket was ever opened), false otherwise.
*/
this._socketClosed = true;
/**
* Used for tracking existing connections and ensuring that all connections
* are properly cleaned up before server shutdown; increases by 1 for every
* new incoming connection.
*/
this._connectionGen = 0;
/**
* Hash of all open connections, indexed by connection number at time of
* creation.
*/
this._connections = {};
}
nsHttpServer.prototype = {
// NSISERVERSOCKETLISTENER
/**
* Processes an incoming request coming in on the given socket and contained
* in the given transport.
*
* @param socket : nsIServerSocket
* the socket through which the request was served
* @param trans : nsISocketTransport
* the transport for the request/response
* @see nsIServerSocketListener.onSocketAccepted
*/
onSocketAccepted(socket, trans) {
dumpn("*** onSocketAccepted(socket=" + socket + ", trans=" + trans + ")");
dumpn(">>> new connection on " + trans.host + ":" + trans.port);
const SEGMENT_SIZE = 8192;
const SEGMENT_COUNT = 1024;
try {
var input = trans
.openInputStream(0, SEGMENT_SIZE, SEGMENT_COUNT)
.QueryInterface(Ci.nsIAsyncInputStream);
var output = trans.openOutputStream(0, 0, 0);
} catch (e) {
dumpn("*** error opening transport streams: " + e);
trans.close(Cr.NS_BINDING_ABORTED);
return;
}
var connectionNumber = ++this._connectionGen;
try {
var conn = new Connection(
input,
output,
this,
socket.port,
trans.port,
connectionNumber,
trans
);
var reader = new RequestReader(conn);
// XXX add request timeout functionality here!
// Note: must use main thread here, or we might get a GC that will cause
// threadsafety assertions. We really need to fix XPConnect so that
// you can actually do things in multi-threaded JS. :-(
input.asyncWait(reader, 0, 0, Services.tm.mainThread);
} catch (e) {
// Assume this connection can't be salvaged and bail on it completely;
// don't attempt to close it so that we can assert that any connection
// being closed is in this._connections.
dumpn("*** error in initial request-processing stages: " + e);
trans.close(Cr.NS_BINDING_ABORTED);
return;
}
this._connections[connectionNumber] = conn;
dumpn("*** starting connection " + connectionNumber);
},
/**
* Called when the socket associated with this is closed.
*
* @param socket : nsIServerSocket
* the socket being closed
* @param status : nsresult
* the reason the socket stopped listening (NS_BINDING_ABORTED if the server
* was stopped using nsIHttpServer.stop)
* @see nsIServerSocketListener.onStopListening
*/
onStopListening(socket) {
dumpn(">>> shutting down server on port " + socket.port);
for (var n in this._connections) {
if (!this._connections[n]._requestStarted) {
this._connections[n].close();
}
}
this._socketClosed = true;
if (this._hasOpenConnections()) {
dumpn("*** open connections!!!");
}
if (!this._hasOpenConnections()) {
dumpn("*** no open connections, notifying async from onStopListening");
// Notify asynchronously so that any pending teardown in stop() has a
// chance to run first.
var self = this;
var stopEvent = {
run() {
dumpn("*** _notifyStopped async callback");
self._notifyStopped();
},
};
Services.tm.currentThread.dispatch(
stopEvent,
Ci.nsIThread.DISPATCH_NORMAL
);
}
},
// NSIHTTPSERVER
//
// see nsIHttpServer.start
//
start(port) {
this._start(port, "localhost");
},
//
// see nsIHttpServer.start_ipv6
//
start_ipv6(port) {
this._start(port, "[::1]");
},
start_dualStack(port) {
this._start(port, "[::1]", true);
},
_start(port, host, dualStack) {
if (this._socket) {
throw Components.Exception("", Cr.NS_ERROR_ALREADY_INITIALIZED);
}
this._port = port;
this._doQuit = this._socketClosed = false;
this._host = host;
// The listen queue needs to be long enough to handle
// network.http.max-persistent-connections-per-server or
// network.http.max-persistent-connections-per-proxy concurrent
// connections, plus a safety margin in case some other process is
// talking to the server as well.
var maxConnections =
5 +
Math.max(
Services.prefs.getIntPref(
"network.http.max-persistent-connections-per-server"
),
Services.prefs.getIntPref(
"network.http.max-persistent-connections-per-proxy"
)
);
try {
var loopback = true;
if (
this._host != "127.0.0.1" &&
this._host != "localhost" &&
this._host != "[::1]"
) {
loopback = false;
}
// When automatically selecting a port, sometimes the chosen port is
// "blocked" from clients. We don't want to use these ports because
// tests will intermittently fail. So, we simply keep trying to to
// get a server socket until a valid port is obtained. We limit
// ourselves to finite attempts just so we don't loop forever.
var socket;
for (var i = 100; i; i--) {
var temp = null;
if (dualStack) {
temp = new ServerSocketDualStack(this._port, maxConnections);
} else if (this._host.includes(":")) {
temp = new ServerSocketIPv6(
this._port,
loopback, // true = localhost, false = everybody
maxConnections
);
} else {
temp = new ServerSocket(
this._port,
loopback, // true = localhost, false = everybody
maxConnections
);
}
var allowed = Services.io.allowPort(temp.port, "http");
if (!allowed) {
dumpn(
">>>Warning: obtained ServerSocket listens on a blocked " +
"port: " +
temp.port
);
}
if (!allowed && this._port == -1) {
dumpn(">>>Throwing away ServerSocket with bad port.");
temp.close();
continue;
}
socket = temp;
break;
}
if (!socket) {
throw new Error(
"No socket server available. Are there no available ports?"
);
}
socket.asyncListen(this);
this._port = socket.port;
this._identity._initialize(socket.port, host, true, dualStack);
this._socket = socket;
dumpn(
">>> listening on port " +
socket.port +
", " +
maxConnections +
" pending connections"
);
} catch (e) {
dump("\n!!! could not start server on port " + port + ": " + e + "\n\n");
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
},
//
// see nsIHttpServer.stop
//
stop(callback) {
if (!this._socket) {
throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
}
// If no argument was provided to stop, return a promise.
let returnValue = undefined;
if (!callback) {
returnValue = new Promise(resolve => {
callback = resolve;
});
}
this._stopCallback =
typeof callback === "function"
? callback
: function () {
callback.onStopped();
};
dumpn(">>> stopping listening on port " + this._socket.port);
this._socket.close();
this._socket = null;
// We can't have this identity any more, and the port on which we're running
// this server now could be meaningless the next time around.
this._identity._teardown();
this._doQuit = false;
// socket-close notification and pending request completion happen async
return returnValue;
},
//
// see nsIHttpServer.registerFile
//
registerFile(path, file, handler) {
if (file && (!file.exists() || file.isDirectory())) {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
this._handler.registerFile(path, file, handler);
},
//
// see nsIHttpServer.registerDirectory
//
registerDirectory(path, directory) {
// XXX true path validation!
if (
path.charAt(0) != "/" ||
path.charAt(path.length - 1) != "/" ||
(directory && (!directory.exists() || !directory.isDirectory()))
) {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
// XXX determine behavior of nonexistent /foo/bar when a /foo/bar/ mapping
// exists!
this._handler.registerDirectory(path, directory);
},
//
// see nsIHttpServer.registerPathHandler
//
registerPathHandler(path, handler) {
this._handler.registerPathHandler(path, handler);
},
//
// see nsIHttpServer.registerPrefixHandler
//
registerPrefixHandler(prefix, handler) {
this._handler.registerPrefixHandler(prefix, handler);
},
//
// see nsIHttpServer.registerErrorHandler
//
registerErrorHandler(code, handler) {
this._handler.registerErrorHandler(code, handler);
},
//
// see nsIHttpServer.setIndexHandler
//
setIndexHandler(handler) {
this._handler.setIndexHandler(handler);
},
//
// see nsIHttpServer.registerContentType
//
registerContentType(ext, type) {
this._handler.registerContentType(ext, type);
},
get connectionNumber() {
return this._connectionGen;
},
//
// see nsIHttpServer.serverIdentity
//
get identity() {
return this._identity;
},
//
// see nsIHttpServer.getState
//
getState(path, k) {
return this._handler._getState(path, k);
},
//
// see nsIHttpServer.setState
//
setState(path, k, v) {
return this._handler._setState(path, k, v);
},
//
// see nsIHttpServer.getSharedState
//
getSharedState(k) {
return this._handler._getSharedState(k);
},
//
// see nsIHttpServer.setSharedState
//
setSharedState(k, v) {
return this._handler._setSharedState(k, v);
},
//
// see nsIHttpServer.getObjectState
//
getObjectState(k) {
return this._handler._getObjectState(k);
},
//
// see nsIHttpServer.setObjectState
//
setObjectState(k, v) {
return this._handler._setObjectState(k, v);
},
get wrappedJSObject() {
return this;
},
// NSISUPPORTS
//
// see nsISupports.QueryInterface
//
QueryInterface: ChromeUtils.generateQI([
"nsIHttpServer",
"nsIServerSocketListener",
]),
// NON-XPCOM PUBLIC API
/**
* Returns true iff this server is not running (and is not in the process of
* serving any requests still to be processed when the server was last
* stopped after being run).
*/
isStopped() {
return this._socketClosed && !this._hasOpenConnections();
},
// PRIVATE IMPLEMENTATION
/** True if this server has any open connections to it, false otherwise. */
_hasOpenConnections() {
//
// If we have any open connections, they're tracked as numeric properties on
// |this._connections|. The non-standard __count__ property could be used
// to check whether there are any properties, but standard-wise, even
// looking forward to ES5, there's no less ugly yet still O(1) way to do
// this.
//
for (var n in this._connections) {
return true;
}
return false;
},
/** Calls the server-stopped callback provided when stop() was called. */
_notifyStopped() {
NS_ASSERT(this._stopCallback !== null, "double-notifying?");
NS_ASSERT(!this._hasOpenConnections(), "should be done serving by now");
//
// NB: We have to grab this now, null out the member, *then* call the
// callback here, or otherwise the callback could (indirectly) futz with
// this._stopCallback by starting and immediately stopping this, at
// which point we'd be nulling out a field we no longer have a right to
// modify.
//
var callback = this._stopCallback;
this._stopCallback = null;
try {
callback();
} catch (e) {
// not throwing because this is specified as being usually (but not
// always) asynchronous
dump("!!! error running onStopped callback: " + e + "\n");
}
},
/**
* Notifies this server that the given connection has been closed.
*
* @param connection : Connection
* the connection that was closed
*/
_connectionClosed(connection) {
NS_ASSERT(
connection.number in this._connections,
"closing a connection " +
this +
" that we never added to the " +
"set of open connections?"
);
NS_ASSERT(
this._connections[connection.number] === connection,
"connection number mismatch? " + this._connections[connection.number]
);
delete this._connections[connection.number];
// Fire a pending server-stopped notification if it's our responsibility.
if (!this._hasOpenConnections() && this._socketClosed) {
this._notifyStopped();
}
},
/**
* Requests that the server be shut down when possible.
*/
_requestQuit() {
dumpn(">>> requesting a quit");
dumpStack();
this._doQuit = true;
},
};
export var HttpServer = nsHttpServer;
export class NodeServer {
// Executes command in the context of a node server.
// See handler in moz-http2.js
//
// Example use:
// let id = NodeServer.fork(); // id is a random string
// await NodeServer.execute(id, `"hello"`)
// > "hello"
// await NodeServer.execute(id, `(() => "hello")()`)
// > "hello"
// await NodeServer.execute(id, `(() => var_defined_on_server)()`)
// > "0"
// await NodeServer.execute(id, `var_defined_on_server`)
// > "0"
// function f(param) { if (param) return param; return "bla"; }
// await NodeServer.execute(id, f); // Defines the function on the server
// await NodeServer.execute(id, `f()`) // executes defined function
// > "bla"
// let result = await NodeServer.execute(id, `f("test")`);
// > "test"
// await NodeServer.kill(id); // shuts down the server
// Forks a new node server using moz-http2-child.js as a starting point
static fork() {
return this.sendCommand("", "/fork");
}
// Executes command in the context of the node server indicated by `id`
static execute(id, command) {
return this.sendCommand(command, `/execute/${id}`);
}
// Shuts down the server
static kill(id) {
return this.sendCommand("", `/kill/${id}`);
}
// Issues a request to the node server (handler defined in moz-http2.js)
// This method should not be called directly.
static sendCommand(command, path) {
let h2Port = Services.env.get("MOZNODE_EXEC_PORT");
if (!h2Port) {
throw new Error("Could not find MOZNODE_EXEC_PORT");
}
let req = new XMLHttpRequest();
const serverIP =
AppConstants.platform == "android" ? "10.0.2.2" : "127.0.0.1";
req.channel.QueryInterface(Ci.nsIHttpChannelInternal).bypassProxy = true;
// Passing a function to NodeServer.execute will define that function
// in node. It can be called in a later execute command.
let isFunction = function (obj) {
return !!(obj && obj.constructor && obj.call && obj.apply);
};
let payload = command;
if (isFunction(command)) {
payload = `${command.name} = ${command.toString()};`;
}
return new Promise((resolve, reject) => {
req.onload = () => {
let x = null;
if (req.statusText != "OK") {
reject(`XHR request failed: ${req.statusText}`);
return;
}
try {
x = JSON.parse(req.responseText);
} catch (e) {
reject(`Failed to parse ${req.responseText} - ${e}`);
return;
}
if (x.error) {
let e = new Error(x.error, "", 0);
e.stack = x.errorStack;
reject(e);
return;
}
resolve(x.result);
};
req.onerror = e => {
reject(e);
};
req.send(payload.toString());
});
}
}
//
// RFC 2396 section 3.2.2:
//
// host = hostname | IPv4address
// hostname = *( domainlabel "." ) toplabel [ "." ]
// domainlabel = alphanum | alphanum *( alphanum | "-" ) alphanum
// toplabel = alpha | alpha *( alphanum | "-" ) alphanum
// IPv4address = 1*digit "." 1*digit "." 1*digit "." 1*digit
//
// IPv6 addresses are notably lacking in the above definition of 'host'.
// RFC 2732 section 3 extends the host definition:
// host = hostname | IPv4address | IPv6reference
// ipv6reference = "[" IPv6address "]"
//
// RFC 3986 supersedes RFC 2732 and offers a more precise definition of a IPv6
// address. For simplicity, the regexp below captures all canonical IPv6
// addresses (e.g. [::1]), but may also match valid non-canonical IPv6 addresses
// (e.g. [::127.0.0.1]) and even invalid bracketed addresses ([::], [99999::]).
const HOST_REGEX = new RegExp(
"^(?:" +
// *( domainlabel "." )
"(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)*" +
// toplabel [ "." ]
"[a-z](?:[a-z0-9-]*[a-z0-9])?\\.?" +
"|" +
// IPv4 address
"\\d+\\.\\d+\\.\\d+\\.\\d+" +
"|" +
// IPv6 addresses (e.g. [::1])
"\\[[:0-9a-f]+\\]" +
")$",
"i"
);
/**
* Represents the identity of a server. An identity consists of a set of
* (scheme, host, port) tuples denoted as locations (allowing a single server to
* serve multiple sites or to be used behind both HTTP and HTTPS proxies for any
* host/port). Any incoming request must be to one of these locations, or it
* will be rejected with an HTTP 400 error. One location, denoted as the
* primary location, is the location assigned in contexts where a location
* cannot otherwise be endogenously derived, such as for HTTP/1.0 requests.
*
* A single identity may contain at most one location per unique host/port pair;
* other than that, no restrictions are placed upon what locations may
* constitute an identity.
*/
function ServerIdentity() {
/** The scheme of the primary location. */
this._primaryScheme = "http";
/** The hostname of the primary location. */
this._primaryHost = "127.0.0.1";
/** The port number of the primary location. */
this._primaryPort = -1;
/**
* The current port number for the corresponding server, stored so that a new
* primary location can always be set if the current one is removed.
*/
this._defaultPort = -1;
/**
* Maps hosts to maps of ports to schemes, e.g. the following would represent
*
* {
* "xexample.com": { 789: "https" },
* "xexample.org": { 80: "http" }
* }
*
* Note the "x" prefix on hostnames, which prevents collisions with special
* JS names like "prototype".
*/
this._locations = { xlocalhost: {} };
}
ServerIdentity.prototype = {
// NSIHTTPSERVERIDENTITY
//
// see nsIHttpServerIdentity.primaryScheme
//
get primaryScheme() {
if (this._primaryPort === -1) {
throw Components.Exception("", Cr.NS_ERROR_NOT_INITIALIZED);
}
return this._primaryScheme;
},
//
// see nsIHttpServerIdentity.primaryHost
//
get primaryHost() {
if (this._primaryPort === -1) {
throw Components.Exception("", Cr.NS_ERROR_NOT_INITIALIZED);
}
return this._primaryHost;
},
//
// see nsIHttpServerIdentity.primaryPort
//
get primaryPort() {
if (this._primaryPort === -1) {
throw Components.Exception("", Cr.NS_ERROR_NOT_INITIALIZED);
}
return this._primaryPort;
},
//
// see nsIHttpServerIdentity.add
//
add(scheme, host, port) {
this._validate(scheme, host, port);
var entry = this._locations["x" + host];
if (!entry) {
this._locations["x" + host] = entry = {};
}
entry[port] = scheme;
},
//
// see nsIHttpServerIdentity.remove
//
remove(scheme, host, port) {
this._validate(scheme, host, port);
var entry = this._locations["x" + host];
if (!entry) {
return false;
}
var present = port in entry;
delete entry[port];
if (
this._primaryScheme == scheme &&
this._primaryHost == host &&
this._primaryPort == port &&
this._defaultPort !== -1
) {
// Always keep at least one identity in existence at any time, unless
// we're in the process of shutting down (the last condition above).
this._primaryPort = -1;
this._initialize(this._defaultPort, host, false);
}
return present;
},
//
// see nsIHttpServerIdentity.has
//
has(scheme, host, port) {
this._validate(scheme, host, port);
return (
"x" + host in this._locations &&
scheme === this._locations["x" + host][port]
);
},
//
// see nsIHttpServerIdentity.has
//
getScheme(host, port) {
this._validate("http", host, port);
var entry = this._locations["x" + host];
if (!entry) {
return "";
}
return entry[port] || "";
},
//
// see nsIHttpServerIdentity.setPrimary
//
setPrimary(scheme, host, port) {
this._validate(scheme, host, port);
this.add(scheme, host, port);
this._primaryScheme = scheme;
this._primaryHost = host;
this._primaryPort = port;
},
// NSISUPPORTS
//
// see nsISupports.QueryInterface
//
QueryInterface: ChromeUtils.generateQI(["nsIHttpServerIdentity"]),
// PRIVATE IMPLEMENTATION
/**
* Initializes the primary name for the corresponding server, based on the
* provided port number.
*/
_initialize(port, host, addSecondaryDefault, dualStack) {
this._host = host;
if (this._primaryPort !== -1) {
this.add("http", host, port);
} else {
this.setPrimary("http", "localhost", port);
}
this._defaultPort = port;
// Only add this if we're being called at server startup
if (addSecondaryDefault && host != "127.0.0.1") {
if (host.includes(":")) {
this.add("http", "[::1]", port);
if (dualStack) {
this.add("http", "127.0.0.1", port);
}
} else {
this.add("http", "127.0.0.1", port);
}
}
},
/**
* Called at server shutdown time, unsets the primary location only if it was
* the default-assigned location and removes the default location from the
* set of locations used.
*/
_teardown() {
if (this._host != "127.0.0.1") {
// Not the default primary location, nothing special to do here
this.remove("http", "127.0.0.1", this._defaultPort);
}
// This is a *very* tricky bit of reasoning here; make absolutely sure the
// tests for this code pass before you commit changes to it.
if (
this._primaryScheme == "http" &&
this._primaryHost == this._host &&
this._primaryPort == this._defaultPort
) {
// Make sure we don't trigger the readding logic in .remove(), then remove
// the default location.
var port = this._defaultPort;
this._defaultPort = -1;
this.remove("http", this._host, port);
// Ensure a server start triggers the setPrimary() path in ._initialize()
this._primaryPort = -1;
} else {
// No reason not to remove directly as it's not our primary location
this.remove("http", this._host, this._defaultPort);
}
},
/**
* Ensures scheme, host, and port are all valid with respect to RFC 2396.
*
* @throws NS_ERROR_ILLEGAL_VALUE
* if any argument doesn't match the corresponding production
*/
_validate(scheme, host, port) {
if (scheme !== "http" && scheme !== "https") {
dumpn("*** server only supports http/https schemes: '" + scheme + "'");
dumpStack();
throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
}
if (!HOST_REGEX.test(host)) {
dumpn("*** unexpected host: '" + host + "'");
throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
}
if (port < 0 || port > 65535) {
dumpn("*** unexpected port: '" + port + "'");
throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
}
},
};
/**
* Represents a connection to the server (and possibly in the future the thread
* on which the connection is processed).
*
* @param input : nsIInputStream
* stream from which incoming data on the connection is read
* @param output : nsIOutputStream
* stream to write data out the connection
* @param server : nsHttpServer
* the server handling the connection
* @param port : int
* the port on which the server is running
* @param outgoingPort : int
* the outgoing port used by this connection
* @param number : uint
* a serial number used to uniquely identify this connection
*/
function Connection(
input,
output,
server,
port,
outgoingPort,
number,
transport
) {
dumpn("*** opening new connection " + number + " on port " + outgoingPort);
/** Stream of incoming data. */
this.input = input;
/** Stream for outgoing data. */
this.output = output;
/** The server associated with this request. */
this.server = server;
/** The port on which the server is running. */
this.port = port;
/** The outgoing poort used by this connection. */
this._outgoingPort = outgoingPort;
/** The serial number of this connection. */
this.number = number;
/** Reference to the underlying transport. */
this.transport = transport;
/**
* The request for which a response is being generated, null if the
* incoming request has not been fully received or if it had errors.
*/
this.request = null;
/** This allows a connection to disambiguate between a peer initiating a
* close and the socket being forced closed on shutdown.
*/
this._closed = false;
/** State variable for debugging. */
this._processed = false;
/** whether or not 1st line of request has been received */
this._requestStarted = false;
}
Connection.prototype = {
/** Closes this connection's input/output streams. */
close() {
if (this._closed) {
return;
}
dumpn(
"*** closing connection " + this.number + " on port " + this._outgoingPort
);
this.input.close();
this.output.close();
this._closed = true;
var server = this.server;
server._connectionClosed(this);
// If an error triggered a server shutdown, act on it now
if (server._doQuit) {
server.stop(function () {
/* not like we can do anything better */
});
}
},
/**
* Initiates processing of this connection, using the data in the given
* request.
*
* @param request : Request
* the request which should be processed
*/
process(request) {
NS_ASSERT(!this._closed && !this._processed);
this._processed = true;
this.request = request;
this.server._handler.handleResponse(this);
},
/**
* Initiates processing of this connection, generating a response with the
* given HTTP error code.
*
* @param code : uint
* an HTTP code, so in the range [0, 1000)
* @param request : Request
* incomplete data about the incoming request (since there were errors
* during its processing
*/
processError(code, request) {
NS_ASSERT(!this._closed && !this._processed);
this._processed = true;
this.request = request;
this.server._handler.handleError(code, this);
},
/** Converts this to a string for debugging purposes. */
toString() {
return (
"<Connection(" +
this.number +
(this.request ? ", " + this.request.path : "") +
"): " +
(this._closed ? "closed" : "open") +
">"
);
},
requestStarted() {
this._requestStarted = true;
},
};
/** Returns an array of count bytes from the given input stream. */
function readBytes(inputStream, count) {
return new BinaryInputStream(inputStream).readByteArray(count);
}
/** Request reader processing states; see RequestReader for details. */
const READER_IN_REQUEST_LINE = 0;
const READER_IN_HEADERS = 1;
const READER_IN_BODY = 2;
const READER_FINISHED = 3;
/**
* Reads incoming request data asynchronously, does any necessary preprocessing,
* and forwards it to the request handler. Processing occurs in three states:
*
* READER_IN_REQUEST_LINE Reading the request's status line
* READER_IN_HEADERS Reading headers in the request
* READER_IN_BODY Reading the body of the request
* READER_FINISHED Entire request has been read and processed
*
* During the first two stages, initial metadata about the request is gathered
* into a Request object. Once the status line and headers have been processed,
* we start processing the body of the request into the Request. Finally, when
* the entire body has been read, we create a Response and hand it off to the
* ServerHandler to be given to the appropriate request handler.
*
* @param connection : Connection
* the connection for the request being read
*/
function RequestReader(connection) {
/** Connection metadata for this request. */
this._connection = connection;
/**
* A container providing line-by-line access to the raw bytes that make up the
* data which has been read from the connection but has not yet been acted
* upon (by passing it to the request handler or by extracting request
* metadata from it).
*/
this._data = new LineData();
/**
* The amount of data remaining to be read from the body of this request.
* After all headers in the request have been read this is the value in the
* Content-Length header, but as the body is read its value decreases to zero.
*/
this._contentLength = 0;
/** The current state of parsing the incoming request. */
this._state = READER_IN_REQUEST_LINE;
/** Metadata constructed from the incoming request for the request handler. */
this._metadata = new Request(connection.port);
/**
* Used to preserve state if we run out of line data midway through a
* multi-line header. _lastHeaderName stores the name of the header, while
* _lastHeaderValue stores the value we've seen so far for the header.
*
* These fields are always either both undefined or both strings.
*/
this._lastHeaderName = this._lastHeaderValue = undefined;
}
RequestReader.prototype = {
// NSIINPUTSTREAMCALLBACK
/**
* Called when more data from the incoming request is available. This method
* then reads the available data from input and deals with that data as
* necessary, depending upon the syntax of already-downloaded data.
*
* @param input : nsIAsyncInputStream
* the stream of incoming data from the connection
*/
onInputStreamReady(input) {
dumpn(
"*** onInputStreamReady(input=" +
input +
") on thread " +
Services.tm.currentThread +
" (main is " +
Services.tm.mainThread +
")"
);
dumpn("*** this._state == " + this._state);
// Handle cases where we get more data after a request error has been
// discovered but *before* we can close the connection.
var data = this._data;
if (!data) {
return;
}
try {
data.appendBytes(readBytes(input, input.available()));
} catch (e) {
if (streamClosed(e)) {
dumpn(
"*** WARNING: unexpected error when reading from socket; will " +
"be treated as if the input stream had been closed"
);
dumpn("*** WARNING: actual error was: " + e);
}
// We've lost a race -- input has been closed, but we're still expecting
// to read more data. available() will throw in this case, and since
// we're dead in the water now, destroy the connection.
dumpn(
"*** onInputStreamReady called on a closed input, destroying " +
"connection"
);
this._connection.close();
return;
}
switch (this._state) {
default:
NS_ASSERT(false, "invalid state: " + this._state);
break;
case READER_IN_REQUEST_LINE:
if (!this._processRequestLine()) {
break;
}
/* fall through */
case READER_IN_HEADERS:
if (!this._processHeaders()) {
break;
}
/* fall through */
case READER_IN_BODY:
this._processBody();
}
if (this._state != READER_FINISHED) {
input.asyncWait(this, 0, 0, Services.tm.currentThread);
}
},
//
// see nsISupports.QueryInterface
//
QueryInterface: ChromeUtils.generateQI(["nsIInputStreamCallback"]),
// PRIVATE API
/**
* Processes unprocessed, downloaded data as a request line.
*
* @returns boolean
* true iff the request line has been fully processed
*/
_processRequestLine() {
NS_ASSERT(this._state == READER_IN_REQUEST_LINE);
// Servers SHOULD ignore any empty line(s) received where a Request-Line
// is expected (section 4.1).
var data = this._data;
var line = {};
var readSuccess;
while ((readSuccess = data.readLine(line)) && line.value == "") {
dumpn("*** ignoring beginning blank line...");
}
// if we don't have a full line, wait until we do
if (!readSuccess) {
return false;
}
// we have the first non-blank line
try {
this._parseRequestLine(line.value);
this._state = READER_IN_HEADERS;
this._connection.requestStarted();
return true;
} catch (e) {
this._handleError(e);
return false;
}
},
/**
* Processes stored data, assuming it is either at the beginning or in
* the middle of processing request headers.
*
* @returns boolean
* true iff header data in the request has been fully processed
*/
_processHeaders() {
NS_ASSERT(this._state == READER_IN_HEADERS);
// XXX things to fix here:
//
// - need to support RFC 2047-encoded non-US-ASCII characters
try {
var done = this._parseHeaders();
if (done) {
var request = this._metadata;
// XXX this is wrong for requests with transfer-encodings applied to
// them, particularly chunked (which by its nature can have no
// meaningful Content-Length header)!
this._contentLength = request.hasHeader("Content-Length")
? parseInt(request.getHeader("Content-Length"), 10)
: 0;
dumpn("_processHeaders, Content-length=" + this._contentLength);
this._state = READER_IN_BODY;
}
return done;
} catch (e) {
this._handleError(e);
return false;
}
},
/**
* Processes stored data, assuming it is either at the beginning or in
* the middle of processing the request body.
*
* @returns boolean
* true iff the request body has been fully processed
*/
_processBody() {
NS_ASSERT(this._state == READER_IN_BODY);
// XXX handle chunked transfer-coding request bodies!
try {
if (this._contentLength > 0) {
var data = this._data.purge();
var count = Math.min(data.length, this._contentLength);
dumpn(
"*** loading data=" +
data +
" len=" +
data.length +
" excess=" +
(data.length - count)
);
data.length = count;
var bos = new BinaryOutputStream(this._metadata._bodyOutputStream);
bos.writeByteArray(data);
this._contentLength -= count;
}
dumpn("*** remaining body data len=" + this._contentLength);
if (this._contentLength == 0) {
this._validateRequest();
this._state = READER_FINISHED;
this._handleResponse();
return true;
}
return false;
} catch (e) {
this._handleError(e);
return false;
}
},
/**
* Does various post-header checks on the data in this request.
*
* @throws : HttpError
* if the request was malformed in some way
*/
_validateRequest() {
NS_ASSERT(this._state == READER_IN_BODY);
dumpn("*** _validateRequest");
var metadata = this._metadata;
var headers = metadata._headers;
// 19.6.1.1 -- servers MUST report 400 to HTTP/1.1 requests w/o Host header
var identity = this._connection.server.identity;
if (metadata._httpVersion.atLeast(nsHttpVersion.HTTP_1_1)) {
if (!headers.hasHeader("Host")) {
dumpn("*** malformed HTTP/1.1 or greater request with no Host header!");
throw HTTP_400;
}
// If the Request-URI wasn't absolute, then we need to determine our host.
// We have to determine what scheme was used to access us based on the
// server identity data at this point, because the request just doesn't
// contain enough data on its own to do this, sadly.
if (!metadata._host) {
var host, port;
var hostPort = headers.getHeader("Host");
var colon = hostPort.lastIndexOf(":");
if (hostPort.lastIndexOf("]") > colon) {
colon = -1;
}
if (colon < 0) {
host = hostPort;
port = "";
} else {
host = hostPort.substring(0, colon);
port = hostPort.substring(colon + 1);
}
// NB: We allow an empty port here because, oddly, a colon may be
// present even without a port number, e.g. "example.com:"; in this
// case the default port applies.
if (!HOST_REGEX.test(host) || !/^\d*$/.test(port)) {
dumpn(
"*** malformed hostname (" +
hostPort +
") in Host " +
"header, 400 time"
);
throw HTTP_400;
}
// If we're not given a port, we're stuck, because we don't know what
// scheme to use to look up the correct port here, in general. Since
// the HTTPS case requires a tunnel/proxy and thus requires that the
// requested URI be absolute (and thus contain the necessary
// information), let's assume HTTP will prevail and use that.
port = +port || 80;
var scheme = identity.getScheme(host, port);
if (!scheme) {
dumpn(
"*** unrecognized hostname (" +
hostPort +
") in Host " +
"header, 400 time"
);
throw HTTP_400;
}
metadata._scheme = scheme;
metadata._host = host;
metadata._port = port;
}
} else {
NS_ASSERT(
metadata._host === undefined,
"HTTP/1.0 doesn't allow absolute paths in the request line!"
);
metadata._scheme = identity.primaryScheme;
metadata._host = identity.primaryHost;
metadata._port = identity.primaryPort;
}
NS_ASSERT(
identity.has(metadata._scheme, metadata._host, metadata._port),
"must have a location we recognize by now!"
);
},
/**
* Handles responses in case of error, either in the server or in the request.
*
* @param e
* the specific error encountered, which is an HttpError in the case where
* the request is in some way invalid or cannot be fulfilled; if this isn't
* an HttpError we're going to be paranoid and shut down, because that
* shouldn't happen, ever
*/
_handleError(e) {
// Don't fall back into normal processing!
this._state = READER_FINISHED;
var server = this._connection.server;
if (e instanceof HttpError) {
var code = e.code;
} else {
dumpn(
"!!! UNEXPECTED ERROR: " +
e +
(e.lineNumber ? ", line " + e.lineNumber : "")
);
// no idea what happened -- be paranoid and shut down
code = 500;
server._requestQuit();
}
// make attempted reuse of data an error
this._data = null;
this._connection.processError(code, this._metadata);
},
/**
* Now that we've read the request line and headers, we can actually hand off
* the request to be handled.
*
* This method is called once per request, after the request line and all
* headers and the body, if any, have been received.
*/
_handleResponse() {
NS_ASSERT(this._state == READER_FINISHED);
// We don't need the line-based data any more, so make attempted reuse an
// error.
this._data = null;
this._connection.process(this._metadata);
},
// PARSING
/**
* Parses the request line for the HTTP request associated with this.
*
* @param line : string
* the request line
*/
_parseRequestLine(line) {
NS_ASSERT(this._state == READER_IN_REQUEST_LINE);
dumpn("*** _parseRequestLine('" + line + "')");
var metadata = this._metadata;
// clients and servers SHOULD accept any amount of SP or HT characters
// between fields, even though only a single SP is required (section 19.3)
var request = line.split(/[ \t]+/);
if (!request || request.length != 3) {
dumpn("*** No request in line");
throw HTTP_400;
}
metadata._method = request[0];
// get the HTTP version
var ver = request[2];
var match = ver.match(/^HTTP\/(\d+\.\d+)$/);
if (!match) {
dumpn("*** No HTTP version in line");
throw HTTP_400;
}
// determine HTTP version
try {
metadata._httpVersion = new nsHttpVersion(match[1]);
if (!metadata._httpVersion.atLeast(nsHttpVersion.HTTP_1_0)) {
throw new Error("unsupported HTTP version");
}
} catch (e) {
// we support HTTP/1.0 and HTTP/1.1 only
throw HTTP_501;
}
var fullPath = request[1];
if (metadata._method == "CONNECT") {
metadata._path = "CONNECT";
metadata._scheme = "https";
[metadata._host, metadata._port] = fullPath.split(":");
return;
}
var serverIdentity = this._connection.server.identity;
var scheme, host, port;
if (fullPath.charAt(0) != "/") {
// No absolute paths in the request line in HTTP prior to 1.1
if (!metadata._httpVersion.atLeast(nsHttpVersion.HTTP_1_1)) {
dumpn("*** Metadata version too low");
throw HTTP_400;
}
try {
var uri = Services.io.newURI(fullPath);
fullPath = uri.pathQueryRef;
scheme = uri.scheme;
host = uri.asciiHost;
if (host.includes(":")) {
// If the host still contains a ":", then it is an IPv6 address.
// IPv6 addresses-as-host are registered with brackets, so we need to
// wrap the host in brackets because nsIURI's host lacks them.
host = `[${host}]`;
}
metadata._host = host;
port = uri.port;
if (port === -1) {
if (scheme === "http") {
port = 80;
} else if (scheme === "https") {
port = 443;
} else {
dumpn("*** Unknown scheme: " + scheme);
throw HTTP_400;
}
}
} catch (e) {
// If the host is not a valid host on the server, the response MUST be a
// 400 (Bad Request) error message (section 5.2). Alternately, the URI
// is malformed.
dumpn("*** Threw when dealing with URI: " + e);
throw HTTP_400;
}
if (
!serverIdentity.has(scheme, host, port) ||
fullPath.charAt(0) != "/"
) {
dumpn("*** serverIdentity unknown or path does not start with '/'");
throw HTTP_400;
}
}
var splitter = fullPath.indexOf("?");
if (splitter < 0) {
// _queryString already set in ctor
metadata._path = fullPath;
} else {
metadata._path = fullPath.substring(0, splitter);
metadata._queryString = fullPath.substring(splitter + 1);
}
metadata._scheme = scheme;
metadata._host = host;
metadata._port = port;
},
/**
* Parses all available HTTP headers in this until the header-ending CRLFCRLF,
* adding them to the store of headers in the request.
*
* @throws
* HTTP_400 if the headers are malformed
* @returns boolean
* true if all headers have now been processed, false otherwise
*/
_parseHeaders() {
NS_ASSERT(this._state == READER_IN_HEADERS);
dumpn("*** _parseHeaders");
var data = this._data;
var headers = this._metadata._headers;
var lastName = this._lastHeaderName;
var lastVal = this._lastHeaderValue;
var line = {};
while (true) {
dumpn("*** Last name: '" + lastName + "'");
dumpn("*** Last val: '" + lastVal + "'");
NS_ASSERT(
!((lastVal === undefined) ^ (lastName === undefined)),
lastName === undefined
? "lastVal without lastName? lastVal: '" + lastVal + "'"
: "lastName without lastVal? lastName: '" + lastName + "'"
);
if (!data.readLine(line)) {
// save any data we have from the header we might still be processing
this._lastHeaderName = lastName;
this._lastHeaderValue = lastVal;
return false;
}
var lineText = line.value;
dumpn("*** Line text: '" + lineText + "'");
var firstChar = lineText.charAt(0);
// blank line means end of headers
if (lineText == "") {
// we're finished with the previous header
if (lastName) {
try {
headers.setHeader(lastName, lastVal, true);
} catch (e) {
dumpn("*** setHeader threw on last header, e == " + e);
throw HTTP_400;
}
} else {
// no headers in request -- valid for HTTP/1.0 requests
}
// either way, we're done processing headers
this._state = READER_IN_BODY;
return true;
} else if (firstChar == " " || firstChar == "\t") {
// multi-line header if we've already seen a header line
if (!lastName) {
dumpn("We don't have a header to continue!");
throw HTTP_400;
}
// append this line's text to the value; starts with SP/HT, so no need
// for separating whitespace
lastVal += lineText;
} else {
// we have a new header, so set the old one (if one existed)
if (lastName) {
try {
headers.setHeader(lastName, lastVal, true);
} catch (e) {
dumpn("*** setHeader threw on a header, e == " + e);
throw HTTP_400;
}
}
var colon = lineText.indexOf(":"); // first colon must be splitter
if (colon < 1) {
dumpn("*** No colon or missing header field-name");
throw HTTP_400;
}
// set header name, value (to be set in the next loop, usually)
lastName = lineText.substring(0, colon);
lastVal = lineText.substring(colon + 1);
} // empty, continuation, start of header
} // while (true)
},
};
/** The character codes for CR and LF. */
const CR = 0x0d,
LF = 0x0a;
/**
* Calculates the number of characters before the first CRLF pair in array, or
* -1 if the array contains no CRLF pair.
*
* @param array : Array
* an array of numbers in the range [0, 256), each representing a single
* character; the first CRLF is the lowest index i where
* |array[i] == "\r".charCodeAt(0)| and |array[i+1] == "\n".charCodeAt(0)|,
* if such an |i| exists, and -1 otherwise
* @param start : uint
* start index from which to begin searching in array
* @returns int
* the index of the first CRLF if any were present, -1 otherwise
*/
function findCRLF(array, start) {
for (var i = array.indexOf(CR, start); i >= 0; i = array.indexOf(CR, i + 1)) {
if (array[i + 1] == LF) {
return i;
}
}
return -1;
}
/**
* A container which provides line-by-line access to the arrays of bytes with
* which it is seeded.
*/
export function LineData() {
/** An array of queued bytes from which to get line-based characters. */
this._data = [];
/** Start index from which to search for CRLF. */
this._start = 0;
}
LineData.prototype = {
/**
* Appends the bytes in the given array to the internal data cache maintained
* by this.
*/
appendBytes(bytes) {
var count = bytes.length;
var quantum = 262144; // just above half SpiderMonkey's argument-count limit
if (count < quantum) {
Array.prototype.push.apply(this._data, bytes);
return;
}
// Large numbers of bytes may cause Array.prototype.push to be called with
// more arguments than the JavaScript engine supports. In that case append
// bytes in fixed-size amounts until all bytes are appended.
for (var start = 0; start < count; start += quantum) {
var slice = bytes.slice(start, Math.min(start + quantum, count));
Array.prototype.push.apply(this._data, slice);
}
},
/**
* Removes and returns a line of data, delimited by CRLF, from this.
*
* @param out
* an object whose "value" property will be set to the first line of text
* present in this, sans CRLF, if this contains a full CRLF-delimited line
* of text; if this doesn't contain enough data, the value of the property
* is undefined
* @returns boolean
* true if a full line of data could be read from the data in this, false
* otherwise
*/
readLine(out) {
var data = this._data;
var length = findCRLF(data, this._start);
if (length < 0) {
this._start = data.length;
// But if our data ends in a CR, we have to back up one, because
// the first byte in the next packet might be an LF and if we
// start looking at data.length we won't find it.
if (data.length && data[data.length - 1] === CR) {
--this._start;
}
return false;
}
// Reset for future lines.
this._start = 0;
//
// We have the index of the CR, so remove all the characters, including
// CRLF, from the array with splice, and convert the removed array
// (excluding the trailing CRLF characters) into the corresponding string.
//
var leading = data.splice(0, length + 2);
var quantum = 262144;
var line = "";
for (var start = 0; start < length; start += quantum) {
var slice = leading.slice(start, Math.min(start + quantum, length));
line += String.fromCharCode.apply(null, slice);
}
out.value = line;
return true;
},
/**
* Removes the bytes currently within this and returns them in an array.
*
* @returns Array
* the bytes within this when this method is called
*/
purge() {
var data = this._data;
this._data = [];
return data;
},
};
/**
* Creates a request-handling function for an nsIHttpRequestHandler object.
*/
function createHandlerFunc(handler) {
return function (metadata, response) {
handler.handle(metadata, response);
};
}
/**
* The default handler for directories; writes an HTML response containing a
* slightly-formatted directory listing.
*/
function defaultIndexHandler(metadata, response) {
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var path = htmlEscape(decodeURI(metadata.path));
//
// Just do a very basic bit of directory listings -- no need for too much
// fanciness, especially since we don't have a style sheet in which we can
// stick rules (don't want to pollute the default path-space).
//
var body =
"<html>\
<head>\
<title>" +
path +
"</title>\
</head>\
<body>\
<h1>" +
path +
'</h1>\
<ol style="list-style-type: none">';
var directory = metadata.getProperty("directory");
NS_ASSERT(directory && directory.isDirectory());
var fileList = [];
var files = directory.directoryEntries;
while (files.hasMoreElements()) {
var f = files.nextFile;
let name = f.leafName;
if (
!f.isHidden() &&
(name.charAt(name.length - 1) != HIDDEN_CHAR ||
name.charAt(name.length - 2) == HIDDEN_CHAR)
) {
fileList.push(f);
}
}
fileList.sort(fileSort);
for (var i = 0; i < fileList.length; i++) {
var file = fileList[i];
try {
let name = file.leafName;
if (name.charAt(name.length - 1) == HIDDEN_CHAR) {
name = name.substring(0, name.length - 1);
}
var sep = file.isDirectory() ? "/" : "";
// Note: using " to delimit the attribute here because encodeURIComponent
// passes through '.
var item =
'<li><a href="' +
encodeURIComponent(name) +
sep +
'">' +
htmlEscape(name) +
sep +
"</a></li>";
body += item;
} catch (e) {
/* some file system error, ignore the file */
}
}
body +=
" </ol>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
}
/**
* Sorts a and b (nsIFile objects) into an aesthetically pleasing order.
*/
function fileSort(a, b) {
var dira = a.isDirectory(),
dirb = b.isDirectory();
if (dira && !dirb) {
return -1;
}
if (dirb && !dira) {
return 1;
}
var namea = a.leafName.toLowerCase(),
nameb = b.leafName.toLowerCase();
return nameb > namea ? -1 : 1;
}
/**
* Converts an externally-provided path into an internal path for use in
* determining file mappings.
*
* @param path
* the path to convert
* @param encoded
* true if the given path should be passed through decodeURI prior to
* conversion
* @throws URIError
* if path is incorrectly encoded
*/
function toInternalPath(path, encoded) {
if (encoded) {
path = decodeURI(path);
}
var comps = path.split("/");
for (var i = 0, sz = comps.length; i < sz; i++) {
var comp = comps[i];
if (comp.charAt(comp.length - 1) == HIDDEN_CHAR) {
comps[i] = comp + HIDDEN_CHAR;
}
}
return comps.join("/");
}
const PERMS_READONLY = (4 << 6) | (4 << 3) | 4;
/**
* Adds custom-specified headers for the given file to the given response, if
* any such headers are specified.
*
* @param file
* the file on the disk which is to be written
* @param metadata
* metadata about the incoming request
* @param response
* the Response to which any specified headers/data should be written
* @throws HTTP_500
* if an error occurred while processing custom-specified headers
*/
function maybeAddHeadersInternal(
file,
metadata,
response,
informationalResponse
) {
var name = file.leafName;
if (name.charAt(name.length - 1) == HIDDEN_CHAR) {
name = name.substring(0, name.length - 1);
}
var headerFile = file.parent;
if (!informationalResponse) {
headerFile.append(name + HEADERS_SUFFIX);
} else {
headerFile.append(name + INFORMATIONAL_RESPONSE_SUFFIX);
}
if (!headerFile.exists()) {
return;
}
const PR_RDONLY = 0x01;
var fis = new FileInputStream(
headerFile,
PR_RDONLY,
PERMS_READONLY,
Ci.nsIFileInputStream.CLOSE_ON_EOF
);
try {
var lis = new ConverterInputStream(fis, "UTF-8", 1024, 0x0);
lis.QueryInterface(Ci.nsIUnicharLineInputStream);
var line = { value: "" };
var more = lis.readLine(line);
if (!more && line.value == "") {
return;
}
// request line
var status = line.value;
if (status.indexOf("HTTP ") == 0) {
status = status.substring(5);
var space = status.indexOf(" ");
var code, description;
if (space < 0) {
code = status;
description = "";
} else {
code = status.substring(0, space);
description = status.substring(space + 1, status.length);
}
if (!informationalResponse) {
response.setStatusLine(
metadata.httpVersion,
parseInt(code, 10),
description
);
} else {
response.setInformationalResponseStatusLine(
metadata.httpVersion,
parseInt(code, 10),
description
);
}
line.value = "";
more = lis.readLine(line);
} else if (informationalResponse) {
// An informational response must have a status line.
return;
}
// headers
while (more || line.value != "") {
var header = line.value;
var colon = header.indexOf(":");
if (!informationalResponse) {
response.setHeader(
header.substring(0, colon),
header.substring(colon + 1, header.length),
false
); // allow overriding server-set headers
} else {
response.setInformationalResponseHeader(
header.substring(0, colon),
header.substring(colon + 1, header.length),
false
); // allow overriding server-set headers
}
line.value = "";
more = lis.readLine(line);
}
} catch (e) {
dumpn("WARNING: error in headers for " + metadata.path + ": " + e);
throw HTTP_500;
} finally {
fis.close();
}
}
function maybeAddHeaders(file, metadata, response) {
maybeAddHeadersInternal(file, metadata, response, false);
}
function maybeAddInformationalResponse(file, metadata, response) {
maybeAddHeadersInternal(file, metadata, response, true);
}
/**
* An object which handles requests for a server, executing default and
* overridden behaviors as instructed by the code which uses and manipulates it.
* Default behavior includes the paths / and /trace (diagnostics), with some
* support for HTTP error pages for various codes and fallback to HTTP 500 if
* those codes fail for any reason.
*
* @param server : nsHttpServer
* the server in which this handler is being used
*/
function ServerHandler(server) {
// FIELDS
/**
* The nsHttpServer instance associated with this handler.
*/
this._server = server;
/**
* A FileMap object containing the set of path->nsIFile mappings for
* all directory mappings set in the server (e.g., "/" for /var/www/html/,
* "/foo/bar/" for /local/path/, and "/foo/bar/baz/" for /local/path2).
*
* Note carefully: the leading and trailing "/" in each path (not file) are
* removed before insertion to simplify the code which uses this. You have
* been warned!
*/
this._pathDirectoryMap = new FileMap();
/**
* Custom request handlers for the server in which this resides. Path-handler
* pairs are stored as property-value pairs in this property.
*
* @see ServerHandler.prototype._defaultPaths
*/
this._overridePaths = {};
/**
* Custom request handlers for the path prefixes on the server in which this
* resides. Path-handler pairs are stored as property-value pairs in this
* property.
*
* @see ServerHandler.prototype._defaultPaths
*/
this._overridePrefixes = {};
/**
* Custom request handlers for the error handlers in the server in which this
* resides. Path-handler pairs are stored as property-value pairs in this
* property.
*
* @see ServerHandler.prototype._defaultErrors
*/
this._overrideErrors = {};
/**
* Maps file extensions to their MIME types in the server, overriding any
* mapping that might or might not exist in the MIME service.
*/
this._mimeMappings = {};
/**
* The default handler for requests for directories, used to serve directories
* when no index file is present.
*/
this._indexHandler = defaultIndexHandler;
/** Per-path state storage for the server. */
this._state = {};
/** Entire-server state storage. */
this._sharedState = {};
/** Entire-server state storage for nsISupports values. */
this._objectState = {};
}
ServerHandler.prototype = {
// PUBLIC API
/**
* Handles a request to this server, responding to the request appropriately
* and initiating server shutdown if necessary.
*
* This method never throws an exception.
*
* @param connection : Connection
* the connection for this request
*/
handleResponse(connection) {
var request = connection.request;
var response = new Response(connection);
var path = request.path;
dumpn("*** path == " + path);
try {
try {
if (path in this._overridePaths) {
// explicit paths first, then files based on existing directory mappings,
// then (if the file doesn't exist) built-in server default paths
dumpn("calling override for " + path);
this._overridePaths[path](request, response);
} else {
var longestPrefix = "";
for (let prefix in this._overridePrefixes) {
if (
prefix.length > longestPrefix.length &&
path.substr(0, prefix.length) == prefix
) {
longestPrefix = prefix;
}
}
if (longestPrefix.length) {
dumpn("calling prefix override for " + longestPrefix);
this._overridePrefixes[longestPrefix](request, response);
} else {
this._handleDefault(request, response);
}
}
} catch (e) {
if (response.partiallySent()) {
response.abort(e);
return;
}
if (!(e instanceof HttpError)) {
dumpn("*** unexpected error: e == " + e);
throw HTTP_500;
}
if (e.code !== 404) {
throw e;
}
dumpn("*** default: " + (path in this._defaultPaths));
response = new Response(connection);
if (path in this._defaultPaths) {
this._defaultPaths[path](request, response);
} else {
throw HTTP_404;
}
}
} catch (e) {
if (response.partiallySent()) {
response.abort(e);
return;
}
var errorCode = "internal";
try {
if (!(e instanceof HttpError)) {
throw e;
}
errorCode = e.code;
dumpn("*** errorCode == " + errorCode);
response = new Response(connection);
if (e.customErrorHandling) {
e.customErrorHandling(response);
}
this._handleError(errorCode, request, response);
return;
} catch (e2) {
dumpn(
"*** error handling " +
errorCode +
" error: " +
"e2 == " +
e2 +
", shutting down server"
);
connection.server._requestQuit();
response.abort(e2);
return;
}
}
response.complete();
},
//
// see nsIHttpServer.registerFile
//
registerFile(path, file, handler) {
if (!file) {
dumpn("*** unregistering '" + path + "' mapping");
delete this._overridePaths[path];
return;
}
dumpn("*** registering '" + path + "' as mapping to " + file.path);
file = file.clone();
var self = this;
this._overridePaths[path] = function (request, response) {
if (!file.exists()) {
throw HTTP_404;
}
dumpn("*** responding '" + path + "' as mapping to " + file.path);
response.setStatusLine(request.httpVersion, 200, "OK");
if (typeof handler === "function") {
handler(request, response);
}
self._writeFileResponse(request, file, response, 0, file.fileSize);
};
},
//
// see nsIHttpServer.registerPathHandler
//
registerPathHandler(path, handler) {
if (!path.length) {
throw Components.Exception(
"Handler path cannot be empty",
Cr.NS_ERROR_INVALID_ARG
);
}
// XXX true path validation!
if (path.charAt(0) != "/" && path != "CONNECT") {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
this._handlerToField(handler, this._overridePaths, path);
},
//
// see nsIHttpServer.registerPrefixHandler
//
registerPrefixHandler(path, handler) {
// XXX true path validation!
if (path.charAt(0) != "/" || path.charAt(path.length - 1) != "/") {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
this._handlerToField(handler, this._overridePrefixes, path);
},
//
// see nsIHttpServer.registerDirectory
//
registerDirectory(path, directory) {
// strip off leading and trailing '/' so that we can use lastIndexOf when
// determining exactly how a path maps onto a mapped directory --
// conditional is required here to deal with "/".substring(1, 0) being
// converted to "/".substring(0, 1) per the JS specification
var key = path.length == 1 ? "" : path.substring(1, path.length - 1);
// the path-to-directory mapping code requires that the first character not
// be "/", or it will go into an infinite loop
if (key.charAt(0) == "/") {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
key = toInternalPath(key, false);
if (directory) {
dumpn("*** mapping '" + path + "' to the location " + directory.path);
this._pathDirectoryMap.put(key, directory);
} else {
dumpn("*** removing mapping for '" + path + "'");
this._pathDirectoryMap.put(key, null);
}
},
//
// see nsIHttpServer.registerErrorHandler
//
registerErrorHandler(err, handler) {
if (!(err in HTTP_ERROR_CODES)) {
dumpn(
"*** WARNING: registering non-HTTP/1.1 error code " +
"(" +
err +
") handler -- was this intentional?"
);
}
this._handlerToField(handler, this._overrideErrors, err);
},
//
// see nsIHttpServer.setIndexHandler
//
setIndexHandler(handler) {
if (!handler) {
handler = defaultIndexHandler;
} else if (typeof handler != "function") {
handler = createHandlerFunc(handler);
}
this._indexHandler = handler;
},
//
// see nsIHttpServer.registerContentType
//
registerContentType(ext, type) {
if (!type) {
delete this._mimeMappings[ext];
} else {
this._mimeMappings[ext] = headerUtils.normalizeFieldValue(type);
}
},
// PRIVATE API
/**
* Sets or remove (if handler is null) a handler in an object with a key.
*
* @param handler
* a handler, either function or an nsIHttpRequestHandler
* @param dict
* The object to attach the handler to.
* @param key
* The field name of the handler.
*/
_handlerToField(handler, dict, key) {
// for convenience, handler can be a function if this is run from xpcshell
if (typeof handler == "function") {
dict[key] = handler;
} else if (handler) {
dict[key] = createHandlerFunc(handler);
} else {
delete dict[key];
}
},
/**
* Handles a request which maps to a file in the local filesystem (if a base
* path has already been set; otherwise the 404 error is thrown).
*
* @param metadata : Request
* metadata for the incoming request
* @param response : Response
* an uninitialized Response to the given request, to be initialized by a
* request handler
* @throws HTTP_###
* if an HTTP error occurred (usually HTTP_404); note that in this case the
* calling code must handle post-processing of the response
*/
_handleDefault(metadata, response) {
dumpn("*** _handleDefault()");
response.setStatusLine(metadata.httpVersion, 200, "OK");
var path = metadata.path;
NS_ASSERT(path.charAt(0) == "/", "invalid path: <" + path + ">");
// determine the actual on-disk file; this requires finding the deepest
// path-to-directory mapping in the requested URL
var file = this._getFileForPath(path);
// the "file" might be a directory, in which case we either serve the
// contained index.html or make the index handler write the response
if (file.exists() && file.isDirectory()) {
file.append("index.html"); // make configurable?
if (!file.exists() || file.isDirectory()) {
metadata._ensurePropertyBag();
metadata._bag.setPropertyAsInterface("directory", file.parent);
this._indexHandler(metadata, response);
return;
}
}
// alternately, the file might not exist
if (!file.exists()) {
throw HTTP_404;
}
var start, end;
if (
metadata._httpVersion.atLeast(nsHttpVersion.HTTP_1_1) &&
metadata.hasHeader("Range") &&
this._getTypeFromFile(file) !== SJS_TYPE
) {
var rangeMatch = metadata
.getHeader("Range")
.match(/^bytes=(\d+)?-(\d+)?$/);
if (!rangeMatch) {
dumpn(
"*** Range header bogosity: '" + metadata.getHeader("Range") + "'"
);
throw HTTP_400;
}
if (rangeMatch[1] !== undefined) {
start = parseInt(rangeMatch[1], 10);
}
if (rangeMatch[2] !== undefined) {
end = parseInt(rangeMatch[2], 10);
}
if (start === undefined && end === undefined) {
dumpn(
"*** More Range header bogosity: '" +
metadata.getHeader("Range") +
"'"
);
throw HTTP_400;
}
// No start given, so the end is really the count of bytes from the
// end of the file.
if (start === undefined) {
start = Math.max(0, file.fileSize - end);
end = file.fileSize - 1;
}
// start and end are inclusive
if (end === undefined || end >= file.fileSize) {
end = file.fileSize - 1;
}
if (start !== undefined && start >= file.fileSize) {
var HTTP_416 = new HttpError(416, "Requested Range Not Satisfiable");
HTTP_416.customErrorHandling = function (errorResponse) {
maybeAddHeaders(file, metadata, errorResponse);
};
throw HTTP_416;
}
if (end < start) {
response.setStatusLine(metadata.httpVersion, 200, "OK");
start = 0;
end = file.fileSize - 1;
} else {
response.setStatusLine(metadata.httpVersion, 206, "Partial Content");
var contentRange = "bytes " + start + "-" + end + "/" + file.fileSize;
response.setHeader("Content-Range", contentRange);
}
} else {
start = 0;
end = file.fileSize - 1;
}
// finally...
dumpn(
"*** handling '" +
path +
"' as mapping to " +
file.path +
" from " +
start +
" to " +
end +
" inclusive"
);
this._writeFileResponse(metadata, file, response, start, end - start + 1);
},
/**
* Writes an HTTP response for the given file, including setting headers for
* file metadata.
*
* @param metadata : Request
* the Request for which a response is being generated
* @param file : nsIFile
* the file which is to be sent in the response
* @param response : Response
* the response to which the file should be written
* @param offset: uint
* the byte offset to skip to when writing
* @param count: uint
* the number of bytes to write
*/
_writeFileResponse(metadata, file, response, offset, count) {
const PR_RDONLY = 0x01;
var type = this._getTypeFromFile(file);
if (type === SJS_TYPE) {
let fis = new FileInputStream(
file,
PR_RDONLY,
PERMS_READONLY,
Ci.nsIFileInputStream.CLOSE_ON_EOF
);
try {
// If you update the list of imports, please update the list in
// tools/lint/eslint/eslint-plugin-mozilla/lib/environments/sjs.js
// as well.
var s = Cu.Sandbox(Cu.getGlobalForObject({}), {
wantGlobalProperties: [
"atob",
"btoa",
"ChromeUtils",
"IOUtils",
"PathUtils",
"TextDecoder",
"TextEncoder",
"URLSearchParams",
"URL",
],
});
s.importFunction(dump, "dump");
s.importFunction(Services, "Services");
// Define a basic key-value state-preservation API across requests, with
// keys initially corresponding to the empty string.
var self = this;
var path = metadata.path;
s.importFunction(function getState(k) {
return self._getState(path, k);
});
s.importFunction(function setState(k, v) {
self._setState(path, k, v);
});
s.importFunction(function getSharedState(k) {
return self._getSharedState(k);
});
s.importFunction(function setSharedState(k, v) {
self._setSharedState(k, v);
});
s.importFunction(function getObjectState(k, callback) {
callback(self._getObjectState(k));
});
s.importFunction(function setObjectState(k, v) {
self._setObjectState(k, v);
});
s.importFunction(function registerPathHandler(p, h) {
self.registerPathHandler(p, h);
});
// Make it possible for sjs files to access their location
this._setState(path, "__LOCATION__", file.path);
try {
// Alas, the line number in errors dumped to console when calling the
// request handler is simply an offset from where we load the SJS file.
// Work around this in a reasonably non-fragile way by dynamically
// getting the line number where we evaluate the SJS file. Don't
// separate these two lines!
var line = new Error().lineNumber;
let uri = Services.io.newFileURI(file);
Services.scriptloader.loadSubScript(uri.spec, s);
} catch (e) {
dumpn("*** syntax error in SJS at " + file.path + ": " + e);
throw HTTP_500;
}
try {
s.handleRequest(metadata, response);
} catch (e) {
dump(
"*** error running SJS at " +
file.path +
": " +
e +
" on line " +
(e instanceof Error
? e.lineNumber + " in httpd.js"
: e.lineNumber - line) +
"\n"
);
throw HTTP_500;
}
} finally {
fis.close();
}
} else {
try {
response.setHeader(
"Last-Modified",
toDateString(file.lastModifiedTime),
false
);
} catch (e) {
/* lastModifiedTime threw, ignore */
}
response.setHeader("Content-Type", type, false);
maybeAddInformationalResponse(file, metadata, response);
maybeAddHeaders(file, metadata, response);
// Allow overriding Content-Length
try {
response.getHeader("Content-Length");
} catch (e) {
response.setHeader("Content-Length", "" + count, false);
}
let fis = new FileInputStream(
file,
PR_RDONLY,
PERMS_READONLY,
Ci.nsIFileInputStream.CLOSE_ON_EOF
);
offset = offset || 0;
count = count || file.fileSize;
NS_ASSERT(offset === 0 || offset < file.fileSize, "bad offset");
NS_ASSERT(count >= 0, "bad count");
NS_ASSERT(offset + count <= file.fileSize, "bad total data size");
try {
if (offset !== 0) {
// Seek (or read, if seeking isn't supported) to the correct offset so
// the data sent to the client matches the requested range.
if (fis instanceof Ci.nsISeekableStream) {
fis.seek(Ci.nsISeekableStream.NS_SEEK_SET, offset);
} else {
new ScriptableInputStream(fis).read(offset);
}
}
} catch (e) {
fis.close();
throw e;
}
let writeMore = function () {
Services.tm.currentThread.dispatch(
writeData,
Ci.nsIThread.DISPATCH_NORMAL
);
};
var input = new BinaryInputStream(fis);
var output = new BinaryOutputStream(response.bodyOutputStream);
var writeData = {
run() {
var chunkSize = Math.min(65536, count);
count -= chunkSize;
NS_ASSERT(count >= 0, "underflow");
try {
var data = input.readByteArray(chunkSize);
NS_ASSERT(
data.length === chunkSize,
"incorrect data returned? got " +
data.length +
", expected " +
chunkSize
);
output.writeByteArray(data);
if (count === 0) {
fis.close();
response.finish();
} else {
writeMore();
}
} catch (e) {
try {
fis.close();
} finally {
response.finish();
}
throw e;
}
},
};
writeMore();
// Now that we know copying will start, flag the response as async.
response.processAsync();
}
},
/**
* Get the value corresponding to a given key for the given path for SJS state
* preservation across requests.
*
* @param path : string
* the path from which the given state is to be retrieved
* @param k : string
* the key whose corresponding value is to be returned
* @returns string
* the corresponding value, which is initially the empty string
*/
_getState(path, k) {
var state = this._state;
if (path in state && k in state[path]) {
return state[path][k];
}
return "";
},
/**
* Set the value corresponding to a given key for the given path for SJS state
* preservation across requests.
*
* @param path : string
* the path from which the given state is to be retrieved
* @param k : string
* the key whose corresponding value is to be set
* @param v : string
* the value to be set
*/
_setState(path, k, v) {
if (typeof v !== "string") {
throw new Error("non-string value passed");
}
var state = this._state;
if (!(path in state)) {
state[path] = {};
}
state[path][k] = v;
},
/**
* Get the value corresponding to a given key for SJS state preservation
* across requests.
*
* @param k : string
* the key whose corresponding value is to be returned
* @returns string
* the corresponding value, which is initially the empty string
*/
_getSharedState(k) {
var state = this._sharedState;
if (k in state) {
return state[k];
}
return "";
},
/**
* Set the value corresponding to a given key for SJS state preservation
* across requests.
*
* @param k : string
* the key whose corresponding value is to be set
* @param v : string
* the value to be set
*/
_setSharedState(k, v) {
if (typeof v !== "string") {
throw new Error("non-string value passed");
}
this._sharedState[k] = v;
},
/**
* Returns the object associated with the given key in the server for SJS
* state preservation across requests.
*
* @param k : string
* the key whose corresponding object is to be returned
* @returns nsISupports
* the corresponding object, or null if none was present
*/
_getObjectState(k) {
if (typeof k !== "string") {
throw new Error("non-string key passed");
}
return this._objectState[k] || null;
},
/**
* Sets the object associated with the given key in the server for SJS
* state preservation across requests.
*
* @param k : string
* the key whose corresponding object is to be set
* @param v : nsISupports
* the object to be associated with the given key; may be null
*/
_setObjectState(k, v) {
if (typeof k !== "string") {
throw new Error("non-string key passed");
}
if (typeof v !== "object") {
throw new Error("non-object value passed");
}
if (v && !("QueryInterface" in v)) {
throw new Error(
"must pass an nsISupports; use wrappedJSObject to ease " +
"pain when using the server from JS"
);
}
this._objectState[k] = v;
},
/**
* Gets a content-type for the given file, first by checking for any custom
* MIME-types registered with this handler for the file's extension, second by
* asking the global MIME service for a content-type, and finally by failing
* over to application/octet-stream.
*
* @param file : nsIFile
* the nsIFile for which to get a file type
* @returns string
* the best content-type which can be determined for the file
*/
_getTypeFromFile(file) {
try {
var name = file.leafName;
var dot = name.lastIndexOf(".");
if (dot > 0) {
var ext = name.slice(dot + 1);
if (ext in this._mimeMappings) {
return this._mimeMappings[ext];
}
}
return Cc["@mozilla.org/mime;1"]
.getService(Ci.nsIMIMEService)
.getTypeFromFile(file);
} catch (e) {
return "application/octet-stream";
}
},
/**
* Returns the nsIFile which corresponds to the path, as determined using
* all registered path->directory mappings and any paths which are explicitly
* overridden.
*
* @param path : string
* the server path for which a file should be retrieved, e.g. "/foo/bar"
* @throws HttpError
* when the correct action is the corresponding HTTP error (i.e., because no
* mapping was found for a directory in path, the referenced file doesn't
* exist, etc.)
* @returns nsIFile
* the file to be sent as the response to a request for the path
*/
_getFileForPath(path) {
// decode and add underscores as necessary
try {
path = toInternalPath(path, true);
} catch (e) {
dumpn("*** toInternalPath threw " + e);
throw HTTP_400; // malformed path
}
// next, get the directory which contains this path
var pathMap = this._pathDirectoryMap;
// An example progression of tmp for a path "/foo/bar/baz/" might be:
// "foo/bar/baz/", "foo/bar/baz", "foo/bar", "foo", ""
var tmp = path.substring(1);
while (true) {
// do we have a match for current head of the path?
var file = pathMap.get(tmp);
if (file) {
// XXX hack; basically disable showing mapping for /foo/bar/ when the
// requested path was /foo/bar, because relative links on the page
// will all be incorrect -- we really need the ability to easily
// redirect here instead
if (
tmp == path.substring(1) &&
!!tmp.length &&
tmp.charAt(tmp.length - 1) != "/"
) {
file = null;
} else {
break;
}
}
// if we've finished trying all prefixes, exit
if (tmp == "") {
break;
}
tmp = tmp.substring(0, tmp.lastIndexOf("/"));
}
// no mapping applies, so 404
if (!file) {
throw HTTP_404;
}
// last, get the file for the path within the determined directory
var parentFolder = file.parent;
var dirIsRoot = parentFolder == null;
// Strategy here is to append components individually, making sure we
// never move above the given directory; this allows paths such as
// "<file>/foo/../bar" but prevents paths such as "<file>/../base-sibling";
// this component-wise approach also means the code works even on platforms
// which don't use "/" as the directory separator, such as Windows
var leafPath = path.substring(tmp.length + 1);
var comps = leafPath.split("/");
for (var i = 0, sz = comps.length; i < sz; i++) {
var comp = comps[i];
if (comp == "..") {
file = file.parent;
} else if (comp == "." || comp == "") {
continue;
} else {
file.append(comp);
}
if (!dirIsRoot && file.equals(parentFolder)) {
throw HTTP_403;
}
}
return file;
},
/**
* Writes the error page for the given HTTP error code over the given
* connection.
*
* @param errorCode : uint
* the HTTP error code to be used
* @param connection : Connection
* the connection on which the error occurred
*/
handleError(errorCode, connection) {
var response = new Response(connection);
dumpn("*** error in request: " + errorCode);
this._handleError(errorCode, new Request(connection.port), response);
},
/**
* Handles a request which generates the given error code, using the
* user-defined error handler if one has been set, gracefully falling back to
* the x00 status code if the code has no handler, and failing to status code
* 500 if all else fails.
*
* @param errorCode : uint
* the HTTP error which is to be returned
* @param metadata : Request
* metadata for the request, which will often be incomplete since this is an
* error
* @param response : Response
* an uninitialized Response should be initialized when this method
* completes with information which represents the desired error code in the
* ideal case or a fallback code in abnormal circumstances (i.e., 500 is a
* fallback for 505, per HTTP specs)
*/
_handleError(errorCode, metadata, response) {
if (!metadata) {
throw Components.Exception("", Cr.NS_ERROR_NULL_POINTER);
}
var errorX00 = errorCode - (errorCode % 100);
try {
if (!(errorCode in HTTP_ERROR_CODES)) {
dumpn("*** WARNING: requested invalid error: " + errorCode);
}
// RFC 2616 says that we should try to handle an error by its class if we
// can't otherwise handle it -- if that fails, we revert to handling it as
// a 500 internal server error, and if that fails we throw and shut down
// the server
// actually handle the error
try {
if (errorCode in this._overrideErrors) {
this._overrideErrors[errorCode](metadata, response);
} else {
this._defaultErrors[errorCode](metadata, response);
}
} catch (e) {
if (response.partiallySent()) {
response.abort(e);
return;
}
// don't retry the handler that threw
if (errorX00 == errorCode) {
throw HTTP_500;
}
dumpn(
"*** error in handling for error code " +
errorCode +
", " +
"falling back to " +
errorX00 +
"..."
);
response = new Response(response._connection);
if (errorX00 in this._overrideErrors) {
this._overrideErrors[errorX00](metadata, response);
} else if (errorX00 in this._defaultErrors) {
this._defaultErrors[errorX00](metadata, response);
} else {
throw HTTP_500;
}
}
} catch (e) {
if (response.partiallySent()) {
response.abort();
return;
}
// we've tried everything possible for a meaningful error -- now try 500
dumpn(
"*** error in handling for error code " +
errorX00 +
", falling " +
"back to 500..."
);
try {
response = new Response(response._connection);
if (500 in this._overrideErrors) {
this._overrideErrors[500](metadata, response);
} else {
this._defaultErrors[500](metadata, response);
}
} catch (e2) {
dumpn("*** multiple errors in default error handlers!");
dumpn("*** e == " + e + ", e2 == " + e2);
response.abort(e2);
return;
}
}
response.complete();
},
// FIELDS
/**
* This object contains the default handlers for the various HTTP error codes.
*/
_defaultErrors: {
400(metadata, response) {
// none of the data in metadata is reliable, so hard-code everything here
response.setStatusLine("1.1", 400, "Bad Request");
response.setHeader("Content-Type", "text/plain;charset=utf-8", false);
var body = "Bad request\n";
response.bodyOutputStream.write(body, body.length);
},
403(metadata, response) {
response.setStatusLine(metadata.httpVersion, 403, "Forbidden");
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head><title>403 Forbidden</title></head>\
<body>\
<h1>403 Forbidden</h1>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
404(metadata, response) {
response.setStatusLine(metadata.httpVersion, 404, "Not Found");
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head><title>404 Not Found</title></head>\
<body>\
<h1>404 Not Found</h1>\
<p>\
<span style='font-family: monospace;'>" +
htmlEscape(metadata.path) +
"</span> was not found.\
</p>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
416(metadata, response) {
response.setStatusLine(
metadata.httpVersion,
416,
"Requested Range Not Satisfiable"
);
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head>\
<title>416 Requested Range Not Satisfiable</title></head>\
<body>\
<h1>416 Requested Range Not Satisfiable</h1>\
<p>The byte range was not valid for the\
requested resource.\
</p>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
500(metadata, response) {
response.setStatusLine(
metadata.httpVersion,
500,
"Internal Server Error"
);
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head><title>500 Internal Server Error</title></head>\
<body>\
<h1>500 Internal Server Error</h1>\
<p>Something's broken in this server and\
needs to be fixed.</p>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
501(metadata, response) {
response.setStatusLine(metadata.httpVersion, 501, "Not Implemented");
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head><title>501 Not Implemented</title></head>\
<body>\
<h1>501 Not Implemented</h1>\
<p>This server is not (yet) Apache.</p>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
505(metadata, response) {
response.setStatusLine("1.1", 505, "HTTP Version Not Supported");
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head><title>505 HTTP Version Not Supported</title></head>\
<body>\
<h1>505 HTTP Version Not Supported</h1>\
<p>This server only supports HTTP/1.0 and HTTP/1.1\
connections.</p>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
},
/**
* Contains handlers for the default set of URIs contained in this server.
*/
_defaultPaths: {
"/": function (metadata, response) {
response.setStatusLine(metadata.httpVersion, 200, "OK");
response.setHeader("Content-Type", "text/html;charset=utf-8", false);
var body =
"<html>\
<head><title>httpd.js</title></head>\
<body>\
<h1>httpd.js</h1>\
<p>If you're seeing this page, httpd.js is up and\
serving requests! Now set a base path and serve some\
files!</p>\
</body>\
</html>";
response.bodyOutputStream.write(body, body.length);
},
"/trace": function (metadata, response) {
response.setStatusLine(metadata.httpVersion, 200, "OK");
response.setHeader("Content-Type", "text/plain;charset=utf-8", false);
var body =
"Request-URI: " +
metadata.scheme +
"://" +
metadata.host +
":" +
metadata.port +
metadata.path +
"\n\n";
body += "Request (semantically equivalent, slightly reformatted):\n\n";
body += metadata.method + " " + metadata.path;
if (metadata.queryString) {
body += "?" + metadata.queryString;
}
body += " HTTP/" + metadata.httpVersion + "\r\n";
var headEnum = metadata.headers;
while (headEnum.hasMoreElements()) {
var fieldName = headEnum
.getNext()
.QueryInterface(Ci.nsISupportsString).data;
body += fieldName + ": " + metadata.getHeader(fieldName) + "\r\n";
}
response.bodyOutputStream.write(body, body.length);
},
},
};
/**
* Maps absolute paths to files on the local file system (as nsILocalFiles).
*/
function FileMap() {
/** Hash which will map paths to nsILocalFiles. */
this._map = {};
}
FileMap.prototype = {
// PUBLIC API
/**
* Maps key to a clone of the nsIFile value if value is non-null;
* otherwise, removes any extant mapping for key.
*
* @param key : string
* string to which a clone of value is mapped
* @param value : nsIFile
* the file to map to key, or null to remove a mapping
*/
put(key, value) {
if (value) {
this._map[key] = value.clone();
} else {
delete this._map[key];
}
},
/**
* Returns a clone of the nsIFile mapped to key, or null if no such
* mapping exists.
*
* @param key : string
* key to which the returned file maps
* @returns nsIFile
* a clone of the mapped file, or null if no mapping exists
*/
get(key) {
var val = this._map[key];
return val ? val.clone() : null;
},
};
// Response CONSTANTS
// token = *<any CHAR except CTLs or separators>
// CHAR = <any US-ASCII character (0-127)>
// CTL = <any US-ASCII control character (0-31) and DEL (127)>
// separators = "(" | ")" | "<" | ">" | "@"
// | "," | ";" | ":" | "\" | <">
// | "/" | "[" | "]" | "?" | "="
// | "{" | "}" | SP | HT
const IS_TOKEN_ARRAY = [
0,
0,
0,
0,
0,
0,
0,
0, // 0
0,
0,
0,
0,
0,
0,
0,
0, // 8
0,
0,
0,
0,
0,
0,
0,
0, // 16
0,
0,
0,
0,
0,
0,
0,
0, // 24
0,
1,
0,
1,
1,
1,
1,
1, // 32
0,
0,
1,
1,
0,
1,
1,
0, // 40
1,
1,
1,
1,
1,
1,
1,
1, // 48
1,
1,
0,
0,
0,
0,
0,
0, // 56
0,
1,
1,
1,
1,
1,
1,
1, // 64
1,
1,
1,
1,
1,
1,
1,
1, // 72
1,
1,
1,
1,
1,
1,
1,
1, // 80
1,
1,
1,
0,
0,
0,
1,
1, // 88
1,
1,
1,
1,
1,
1,
1,
1, // 96
1,
1,
1,
1,
1,
1,
1,
1, // 104
1,
1,
1,
1,
1,
1,
1,
1, // 112
1,
1,
1,
0,
1,
0,
1,
]; // 120
/**
* Determines whether the given character code is a CTL.
*
* @param code : uint
* the character code
* @returns boolean
* true if code is a CTL, false otherwise
*/
function isCTL(code) {
return (code >= 0 && code <= 31) || code == 127;
}
/**
* Represents a response to an HTTP request, encapsulating all details of that
* response. This includes all headers, the HTTP version, status code and
* explanation, and the entity itself.
*
* @param connection : Connection
* the connection over which this response is to be written
*/
function Response(connection) {
/** The connection over which this response will be written. */
this._connection = connection;
/**
* The HTTP version of this response; defaults to 1.1 if not set by the
* handler.
*/
this._httpVersion = nsHttpVersion.HTTP_1_1;
/**
* The HTTP code of this response; defaults to 200.
*/
this._httpCode = 200;
/**
* The description of the HTTP code in this response; defaults to "OK".
*/
this._httpDescription = "OK";
/**
* An nsIHttpHeaders object in which the headers in this response should be
* stored. This property is null after the status line and headers have been
* written to the network, and it may be modified up until it is cleared,
* except if this._finished is set first (in which case headers are written
* asynchronously in response to a finish() call not preceded by
* flushHeaders()).
*/
this._headers = new nsHttpHeaders();
/**
* Informational response:
* For example 103 Early Hint
**/
this._informationalResponseHttpVersion = nsHttpVersion.HTTP_1_1;
this._informationalResponseHttpCode = 0;
this._informationalResponseHttpDescription = "";
this._informationalResponseHeaders = new nsHttpHeaders();
this._informationalResponseSet = false;
/**
* Set to true when this response is ended (completely constructed if possible
* and the connection closed); further actions on this will then fail.
*/
this._ended = false;
/**
* A stream used to hold data written to the body of this response.
*/
this._bodyOutputStream = null;
/**
* A stream containing all data that has been written to the body of this
* response so far. (Async handlers make the data contained in this
* unreliable as a way of determining content length in general, but auxiliary
* saved information can sometimes be used to guarantee reliability.)
*/
this._bodyInputStream = null;
/**
* A stream copier which copies data to the network. It is initially null
* until replaced with a copier for response headers; when headers have been
* fully sent it is replaced with a copier for the response body, remaining
* so for the duration of response processing.
*/
this._asyncCopier = null;
/**
* True if this response has been designated as being processed
* asynchronously rather than for the duration of a single call to
* nsIHttpRequestHandler.handle.
*/
this._processAsync = false;
/**
* True iff finish() has been called on this, signaling that no more changes
* to this may be made.
*/
this._finished = false;
/**
* True iff powerSeized() has been called on this, signaling that this
* response is to be handled manually by the response handler (which may then
* send arbitrary data in response, even non-HTTP responses).
*/
this._powerSeized = false;
}
Response.prototype = {
// PUBLIC CONSTRUCTION API
//
// see nsIHttpResponse.bodyOutputStream
//
get bodyOutputStream() {
if (this._finished) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
if (!this._bodyOutputStream) {
var pipe = new Pipe(
true,
false,
Response.SEGMENT_SIZE,
PR_UINT32_MAX,
null
);
this._bodyOutputStream = pipe.outputStream;
this._bodyInputStream = pipe.inputStream;
if (this._processAsync || this._powerSeized) {
this._startAsyncProcessor();
}
}
return this._bodyOutputStream;
},
//
// see nsIHttpResponse.write
//
write(data) {
if (this._finished) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
var dataAsString = String(data);
this.bodyOutputStream.write(dataAsString, dataAsString.length);
},
//
// see nsIHttpResponse.setStatusLine
//
setStatusLineInternal(httpVersion, code, description, informationalResponse) {
if (this._finished || this._powerSeized) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
if (!informationalResponse) {
if (!this._headers) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
} else if (!this._informationalResponseHeaders) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
this._ensureAlive();
if (!(code >= 0 && code < 1000)) {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
try {
var httpVer;
// avoid version construction for the most common cases
if (!httpVersion || httpVersion == "1.1") {
httpVer = nsHttpVersion.HTTP_1_1;
} else if (httpVersion == "1.0") {
httpVer = nsHttpVersion.HTTP_1_0;
} else {
httpVer = new nsHttpVersion(httpVersion);
}
} catch (e) {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
// Reason-Phrase = *<TEXT, excluding CR, LF>
// TEXT = <any OCTET except CTLs, but including LWS>
//
// XXX this ends up disallowing octets which aren't Unicode, I think -- not
// much to do if description is IDL'd as string
if (!description) {
description = "";
}
for (var i = 0; i < description.length; i++) {
if (isCTL(description.charCodeAt(i)) && description.charAt(i) != "\t") {
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
}
// set the values only after validation to preserve atomicity
if (!informationalResponse) {
this._httpDescription = description;
this._httpCode = code;
this._httpVersion = httpVer;
} else {
this._informationalResponseSet = true;
this._informationalResponseHttpDescription = description;
this._informationalResponseHttpCode = code;
this._informationalResponseHttpVersion = httpVer;
}
},
//
// see nsIHttpResponse.setStatusLine
//
setStatusLine(httpVersion, code, description) {
this.setStatusLineInternal(httpVersion, code, description, false);
},
setInformationalResponseStatusLine(httpVersion, code, description) {
this.setStatusLineInternal(httpVersion, code, description, true);
},
//
// see nsIHttpResponse.setHeader
//
setHeader(name, value, merge) {
if (!this._headers || this._finished || this._powerSeized) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
this._ensureAlive();
this._headers.setHeader(name, value, merge);
},
setInformationalResponseHeader(name, value, merge) {
if (
!this._informationalResponseHeaders ||
this._finished ||
this._powerSeized
) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
this._ensureAlive();
this._informationalResponseHeaders.setHeader(name, value, merge);
},
setHeaderNoCheck(name, value) {
if (!this._headers || this._finished || this._powerSeized) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
this._ensureAlive();
this._headers.setHeaderNoCheck(name, value);
},
setInformationalHeaderNoCheck(name, value) {
if (!this._headers || this._finished || this._powerSeized) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
this._ensureAlive();
this._informationalResponseHeaders.setHeaderNoCheck(name, value);
},
//
// see nsIHttpResponse.processAsync
//
processAsync() {
if (this._finished) {
throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
}
if (this._powerSeized) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
if (this._processAsync) {
return;
}
this._ensureAlive();
dumpn("*** processing connection " + this._connection.number + " async");
this._processAsync = true;
/*
* Either the bodyOutputStream getter or this method is responsible for
* starting the asynchronous processor and catching writes of data to the
* response body of async responses as they happen, for the purpose of
* forwarding those writes to the actual connection's output stream.
* If bodyOutputStream is accessed first, calling this method will create
* the processor (when it first is clear that body data is to be written
* immediately, not buffered). If this method is called first, accessing
* bodyOutputStream will create the processor. If only this method is
* called, we'll write nothing, neither headers nor the nonexistent body,
* until finish() is called. Since that delay is easily avoided by simply
* getting bodyOutputStream or calling write(""), we don't worry about it.
*/
if (this._bodyOutputStream && !this._asyncCopier) {
this._startAsyncProcessor();
}
},
//
// see nsIHttpResponse.seizePower
//
seizePower() {
if (this._processAsync) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
if (this._finished) {
throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
}
if (this._powerSeized) {
return;
}
this._ensureAlive();
dumpn(
"*** forcefully seizing power over connection " +
this._connection.number +
"..."
);
// Purge any already-written data without sending it. We could as easily
// swap out the streams entirely, but that makes it possible to acquire and
// unknowingly use a stale reference, so we require there only be one of
// each stream ever for any response to avoid this complication.
if (this._asyncCopier) {
this._asyncCopier.cancel(Cr.NS_BINDING_ABORTED);
}
this._asyncCopier = null;
if (this._bodyOutputStream) {
var input = new BinaryInputStream(this._bodyInputStream);
var avail;
while ((avail = input.available()) > 0) {
input.readByteArray(avail);
}
}
this._powerSeized = true;
if (this._bodyOutputStream) {
this._startAsyncProcessor();
}
},
//
// see nsIHttpResponse.finish
//
finish() {
if (!this._processAsync && !this._powerSeized) {
throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
}
if (this._finished) {
return;
}
dumpn("*** finishing connection " + this._connection.number);
this._startAsyncProcessor(); // in case bodyOutputStream was never accessed
if (this._bodyOutputStream) {
this._bodyOutputStream.close();
}
this._finished = true;
},
// NSISUPPORTS
//
// see nsISupports.QueryInterface
//
QueryInterface: ChromeUtils.generateQI(["nsIHttpResponse"]),
// POST-CONSTRUCTION API (not exposed externally)
/**
* The HTTP version number of this, as a string (e.g. "1.1").
*/
get httpVersion() {
this._ensureAlive();
return this._httpVersion.toString();
},
/**
* The HTTP status code of this response, as a string of three characters per
* RFC 2616.
*/
get httpCode() {
this._ensureAlive();
var codeString =
(this._httpCode < 10 ? "0" : "") +
(this._httpCode < 100 ? "0" : "") +
this._httpCode;
return codeString;
},
/**
* The description of the HTTP status code of this response, or "" if none is
* set.
*/
get httpDescription() {
this._ensureAlive();
return this._httpDescription;
},
/**
* The headers in this response, as an nsHttpHeaders object.
*/
get headers() {
this._ensureAlive();
return this._headers;
},
//
// see nsHttpHeaders.getHeader
//
getHeader(name) {
this._ensureAlive();
return this._headers.getHeader(name);
},
/**
* Determines whether this response may be abandoned in favor of a newly
* constructed response. A response may be abandoned only if it is not being
* sent asynchronously and if raw control over it has not been taken from the
* server.
*
* @returns boolean
* true iff no data has been written to the network
*/
partiallySent() {
dumpn("*** partiallySent()");
return this._processAsync || this._powerSeized;
},
/**
* If necessary, kicks off the remaining request processing needed to be done
* after a request handler performs its initial work upon this response.
*/
complete() {
dumpn("*** complete()");
if (this._processAsync || this._powerSeized) {
NS_ASSERT(
this._processAsync ^ this._powerSeized,
"can't both send async and relinquish power"
);
return;
}
NS_ASSERT(!this.partiallySent(), "completing a partially-sent response?");
this._startAsyncProcessor();
// Now make sure we finish processing this request!
if (this._bodyOutputStream) {
this._bodyOutputStream.close();
}
},
/**
* Abruptly ends processing of this response, usually due to an error in an
* incoming request but potentially due to a bad error handler. Since we
* cannot handle the error in the usual way (giving an HTTP error page in
* response) because data may already have been sent (or because the response
* might be expected to have been generated asynchronously or completely from
* scratch by the handler), we stop processing this response and abruptly
* close the connection.
*
* @param e : Error
* the exception which precipitated this abort, or null if no such exception
* was generated
* @param truncateConnection : Boolean
* ensures that we truncate the connection using an RST packet, so the
* client testing code is aware that an error occurred, otherwise it may
* consider the response as valid.
*/
abort(e, truncateConnection = false) {
dumpn("*** abort(<" + e + ">)");
if (truncateConnection) {
dumpn("*** truncate connection");
this._connection.transport.setLinger(true, 0);
}
// This response will be ended by the processor if one was created.
var copier = this._asyncCopier;
if (copier) {
// We dispatch asynchronously here so that any pending writes of data to
// the connection will be deterministically written. This makes it easier
// to specify exact behavior, and it makes observable behavior more
// predictable for clients. Note that the correctness of this depends on
// callbacks in response to _waitToReadData in WriteThroughCopier
// happening asynchronously with respect to the actual writing of data to
// bodyOutputStream, as they currently do; if they happened synchronously,
// an event which ran before this one could write more data to the
// response body before we get around to canceling the copier. We have
// tests for this in test_seizepower.js, however, and I can't think of a
// way to handle both cases without removing bodyOutputStream access and
// moving its effective write(data, length) method onto Response, which
// would be slower and require more code than this anyway.
Services.tm.currentThread.dispatch(
{
run() {
dumpn("*** canceling copy asynchronously...");
copier.cancel(Cr.NS_ERROR_UNEXPECTED);
},
},
Ci.nsIThread.DISPATCH_NORMAL
);
} else {
this.end();
}
},
/**
* Closes this response's network connection, marks the response as finished,
* and notifies the server handler that the request is done being processed.
*/
end() {
NS_ASSERT(!this._ended, "ending this response twice?!?!");
this._connection.close();
if (this._bodyOutputStream) {
this._bodyOutputStream.close();
}
this._finished = true;
this._ended = true;
},
// PRIVATE IMPLEMENTATION
/**
* Sends the status line and headers of this response if they haven't been
* sent and initiates the process of copying data written to this response's
* body to the network.
*/
_startAsyncProcessor() {
dumpn("*** _startAsyncProcessor()");
// Handle cases where we're being called a second time. The former case
// happens when this is triggered both by complete() and by processAsync(),
// while the latter happens when processAsync() in conjunction with sent
// data causes abort() to be called.
if (this._asyncCopier || this._ended) {
dumpn("*** ignoring second call to _startAsyncProcessor");
return;
}
// Send headers if they haven't been sent already and should be sent, then
// asynchronously continue to send the body.
if (this._headers && !this._powerSeized) {
this._sendHeaders();
return;
}
this._headers = null;
this._sendBody();
},
/**
* Signals that all modifications to the response status line and headers are
* complete and then sends that data over the network to the client. Once
* this method completes, a different response to the request that resulted
* in this response cannot be sent -- the only possible action in case of
* error is to abort the response and close the connection.
*/
_sendHeaders() {
dumpn("*** _sendHeaders()");
NS_ASSERT(this._headers);
NS_ASSERT(this._informationalResponseHeaders);
NS_ASSERT(!this._powerSeized);
var preambleData = [];
// Informational response, e.g. 103
if (this._informationalResponseSet) {
// request-line
let statusLine =
"HTTP/" +
this._informationalResponseHttpVersion +
" " +
this._informationalResponseHttpCode +
" " +
this._informationalResponseHttpDescription +
"\r\n";
preambleData.push(statusLine);
// headers
let headEnum = this._informationalResponseHeaders.enumerator;
while (headEnum.hasMoreElements()) {
let fieldName = headEnum
.getNext()
.QueryInterface(Ci.nsISupportsString).data;
let values =
this._informationalResponseHeaders.getHeaderValues(fieldName);
for (let i = 0, sz = values.length; i < sz; i++) {
preambleData.push(fieldName + ": " + values[i] + "\r\n");
}
}
// end request-line/headers
preambleData.push("\r\n");
}
// request-line
var statusLine =
"HTTP/" +
this.httpVersion +
" " +
this.httpCode +
" " +
this.httpDescription +
"\r\n";
// header post-processing
var headers = this._headers;
headers.setHeader("Connection", "close", false);
headers.setHeader("Server", "httpd.js", false);
if (!headers.hasHeader("Date")) {
headers.setHeader("Date", toDateString(Date.now()), false);
}
// Any response not being processed asynchronously must have an associated
// Content-Length header for reasons of backwards compatibility with the
// initial server, which fully buffered every response before sending it.
// Beyond that, however, it's good to do this anyway because otherwise it's
// impossible to test behaviors that depend on the presence or absence of a
// Content-Length header.
if (!this._processAsync) {
dumpn("*** non-async response, set Content-Length");
var bodyStream = this._bodyInputStream;
var avail = bodyStream ? bodyStream.available() : 0;
// XXX assumes stream will always report the full amount of data available
headers.setHeader("Content-Length", "" + avail, false);
}
// construct and send response
dumpn("*** header post-processing completed, sending response head...");
// request-line
preambleData.push(statusLine);
// headers
var headEnum = headers.enumerator;
while (headEnum.hasMoreElements()) {
var fieldName = headEnum
.getNext()
.QueryInterface(Ci.nsISupportsString).data;
var values = headers.getHeaderValues(fieldName);
for (var i = 0, sz = values.length; i < sz; i++) {
preambleData.push(fieldName + ": " + values[i] + "\r\n");
}
}
// end request-line/headers
preambleData.push("\r\n");
var preamble = preambleData.join("");
var responseHeadPipe = new Pipe(true, false, 0, PR_UINT32_MAX, null);
responseHeadPipe.outputStream.write(preamble, preamble.length);
var response = this;
var copyObserver = {
onStartRequest() {
dumpn("*** preamble copying started");
},
onStopRequest(request, statusCode) {
dumpn(
"*** preamble copying complete " +
"[status=0x" +
statusCode.toString(16) +
"]"
);
if (!Components.isSuccessCode(statusCode)) {
dumpn(
"!!! header copying problems: non-success statusCode, " +
"ending response"
);
response.end();
} else {
response._sendBody();
}
},
QueryInterface: ChromeUtils.generateQI(["nsIRequestObserver"]),
};
this._asyncCopier = new WriteThroughCopier(
responseHeadPipe.inputStream,
this._connection.output,
copyObserver,
null
);
responseHeadPipe.outputStream.close();
// Forbid setting any more headers or modifying the request line.
this._headers = null;
},
/**
* Asynchronously writes the body of the response (or the entire response, if
* seizePower() has been called) to the network.
*/
_sendBody() {
dumpn("*** _sendBody");
NS_ASSERT(!this._headers, "still have headers around but sending body?");
// If no body data was written, we're done
if (!this._bodyInputStream) {
dumpn("*** empty body, response finished");
this.end();
return;
}
var response = this;
var copyObserver = {
onStartRequest() {
dumpn("*** onStartRequest");
},
onStopRequest(request, statusCode) {
dumpn("*** onStopRequest [status=0x" + statusCode.toString(16) + "]");
if (statusCode === Cr.NS_BINDING_ABORTED) {
dumpn("*** terminating copy observer without ending the response");
} else {
if (!Components.isSuccessCode(statusCode)) {
dumpn("*** WARNING: non-success statusCode in onStopRequest");
}
response.end();
}
},
QueryInterface: ChromeUtils.generateQI(["nsIRequestObserver"]),
};
dumpn("*** starting async copier of body data...");
this._asyncCopier = new WriteThroughCopier(
this._bodyInputStream,
this._connection.output,
copyObserver,
null
);
},
/** Ensures that this hasn't been ended. */
_ensureAlive() {
NS_ASSERT(!this._ended, "not handling response lifetime correctly");
},
};
/**
* Size of the segments in the buffer used in storing response data and writing
* it to the socket.
*/
Response.SEGMENT_SIZE = 8192;
/** Serves double duty in WriteThroughCopier implementation. */
function notImplemented() {
throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
}
/** Returns true iff the given exception represents stream closure. */
function streamClosed(e) {
return (
e === Cr.NS_BASE_STREAM_CLOSED ||
(typeof e === "object" && e.result === Cr.NS_BASE_STREAM_CLOSED)
);
}
/** Returns true iff the given exception represents a blocked stream. */
function wouldBlock(e) {
return (
e === Cr.NS_BASE_STREAM_WOULD_BLOCK ||
(typeof e === "object" && e.result === Cr.NS_BASE_STREAM_WOULD_BLOCK)
);
}
/**
* Copies data from source to sink as it becomes available, when that data can
* be written to sink without blocking.
*
* @param source : nsIAsyncInputStream
* the stream from which data is to be read
* @param sink : nsIAsyncOutputStream
* the stream to which data is to be copied
* @param observer : nsIRequestObserver
* an observer which will be notified when the copy starts and finishes
* @param context : nsISupports
* context passed to observer when notified of start/stop
* @throws NS_ERROR_NULL_POINTER
* if source, sink, or observer are null
*/
export function WriteThroughCopier(source, sink, observer, context) {
if (!source || !sink || !observer) {
throw Components.Exception("", Cr.NS_ERROR_NULL_POINTER);
}
/** Stream from which data is being read. */
this._source = source;
/** Stream to which data is being written. */
this._sink = sink;
/** Observer watching this copy. */
this._observer = observer;
/** Context for the observer watching this. */
this._context = context;
/**
* True iff this is currently being canceled (cancel has been called, the
* callback may not yet have been made).
*/
this._canceled = false;
/**
* False until all data has been read from input and written to output, at
* which point this copy is completed and cancel() is asynchronously called.
*/
this._completed = false;
/** Required by nsIRequest, meaningless. */
this.loadFlags = 0;
/** Required by nsIRequest, meaningless. */
this.loadGroup = null;
/** Required by nsIRequest, meaningless. */
this.name = "response-body-copy";
/** Status of this request. */
this.status = Cr.NS_OK;
/** Arrays of byte strings waiting to be written to output. */
this._pendingData = [];
// start copying
try {
observer.onStartRequest(this);
this._waitToReadData();
this._waitForSinkClosure();
} catch (e) {
dumpn(
"!!! error starting copy: " +
e +
("lineNumber" in e ? ", line " + e.lineNumber : "")
);
dumpn(e.stack);
this.cancel(Cr.NS_ERROR_UNEXPECTED);
}
}
WriteThroughCopier.prototype = {
/* nsISupports implementation */
QueryInterface: ChromeUtils.generateQI([
"nsIInputStreamCallback",
"nsIOutputStreamCallback",
"nsIRequest",
]),
// NSIINPUTSTREAMCALLBACK
/**
* Receives a more-data-in-input notification and writes the corresponding
* data to the output.
*
* @param input : nsIAsyncInputStream
* the input stream on whose data we have been waiting
*/
onInputStreamReady(input) {
if (this._source === null) {
return;
}
dumpn("*** onInputStreamReady");
//
// Ordinarily we'll read a non-zero amount of data from input, queue it up
// to be written and then wait for further callbacks. The complications in
// this method are the cases where we deviate from that behavior when errors
// occur or when copying is drawing to a finish.
//
// The edge cases when reading data are:
//
// Zero data is read
// If zero data was read, we're at the end of available data, so we can
// should stop reading and move on to writing out what we have (or, if
// we've already done that, onto notifying of completion).
// A stream-closed exception is thrown
// This is effectively a less kind version of zero data being read; the
// only difference is that we notify of completion with that result
// rather than with NS_OK.
// Some other exception is thrown
// This is the least kind result. We don't know what happened, so we
// act as though the stream closed except that we notify of completion
// with the result NS_ERROR_UNEXPECTED.
//
var bytesWanted = 0,
bytesConsumed = -1;
try {
input = new BinaryInputStream(input);
bytesWanted = Math.min(input.available(), Response.SEGMENT_SIZE);
dumpn("*** input wanted: " + bytesWanted);
if (bytesWanted > 0) {
var data = input.readByteArray(bytesWanted);
bytesConsumed = data.length;
this._pendingData.push(String.fromCharCode.apply(String, data));
}
dumpn("*** " + bytesConsumed + " bytes read");
// Handle the zero-data edge case in the same place as all other edge
// cases are handled.
if (bytesWanted === 0) {
throw Components.Exception("", Cr.NS_BASE_STREAM_CLOSED);
}
} catch (e) {
let rv;
if (streamClosed(e)) {
dumpn("*** input stream closed");
rv = bytesWanted === 0 ? Cr.NS_OK : Cr.NS_ERROR_UNEXPECTED;
} else {
dumpn("!!! unexpected error reading from input, canceling: " + e);
rv = Cr.NS_ERROR_UNEXPECTED;
}
this._doneReadingSource(rv);
return;
}
var pendingData = this._pendingData;
NS_ASSERT(bytesConsumed > 0);
NS_ASSERT(!!pendingData.length, "no pending data somehow?");
NS_ASSERT(
!!pendingData[pendingData.length - 1].length,
"buffered zero bytes of data?"
);
NS_ASSERT(this._source !== null);
// Reading has gone great, and we've gotten data to write now. What if we
// don't have a place to write that data, because output went away just
// before this read? Drop everything on the floor, including new data, and
// cancel at this point.
if (this._sink === null) {
pendingData.length = 0;
this._doneReadingSource(Cr.NS_ERROR_UNEXPECTED);
return;
}
// Okay, we've read the data, and we know we have a place to write it. We
// need to queue up the data to be written, but *only* if none is queued
// already -- if data's already queued, the code that actually writes the
// data will make sure to wait on unconsumed pending data.
try {
if (pendingData.length === 1) {
this._waitToWriteData();
}
} catch (e) {
dumpn(
"!!! error waiting to write data just read, swallowing and " +
"writing only what we already have: " +
e
);
this._doneWritingToSink(Cr.NS_ERROR_UNEXPECTED);
return;
}
// Whee! We successfully read some data, and it's successfully queued up to
// be written. All that remains now is to wait for more data to read.
try {
this._waitToReadData();
} catch (e) {
dumpn("!!! error waiting to read more data: " + e);
this._doneReadingSource(Cr.NS_ERROR_UNEXPECTED);
}
},
// NSIOUTPUTSTREAMCALLBACK
/**
* Callback when data may be written to the output stream without blocking, or
* when the output stream has been closed.
*
* @param output : nsIAsyncOutputStream
* the output stream on whose writability we've been waiting, also known as
* this._sink
*/
onOutputStreamReady(output) {
if (this._sink === null) {
return;
}
dumpn("*** onOutputStreamReady");
var pendingData = this._pendingData;
if (pendingData.length === 0) {
// There's no pending data to write. The only way this can happen is if
// we're waiting on the output stream's closure, so we can respond to a
// copying failure as quickly as possible (rather than waiting for data to
// be available to read and then fail to be copied). Therefore, we must
// be done now -- don't bother to attempt to write anything and wrap
// things up.
dumpn("!!! output stream closed prematurely, ending copy");
this._doneWritingToSink(Cr.NS_ERROR_UNEXPECTED);
return;
}
NS_ASSERT(!!pendingData[0].length, "queued up an empty quantum?");
//
// Write out the first pending quantum of data. The possible errors here
// are:
//
// The write might fail because we can't write that much data
// Okay, we've written what we can now, so re-queue what's left and
// finish writing it out later.
// The write failed because the stream was closed
// Discard pending data that we can no longer write, stop reading, and
// signal that copying finished.
// Some other error occurred.
// Same as if the stream were closed, but notify with the status
// NS_ERROR_UNEXPECTED so the observer knows something was wonky.
//
try {
var quantum = pendingData[0];
// XXX |quantum| isn't guaranteed to be ASCII, so we're relying on
// undefined behavior! We're only using this because writeByteArray
// for details.
var bytesWritten = output.write(quantum, quantum.length);
if (bytesWritten === quantum.length) {
pendingData.shift();
} else {
pendingData[0] = quantum.substring(bytesWritten);
}
dumpn("*** wrote " + bytesWritten + " bytes of data");
} catch (e) {
if (wouldBlock(e)) {
NS_ASSERT(
!!pendingData.length,
"stream-blocking exception with no data to write?"
);
NS_ASSERT(
!!pendingData[0].length,
"stream-blocking exception with empty quantum?"
);
this._waitToWriteData();
return;
}
if (streamClosed(e)) {
dumpn("!!! output stream prematurely closed, signaling error...");
} else {
dumpn("!!! unknown error: " + e + ", quantum=" + quantum);
}
this._doneWritingToSink(Cr.NS_ERROR_UNEXPECTED);
return;
}
// The day is ours! Quantum written, now let's see if we have more data
// still to write.
try {
if (pendingData.length) {
this._waitToWriteData();
return;
}
} catch (e) {
dumpn("!!! unexpected error waiting to write pending data: " + e);
this._doneWritingToSink(Cr.NS_ERROR_UNEXPECTED);
return;
}
// Okay, we have no more pending data to write -- but might we get more in
// the future?
if (this._source !== null) {
/*
* If we might, then wait for the output stream to be closed. (We wait
* only for closure because we have no data to write -- and if we waited
* for a specific amount of data, we would get repeatedly notified for no
* reason if over time the output stream permitted more and more data to
* be written to it without blocking.)
*/
this._waitForSinkClosure();
} else {
/*
* On the other hand, if we can't have more data because the input
* stream's gone away, then it's time to notify of copy completion.
* Victory!
*/
this._sink = null;
this._cancelOrDispatchCancelCallback(Cr.NS_OK);
}
},
// NSIREQUEST
/** Returns true if the cancel observer hasn't been notified yet. */
isPending() {
return !this._completed;
},
/** Not implemented, don't use! */
suspend: notImplemented,
/** Not implemented, don't use! */
resume: notImplemented,
/**
* Cancels data reading from input, asynchronously writes out any pending
* data, and causes the observer to be notified with the given error code when
* all writing has finished.
*
* @param status : nsresult
* the status to pass to the observer when data copying has been canceled
*/
cancel(status) {
dumpn("*** cancel(" + status.toString(16) + ")");
if (this._canceled) {
dumpn("*** suppressing a late cancel");
return;
}
this._canceled = true;
this.status = status;
// We could be in the middle of absolutely anything at this point. Both
// input and output might still be around, we might have pending data to
// write, and in general we know nothing about the state of the world. We
// therefore must assume everything's in progress and take everything to its
// final steady state (or so far as it can go before we need to finish
// writing out remaining data).
this._doneReadingSource(status);
},
// PRIVATE IMPLEMENTATION
/**
* Stop reading input if we haven't already done so, passing e as the status
* when closing the stream, and kick off a copy-completion notice if no more
* data remains to be written.
*
* @param e : nsresult
* the status to be used when closing the input stream
*/
_doneReadingSource(e) {
dumpn("*** _doneReadingSource(0x" + e.toString(16) + ")");
this._finishSource(e);
if (this._pendingData.length === 0) {
this._sink = null;
} else {
NS_ASSERT(this._sink !== null, "null output?");
}
// If we've written out all data read up to this point, then it's time to
// signal completion.
if (this._sink === null) {
NS_ASSERT(this._pendingData.length === 0, "pending data still?");
this._cancelOrDispatchCancelCallback(e);
}
},
/**
* Stop writing output if we haven't already done so, discard any data that
* remained to be sent, close off input if it wasn't already closed, and kick
* off a copy-completion notice.
*
* @param e : nsresult
* the status to be used when closing input if it wasn't already closed
*/
_doneWritingToSink(e) {
dumpn("*** _doneWritingToSink(0x" + e.toString(16) + ")");
this._pendingData.length = 0;
this._sink = null;
this._doneReadingSource(e);
},
/**
* Completes processing of this copy: either by canceling the copy if it
* hasn't already been canceled using the provided status, or by dispatching
* the cancel callback event (with the originally provided status, of course)
* if it already has been canceled.
*
* @param status : nsresult
* the status code to use to cancel this, if this hasn't already been
* canceled
*/
_cancelOrDispatchCancelCallback(status) {
dumpn("*** _cancelOrDispatchCancelCallback(" + status + ")");
NS_ASSERT(this._source === null, "should have finished input");
NS_ASSERT(this._sink === null, "should have finished output");
NS_ASSERT(this._pendingData.length === 0, "should have no pending data");
if (!this._canceled) {
this.cancel(status);
return;
}
var self = this;
var event = {
run() {
dumpn("*** onStopRequest async callback");
self._completed = true;
try {
self._observer.onStopRequest(self, self.status);
} catch (e) {
NS_ASSERT(
false,
"how are we throwing an exception here? we control " +
"all the callers! " +
e
);
}
},
};
Services.tm.currentThread.dispatch(event, Ci.nsIThread.DISPATCH_NORMAL);
},
/**
* Kicks off another wait for more data to be available from the input stream.
*/
_waitToReadData() {
dumpn("*** _waitToReadData");
this._source.asyncWait(
this,
0,
Response.SEGMENT_SIZE,
Services.tm.mainThread
);
},
/**
* Kicks off another wait until data can be written to the output stream.
*/
_waitToWriteData() {
dumpn("*** _waitToWriteData");
var pendingData = this._pendingData;
NS_ASSERT(!!pendingData.length, "no pending data to write?");
NS_ASSERT(!!pendingData[0].length, "buffered an empty write?");
this._sink.asyncWait(
this,
0,
pendingData[0].length,
Services.tm.mainThread
);
},
/**
* Kicks off a wait for the sink to which data is being copied to be closed.
* We wait for stream closure when we don't have any data to be copied, rather
* than waiting to write a specific amount of data. We can't wait to write
* data because the sink might be infinitely writable, and if no data appears
* in the source for a long time we might have to spin quite a bit waiting to
* write, waiting to write again, &c. Waiting on stream closure instead means
* we'll get just one notification if the sink dies. Note that when data
* starts arriving from the sink we'll resume waiting for data to be written,
* dropping this closure-only callback entirely.
*/
_waitForSinkClosure() {
dumpn("*** _waitForSinkClosure");
this._sink.asyncWait(
this,
Ci.nsIAsyncOutputStream.WAIT_CLOSURE_ONLY,
0,
Services.tm.mainThread
);
},
/**
* Closes input with the given status, if it hasn't already been closed;
* otherwise a no-op.
*
* @param status : nsresult
* status code use to close the source stream if necessary
*/
_finishSource(status) {
dumpn("*** _finishSource(" + status.toString(16) + ")");
if (this._source !== null) {
this._source.closeWithStatus(status);
this._source = null;
}
},
};
/**
* A container for utility functions used with HTTP headers.
*/
const headerUtils = {
/**
* Normalizes fieldName (by converting it to lowercase) and ensures it is a
* valid header field name (although not necessarily one specified in RFC
* 2616).
*
* @throws NS_ERROR_INVALID_ARG
* if fieldName does not match the field-name production in RFC 2616
* @returns string
* fieldName converted to lowercase if it is a valid header, for characters
* where case conversion is possible
*/
normalizeFieldName(fieldName) {
if (fieldName == "") {
dumpn("*** Empty fieldName");
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
for (var i = 0, sz = fieldName.length; i < sz; i++) {
if (!IS_TOKEN_ARRAY[fieldName.charCodeAt(i)]) {
dumpn(fieldName + " is not a valid header field name!");
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
}
return fieldName.toLowerCase();
},
/**
* Ensures that fieldValue is a valid header field value (although not
* necessarily as specified in RFC 2616 if the corresponding field name is
* part of the HTTP protocol), normalizes the value if it is, and
* returns the normalized value.
*
* @param fieldValue : string
* a value to be normalized as an HTTP header field value
* @throws NS_ERROR_INVALID_ARG
* if fieldValue does not match the field-value production in RFC 2616
* @returns string
* fieldValue as a normalized HTTP header field value
*/
normalizeFieldValue(fieldValue) {
// field-value = *( field-content | LWS )
// field-content = <the OCTETs making up the field-value
// and consisting of either *TEXT or combinations
// of token, separators, and quoted-string>
// TEXT = <any OCTET except CTLs,
// but including LWS>
// LWS = [CRLF] 1*( SP | HT )
//
// quoted-string = ( <"> *(qdtext | quoted-pair ) <"> )
// qdtext = <any TEXT except <">>
// quoted-pair = "\" CHAR
// CHAR = <any US-ASCII character (octets 0 - 127)>
// Any LWS that occurs between field-content MAY be replaced with a single
// SP before interpreting the field value or forwarding the message
// downstream (section 4.2); we replace 1*LWS with a single SP
var val = fieldValue.replace(/(?:(?:\r\n)?[ \t]+)+/g, " ");
// remove leading/trailing LWS (which has been converted to SP)
val = val.replace(/^ +/, "").replace(/ +$/, "");
// that should have taken care of all CTLs, so val should contain no CTLs
dumpn("*** Normalized value: '" + val + "'");
for (var i = 0, len = val.length; i < len; i++) {
if (isCTL(val.charCodeAt(i))) {
dump("*** Char " + i + " has charcode " + val.charCodeAt(i));
throw Components.Exception("", Cr.NS_ERROR_INVALID_ARG);
}
}
// XXX disallows quoted-pair where CHAR is a CTL -- will not invalidly
// normalize, however, so this can be construed as a tightening of the
// spec and not entirely as a bug
return val;
},
};
/**
* Converts the given string into a string which is safe for use in an HTML
* context.
*
* @param str : string
* the string to make HTML-safe
* @returns string
* an HTML-safe version of str
*/
function htmlEscape(str) {
// this is naive, but it'll work
var s = "";
for (var i = 0; i < str.length; i++) {
s += "&#" + str.charCodeAt(i) + ";";
}
return s;
}
/**
* Constructs an object representing an HTTP version (see section 3.1).
*
* @param versionString
* a string of the form "#.#", where # is an non-negative decimal integer with
* or without leading zeros
* @throws
* if versionString does not specify a valid HTTP version number
*/
function nsHttpVersion(versionString) {
var matches = /^(\d+)\.(\d+)$/.exec(versionString);
if (!matches) {
throw new Error("Not a valid HTTP version!");
}
/** The major version number of this, as a number. */
this.major = parseInt(matches[1], 10);
/** The minor version number of this, as a number. */
this.minor = parseInt(matches[2], 10);
if (
isNaN(this.major) ||
isNaN(this.minor) ||
this.major < 0 ||
this.minor < 0
) {
throw new Error("Not a valid HTTP version!");
}
}
nsHttpVersion.prototype = {
/**
* Returns the standard string representation of the HTTP version represented
* by this (e.g., "1.1").
*/
toString() {
return this.major + "." + this.minor;
},
/**
* Returns true if this represents the same HTTP version as otherVersion,
* false otherwise.
*
* @param otherVersion : nsHttpVersion
* the version to compare against this
*/
equals(otherVersion) {
return this.major == otherVersion.major && this.minor == otherVersion.minor;
},
/** True if this >= otherVersion, false otherwise. */
atLeast(otherVersion) {
return (
this.major > otherVersion.major ||
(this.major == otherVersion.major && this.minor >= otherVersion.minor)
);
},
};
nsHttpVersion.HTTP_1_0 = new nsHttpVersion("1.0");
nsHttpVersion.HTTP_1_1 = new nsHttpVersion("1.1");
/**
* An object which stores HTTP headers for a request or response.
*
* Note that since headers are case-insensitive, this object converts headers to
* lowercase before storing them. This allows the getHeader and hasHeader
* methods to work correctly for any case of a header, but it means that the
* values returned by .enumerator may not be equal case-sensitively to the
* values passed to setHeader when adding headers to this.
*/
export function nsHttpHeaders() {
/**
* A hash of headers, with header field names as the keys and header field
* values as the values. Header field names are case-insensitive, but upon
* insertion here they are converted to lowercase. Header field values are
* normalized upon insertion to contain no leading or trailing whitespace.
*
* Note also that per RFC 2616, section 4.2, two headers with the same name in
* a message may be treated as one header with the same field name and a field
* value consisting of the separate field values joined together with a "," in
* their original order. This hash stores multiple headers with the same name
* in this manner.
*/
this._headers = {};
}
nsHttpHeaders.prototype = {
/**
* Sets the header represented by name and value in this.
*
* @param name : string
* the header name
* @param value : string
* the header value
* @throws NS_ERROR_INVALID_ARG
* if name or value is not a valid header component
*/
setHeader(fieldName, fieldValue, merge) {
var name = headerUtils.normalizeFieldName(fieldName);
var value = headerUtils.normalizeFieldValue(fieldValue);
// The following three headers are stored as arrays because their real-world
// syntax prevents joining individual headers into a single header using
// ",". See also <https://hg.mozilla.org/mozilla-central/diff/9b2a99adc05e/netwerk/protocol/http/src/nsHttpHeaderArray.cpp#l77>
if (merge && name in this._headers) {
if (
name === "www-authenticate" ||
name === "proxy-authenticate" ||
name === "set-cookie"
) {
this._headers[name].push(value);
} else {
this._headers[name][0] += "," + value;
NS_ASSERT(
this._headers[name].length === 1,
"how'd a non-special header have multiple values?"
);
}
} else {
this._headers[name] = [value];
}
},
setHeaderNoCheck(fieldName, fieldValue) {
var name = headerUtils.normalizeFieldName(fieldName);
var value = headerUtils.normalizeFieldValue(fieldValue);
if (name in this._headers) {
this._headers[name].push(value);
} else {
this._headers[name] = [value];
}
},
/**
* Returns the value for the header specified by this.
*
* @throws NS_ERROR_INVALID_ARG
* if fieldName does not constitute a valid header field name
* @throws NS_ERROR_NOT_AVAILABLE
* if the given header does not exist in this
* @returns string
* the field value for the given header, possibly with non-semantic changes
* (i.e., leading/trailing whitespace stripped, whitespace runs replaced
* with spaces, etc.) at the option of the implementation; multiple
* instances of the header will be combined with a comma, except for
* the three headers noted in the description of getHeaderValues
*/
getHeader(fieldName) {
return this.getHeaderValues(fieldName).join("\n");
},
/**
* Returns the value for the header specified by fieldName as an array.
*
* @throws NS_ERROR_INVALID_ARG
* if fieldName does not constitute a valid header field name
* @throws NS_ERROR_NOT_AVAILABLE
* if the given header does not exist in this
* @returns [string]
* an array of all the header values in this for the given
* header name. Header values will generally be collapsed
* into a single header by joining all header values together
* with commas, but certain headers (Proxy-Authenticate,
* WWW-Authenticate, and Set-Cookie) violate the HTTP spec
* and cannot be collapsed in this manner. For these headers
* only, the returned array may contain multiple elements if
* that header has been added more than once.
*/
getHeaderValues(fieldName) {
var name = headerUtils.normalizeFieldName(fieldName);
if (name in this._headers) {
return this._headers[name];
}
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
},
/**
* Returns true if a header with the given field name exists in this, false
* otherwise.
*
* @param fieldName : string
* the field name whose existence is to be determined in this
* @throws NS_ERROR_INVALID_ARG
* if fieldName does not constitute a valid header field name
* @returns boolean
* true if the header's present, false otherwise
*/
hasHeader(fieldName) {
var name = headerUtils.normalizeFieldName(fieldName);
return name in this._headers;
},
/**
* Returns a new enumerator over the field names of the headers in this, as
* nsISupportsStrings. The names returned will be in lowercase, regardless of
* how they were input using setHeader (header names are case-insensitive per
* RFC 2616).
*/
get enumerator() {
var headers = [];
for (var i in this._headers) {
var supports = new SupportsString();
supports.data = i;
headers.push(supports);
}
return new nsSimpleEnumerator(headers);
},
};
/**
* Constructs an nsISimpleEnumerator for the given array of items.
*
* @param items : Array
* the items, which must all implement nsISupports
*/
function nsSimpleEnumerator(items) {
this._items = items;
this._nextIndex = 0;
}
nsSimpleEnumerator.prototype = {
hasMoreElements() {
return this._nextIndex < this._items.length;
},
getNext() {
if (!this.hasMoreElements()) {
throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
}
return this._items[this._nextIndex++];
},
[Symbol.iterator]() {
return this._items.values();
},
QueryInterface: ChromeUtils.generateQI(["nsISimpleEnumerator"]),
};
/**
* A representation of the data in an HTTP request.
*
* @param port : uint
* the port on which the server receiving this request runs
*/
function Request(port) {
/** Method of this request, e.g. GET or POST. */
this._method = "";
/** Path of the requested resource; empty paths are converted to '/'. */
this._path = "";
/** Query string, if any, associated with this request (not including '?'). */
this._queryString = "";
/** Scheme of requested resource, usually http, always lowercase. */
this._scheme = "http";
/** Hostname on which the requested resource resides. */
this._host = undefined;
/** Port number over which the request was received. */
this._port = port;
var bodyPipe = new Pipe(false, false, 0, PR_UINT32_MAX, null);
/** Stream from which data in this request's body may be read. */
this._bodyInputStream = bodyPipe.inputStream;
/** Stream to which data in this request's body is written. */
this._bodyOutputStream = bodyPipe.outputStream;
/**
* The headers in this request.
*/
this._headers = new nsHttpHeaders();
/**
* For the addition of ad-hoc properties and new functionality without having
* to change nsIHttpRequest every time; currently lazily created, as its only
* use is in directory listings.
*/
this._bag = null;
}
Request.prototype = {
// SERVER METADATA
//
// see nsIHttpRequest.scheme
//
get scheme() {
return this._scheme;
},
//
// see nsIHttpRequest.host
//
get host() {
return this._host;
},
//
// see nsIHttpRequest.port
//
get port() {
return this._port;
},
// REQUEST LINE
//
// see nsIHttpRequest.method
//
get method() {
return this._method;
},
//
// see nsIHttpRequest.httpVersion
//
get httpVersion() {
return this._httpVersion.toString();
},
//
// see nsIHttpRequest.path
//
get path() {
return this._path;
},
//
// see nsIHttpRequest.queryString
//
get queryString() {
return this._queryString;
},
// HEADERS
//
// see nsIHttpRequest.getHeader
//
getHeader(name) {
return this._headers.getHeader(name);
},
//
// see nsIHttpRequest.hasHeader
//
hasHeader(name) {
return this._headers.hasHeader(name);
},
//
// see nsIHttpRequest.headers
//
get headers() {
return this._headers.enumerator;
},
//
// see nsIPropertyBag.enumerator
//
get enumerator() {
this._ensurePropertyBag();
return this._bag.enumerator;
},
//
// see nsIHttpRequest.headers
//
get bodyInputStream() {
return this._bodyInputStream;
},
//
// see nsIPropertyBag.getProperty
//
getProperty(name) {
this._ensurePropertyBag();
return this._bag.getProperty(name);
},
// NSISUPPORTS
//
// see nsISupports.QueryInterface
//
QueryInterface: ChromeUtils.generateQI(["nsIHttpRequest"]),
// PRIVATE IMPLEMENTATION
/** Ensures a property bag has been created for ad-hoc behaviors. */
_ensurePropertyBag() {
if (!this._bag) {
this._bag = new WritablePropertyBag();
}
},
};