summaryrefslogtreecommitdiffstats
path: root/services/common/rest.sys.mjs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /services/common/rest.sys.mjs
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'services/common/rest.sys.mjs')
-rw-r--r--services/common/rest.sys.mjs720
1 files changed, 720 insertions, 0 deletions
diff --git a/services/common/rest.sys.mjs b/services/common/rest.sys.mjs
new file mode 100644
index 0000000000..ed32047bcd
--- /dev/null
+++ b/services/common/rest.sys.mjs
@@ -0,0 +1,720 @@
+/* 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 file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { NetUtil } from "resource://gre/modules/NetUtil.sys.mjs";
+
+import { Log } from "resource://gre/modules/Log.sys.mjs";
+
+import { CommonUtils } from "resource://services-common/utils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+ CryptoUtils: "resource://services-crypto/utils.sys.mjs",
+});
+
+function decodeString(data, charset) {
+ if (!data || !charset) {
+ return data;
+ }
+
+ // This could be simpler if we assumed the charset is only ever UTF-8.
+ // It's unclear to me how willing we are to assume this, though...
+ let stringStream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(
+ Ci.nsIStringInputStream
+ );
+ stringStream.setData(data, data.length);
+
+ let converterStream = Cc[
+ "@mozilla.org/intl/converter-input-stream;1"
+ ].createInstance(Ci.nsIConverterInputStream);
+
+ converterStream.init(
+ stringStream,
+ charset,
+ 0,
+ converterStream.DEFAULT_REPLACEMENT_CHARACTER
+ );
+
+ let remaining = data.length;
+ let body = "";
+ while (remaining > 0) {
+ let str = {};
+ let num = converterStream.readString(remaining, str);
+ if (!num) {
+ break;
+ }
+ remaining -= num;
+ body += str.value;
+ }
+ return body;
+}
+
+/**
+ * Single use HTTP requests to RESTish resources.
+ *
+ * @param uri
+ * URI for the request. This can be an nsIURI object or a string
+ * that can be used to create one. An exception will be thrown if
+ * the string is not a valid URI.
+ *
+ * Examples:
+ *
+ * (1) Quick GET request:
+ *
+ * let response = await new RESTRequest("http://server/rest/resource").get();
+ * if (!response.success) {
+ * // Bail out if we're not getting an HTTP 2xx code.
+ * processHTTPError(response.status);
+ * return;
+ * }
+ * processData(response.body);
+ *
+ * (2) Quick PUT request (non-string data is automatically JSONified)
+ *
+ * let response = await new RESTRequest("http://server/rest/resource").put(data);
+ */
+export function RESTRequest(uri) {
+ this.status = this.NOT_SENT;
+
+ // If we don't have an nsIURI object yet, make one. This will throw if
+ // 'uri' isn't a valid URI string.
+ if (!(uri instanceof Ci.nsIURI)) {
+ uri = Services.io.newURI(uri);
+ }
+ this.uri = uri;
+
+ this._headers = {};
+ this._deferred = Promise.withResolvers();
+ this._log = Log.repository.getLogger(this._logName);
+ this._log.manageLevelFromPref("services.common.log.logger.rest.request");
+}
+
+RESTRequest.prototype = {
+ _logName: "Services.Common.RESTRequest",
+
+ QueryInterface: ChromeUtils.generateQI([
+ "nsIInterfaceRequestor",
+ "nsIChannelEventSink",
+ ]),
+
+ /** Public API: **/
+
+ /**
+ * URI for the request (an nsIURI object).
+ */
+ uri: null,
+
+ /**
+ * HTTP method (e.g. "GET")
+ */
+ method: null,
+
+ /**
+ * RESTResponse object
+ */
+ response: null,
+
+ /**
+ * nsIRequest load flags. Don't do any caching by default. Don't send user
+ * cookies and such over the wire (Bug 644734).
+ */
+ loadFlags:
+ Ci.nsIRequest.LOAD_BYPASS_CACHE |
+ Ci.nsIRequest.INHIBIT_CACHING |
+ Ci.nsIRequest.LOAD_ANONYMOUS,
+
+ /**
+ * nsIHttpChannel
+ */
+ channel: null,
+
+ /**
+ * Flag to indicate the status of the request.
+ *
+ * One of NOT_SENT, SENT, IN_PROGRESS, COMPLETED, ABORTED.
+ */
+ status: null,
+
+ NOT_SENT: 0,
+ SENT: 1,
+ IN_PROGRESS: 2,
+ COMPLETED: 4,
+ ABORTED: 8,
+
+ /**
+ * HTTP status text of response
+ */
+ statusText: null,
+
+ /**
+ * Request timeout (in seconds, though decimal values can be used for
+ * up to millisecond granularity.)
+ *
+ * 0 for no timeout. Default is 300 seconds (5 minutes), the same as Sync uses
+ * in resource.js.
+ */
+ timeout: 300,
+
+ /**
+ * The encoding with which the response to this request must be treated.
+ * If a charset parameter is available in the HTTP Content-Type header for
+ * this response, that will always be used, and this value is ignored. We
+ * default to UTF-8 because that is a reasonable default.
+ */
+ charset: "utf-8",
+
+ /**
+ * Set a request header.
+ */
+ setHeader(name, value) {
+ this._headers[name.toLowerCase()] = value;
+ },
+
+ /**
+ * Perform an HTTP GET.
+ *
+ * @return Promise<RESTResponse>
+ */
+ async get() {
+ return this.dispatch("GET", null);
+ },
+
+ /**
+ * Perform an HTTP PATCH.
+ *
+ * @param data
+ * Data to be used as the request body. If this isn't a string
+ * it will be JSONified automatically.
+ *
+ * @return Promise<RESTResponse>
+ */
+ async patch(data) {
+ return this.dispatch("PATCH", data);
+ },
+
+ /**
+ * Perform an HTTP PUT.
+ *
+ * @param data
+ * Data to be used as the request body. If this isn't a string
+ * it will be JSONified automatically.
+ *
+ * @return Promise<RESTResponse>
+ */
+ async put(data) {
+ return this.dispatch("PUT", data);
+ },
+
+ /**
+ * Perform an HTTP POST.
+ *
+ * @param data
+ * Data to be used as the request body. If this isn't a string
+ * it will be JSONified automatically.
+ *
+ * @return Promise<RESTResponse>
+ */
+ async post(data) {
+ return this.dispatch("POST", data);
+ },
+
+ /**
+ * Perform an HTTP DELETE.
+ *
+ * @return Promise<RESTResponse>
+ */
+ async delete() {
+ return this.dispatch("DELETE", null);
+ },
+
+ /**
+ * Abort an active request.
+ */
+ abort(rejectWithError = null) {
+ if (this.status != this.SENT && this.status != this.IN_PROGRESS) {
+ throw new Error("Can only abort a request that has been sent.");
+ }
+
+ this.status = this.ABORTED;
+ this.channel.cancel(Cr.NS_BINDING_ABORTED);
+
+ if (this.timeoutTimer) {
+ // Clear the abort timer now that the channel is done.
+ this.timeoutTimer.clear();
+ }
+ if (rejectWithError) {
+ this._deferred.reject(rejectWithError);
+ }
+ },
+
+ /** Implementation stuff **/
+
+ async dispatch(method, data) {
+ if (this.status != this.NOT_SENT) {
+ throw new Error("Request has already been sent!");
+ }
+
+ this.method = method;
+
+ // Create and initialize HTTP channel.
+ let channel = NetUtil.newChannel({
+ uri: this.uri,
+ loadUsingSystemPrincipal: true,
+ })
+ .QueryInterface(Ci.nsIRequest)
+ .QueryInterface(Ci.nsIHttpChannel);
+ this.channel = channel;
+ channel.loadFlags |= this.loadFlags;
+ channel.notificationCallbacks = this;
+
+ this._log.debug(`${method} request to ${this.uri.spec}`);
+ // Set request headers.
+ let headers = this._headers;
+ for (let key in headers) {
+ if (key == "authorization" || key == "x-client-state") {
+ this._log.trace("HTTP Header " + key + ": ***** (suppressed)");
+ } else {
+ this._log.trace("HTTP Header " + key + ": " + headers[key]);
+ }
+ channel.setRequestHeader(key, headers[key], false);
+ }
+
+ // REST requests accept JSON by default
+ if (!headers.accept) {
+ channel.setRequestHeader(
+ "accept",
+ "application/json;q=0.9,*/*;q=0.2",
+ false
+ );
+ }
+
+ // Set HTTP request body.
+ if (method == "PUT" || method == "POST" || method == "PATCH") {
+ // Convert non-string bodies into JSON with utf-8 encoding. If a string
+ // is passed we assume they've already encoded it.
+ let contentType = headers["content-type"];
+ if (typeof data != "string") {
+ data = JSON.stringify(data);
+ if (!contentType) {
+ contentType = "application/json";
+ }
+ if (!contentType.includes("charset")) {
+ data = CommonUtils.encodeUTF8(data);
+ contentType += "; charset=utf-8";
+ } else {
+ // If someone handed us an object but also a custom content-type
+ // it's probably confused. We could go to even further lengths to
+ // respect it, but this shouldn't happen in practice.
+ console.error(
+ "rest.js found an object to JSON.stringify but also a " +
+ "content-type header with a charset specification. " +
+ "This probably isn't going to do what you expect"
+ );
+ }
+ }
+ if (!contentType) {
+ contentType = "text/plain";
+ }
+
+ this._log.debug(method + " Length: " + data.length);
+ if (this._log.level <= Log.Level.Trace) {
+ this._log.trace(method + " Body: " + data);
+ }
+
+ let stream = Cc["@mozilla.org/io/string-input-stream;1"].createInstance(
+ Ci.nsIStringInputStream
+ );
+ stream.setData(data, data.length);
+
+ channel.QueryInterface(Ci.nsIUploadChannel);
+ channel.setUploadStream(stream, contentType, data.length);
+ }
+ // We must set this after setting the upload stream, otherwise it
+ // will always be 'PUT'. Yeah, I know.
+ channel.requestMethod = method;
+
+ // Before opening the channel, set the charset that serves as a hint
+ // as to what the response might be encoded as.
+ channel.contentCharset = this.charset;
+
+ // Blast off!
+ try {
+ channel.asyncOpen(this);
+ } catch (ex) {
+ // asyncOpen can throw in a bunch of cases -- e.g., a forbidden port.
+ this._log.warn("Caught an error in asyncOpen", ex);
+ this._deferred.reject(ex);
+ }
+ this.status = this.SENT;
+ this.delayTimeout();
+ return this._deferred.promise;
+ },
+
+ /**
+ * Create or push back the abort timer that kills this request.
+ */
+ delayTimeout() {
+ if (this.timeout) {
+ CommonUtils.namedTimer(
+ this.abortTimeout,
+ this.timeout * 1000,
+ this,
+ "timeoutTimer"
+ );
+ }
+ },
+
+ /**
+ * Abort the request based on a timeout.
+ */
+ abortTimeout() {
+ this.abort(
+ Components.Exception(
+ "Aborting due to channel inactivity.",
+ Cr.NS_ERROR_NET_TIMEOUT
+ )
+ );
+ },
+
+ /** nsIStreamListener **/
+
+ onStartRequest(channel) {
+ if (this.status == this.ABORTED) {
+ this._log.trace(
+ "Not proceeding with onStartRequest, request was aborted."
+ );
+ // We might have already rejected, but just in case.
+ this._deferred.reject(
+ Components.Exception("Request aborted", Cr.NS_BINDING_ABORTED)
+ );
+ return;
+ }
+
+ try {
+ channel.QueryInterface(Ci.nsIHttpChannel);
+ } catch (ex) {
+ this._log.error("Unexpected error: channel is not a nsIHttpChannel!");
+ this.status = this.ABORTED;
+ channel.cancel(Cr.NS_BINDING_ABORTED);
+ this._deferred.reject(ex);
+ return;
+ }
+
+ this.status = this.IN_PROGRESS;
+
+ this._log.trace(
+ "onStartRequest: " + channel.requestMethod + " " + channel.URI.spec
+ );
+
+ // Create a new response object.
+ this.response = new RESTResponse(this);
+
+ this.delayTimeout();
+ },
+
+ onStopRequest(channel, statusCode) {
+ if (this.timeoutTimer) {
+ // Clear the abort timer now that the channel is done.
+ this.timeoutTimer.clear();
+ }
+
+ // We don't want to do anything for a request that's already been aborted.
+ if (this.status == this.ABORTED) {
+ this._log.trace(
+ "Not proceeding with onStopRequest, request was aborted."
+ );
+ // We might not have already rejected if the user called reject() manually.
+ // If we have already rejected, then this is a no-op
+ this._deferred.reject(
+ Components.Exception("Request aborted", Cr.NS_BINDING_ABORTED)
+ );
+ return;
+ }
+
+ try {
+ channel.QueryInterface(Ci.nsIHttpChannel);
+ } catch (ex) {
+ this._log.error("Unexpected error: channel not nsIHttpChannel!");
+ this.status = this.ABORTED;
+ this._deferred.reject(ex);
+ return;
+ }
+
+ this.status = this.COMPLETED;
+
+ try {
+ this.response.body = decodeString(
+ this.response._rawBody,
+ this.response.charset
+ );
+ this.response._rawBody = null;
+ } catch (ex) {
+ this._log.warn(
+ `Exception decoding response - ${this.method} ${channel.URI.spec}`,
+ ex
+ );
+ this._deferred.reject(ex);
+ return;
+ }
+
+ let statusSuccess = Components.isSuccessCode(statusCode);
+ let uri = (channel && channel.URI && channel.URI.spec) || "<unknown>";
+ this._log.trace(
+ "Channel for " +
+ channel.requestMethod +
+ " " +
+ uri +
+ " returned status code " +
+ statusCode
+ );
+
+ // Throw the failure code and stop execution. Use Components.Exception()
+ // instead of Error() so the exception is QI-able and can be passed across
+ // XPCOM borders while preserving the status code.
+ if (!statusSuccess) {
+ let message = Components.Exception("", statusCode).name;
+ let error = Components.Exception(message, statusCode);
+ this._log.debug(
+ this.method + " " + uri + " failed: " + statusCode + " - " + message
+ );
+ // Additionally give the full response body when Trace logging.
+ if (this._log.level <= Log.Level.Trace) {
+ this._log.trace(this.method + " body", this.response.body);
+ }
+ this._deferred.reject(error);
+ return;
+ }
+
+ this._log.debug(this.method + " " + uri + " " + this.response.status);
+
+ // Note that for privacy/security reasons we don't log this response body
+
+ delete this._inputStream;
+
+ this._deferred.resolve(this.response);
+ },
+
+ onDataAvailable(channel, stream, off, count) {
+ // We get an nsIRequest, which doesn't have contentCharset.
+ try {
+ channel.QueryInterface(Ci.nsIHttpChannel);
+ } catch (ex) {
+ this._log.error("Unexpected error: channel not nsIHttpChannel!");
+ this.abort(ex);
+ return;
+ }
+
+ if (channel.contentCharset) {
+ this.response.charset = channel.contentCharset;
+ } else {
+ this.response.charset = null;
+ }
+
+ if (!this._inputStream) {
+ this._inputStream = Cc[
+ "@mozilla.org/scriptableinputstream;1"
+ ].createInstance(Ci.nsIScriptableInputStream);
+ }
+ this._inputStream.init(stream);
+
+ this.response._rawBody += this._inputStream.read(count);
+
+ this.delayTimeout();
+ },
+
+ /** nsIInterfaceRequestor **/
+
+ getInterface(aIID) {
+ return this.QueryInterface(aIID);
+ },
+
+ /**
+ * Returns true if headers from the old channel should be
+ * copied to the new channel. Invoked when a channel redirect
+ * is in progress.
+ */
+ shouldCopyOnRedirect(oldChannel, newChannel, flags) {
+ let isInternal = !!(flags & Ci.nsIChannelEventSink.REDIRECT_INTERNAL);
+ let isSameURI = newChannel.URI.equals(oldChannel.URI);
+ this._log.debug(
+ "Channel redirect: " +
+ oldChannel.URI.spec +
+ ", " +
+ newChannel.URI.spec +
+ ", internal = " +
+ isInternal
+ );
+ return isInternal && isSameURI;
+ },
+
+ /** nsIChannelEventSink **/
+ asyncOnChannelRedirect(oldChannel, newChannel, flags, callback) {
+ let oldSpec =
+ oldChannel && oldChannel.URI ? oldChannel.URI.spec : "<undefined>";
+ let newSpec =
+ newChannel && newChannel.URI ? newChannel.URI.spec : "<undefined>";
+ this._log.debug(
+ "Channel redirect: " + oldSpec + ", " + newSpec + ", " + flags
+ );
+
+ try {
+ newChannel.QueryInterface(Ci.nsIHttpChannel);
+ } catch (ex) {
+ this._log.error("Unexpected error: channel not nsIHttpChannel!");
+ callback.onRedirectVerifyCallback(Cr.NS_ERROR_NO_INTERFACE);
+ return;
+ }
+
+ // For internal redirects, copy the headers that our caller set.
+ try {
+ if (this.shouldCopyOnRedirect(oldChannel, newChannel, flags)) {
+ this._log.trace("Copying headers for safe internal redirect.");
+ for (let key in this._headers) {
+ newChannel.setRequestHeader(key, this._headers[key], false);
+ }
+ }
+ } catch (ex) {
+ this._log.error("Error copying headers", ex);
+ }
+
+ this.channel = newChannel;
+
+ // We let all redirects proceed.
+ callback.onRedirectVerifyCallback(Cr.NS_OK);
+ },
+};
+
+/**
+ * Response object for a RESTRequest. This will be created automatically by
+ * the RESTRequest.
+ */
+export function RESTResponse(request = null) {
+ this.body = "";
+ this._rawBody = "";
+ this.request = request;
+ this._log = Log.repository.getLogger(this._logName);
+ this._log.manageLevelFromPref("services.common.log.logger.rest.response");
+}
+
+RESTResponse.prototype = {
+ _logName: "Services.Common.RESTResponse",
+
+ /**
+ * Corresponding REST request
+ */
+ request: null,
+
+ /**
+ * HTTP status code
+ */
+ get status() {
+ let status;
+ try {
+ status = this.request.channel.responseStatus;
+ } catch (ex) {
+ this._log.debug("Caught exception fetching HTTP status code", ex);
+ return null;
+ }
+ Object.defineProperty(this, "status", { value: status });
+ return status;
+ },
+
+ /**
+ * HTTP status text
+ */
+ get statusText() {
+ let statusText;
+ try {
+ statusText = this.request.channel.responseStatusText;
+ } catch (ex) {
+ this._log.debug("Caught exception fetching HTTP status text", ex);
+ return null;
+ }
+ Object.defineProperty(this, "statusText", { value: statusText });
+ return statusText;
+ },
+
+ /**
+ * Boolean flag that indicates whether the HTTP status code is 2xx or not.
+ */
+ get success() {
+ let success;
+ try {
+ success = this.request.channel.requestSucceeded;
+ } catch (ex) {
+ this._log.debug("Caught exception fetching HTTP success flag", ex);
+ return null;
+ }
+ Object.defineProperty(this, "success", { value: success });
+ return success;
+ },
+
+ /**
+ * Object containing HTTP headers (keyed as lower case)
+ */
+ get headers() {
+ let headers = {};
+ try {
+ this._log.trace("Processing response headers.");
+ let channel = this.request.channel.QueryInterface(Ci.nsIHttpChannel);
+ channel.visitResponseHeaders(function (header, value) {
+ headers[header.toLowerCase()] = value;
+ });
+ } catch (ex) {
+ this._log.debug("Caught exception processing response headers", ex);
+ return null;
+ }
+
+ Object.defineProperty(this, "headers", { value: headers });
+ return headers;
+ },
+
+ /**
+ * HTTP body (string)
+ */
+ body: null,
+};
+
+/**
+ * Single use MAC authenticated HTTP requests to RESTish resources.
+ *
+ * @param uri
+ * URI going to the RESTRequest constructor.
+ * @param authToken
+ * (Object) An auth token of the form {id: (string), key: (string)}
+ * from which the MAC Authentication header for this request will be
+ * derived. A token as obtained from
+ * TokenServerClient.getTokenUsingOAuth is accepted.
+ * @param extra
+ * (Object) Optional extra parameters. Valid keys are: nonce_bytes, ts,
+ * nonce, and ext. See CrytoUtils.computeHTTPMACSHA1 for information on
+ * the purpose of these values.
+ */
+export function TokenAuthenticatedRESTRequest(uri, authToken, extra) {
+ RESTRequest.call(this, uri);
+ this.authToken = authToken;
+ this.extra = extra || {};
+}
+
+TokenAuthenticatedRESTRequest.prototype = {
+ async dispatch(method, data) {
+ let sig = await lazy.CryptoUtils.computeHTTPMACSHA1(
+ this.authToken.id,
+ this.authToken.key,
+ method,
+ this.uri,
+ this.extra
+ );
+
+ this.setHeader("Authorization", sig.getHeader());
+
+ return super.dispatch(method, data);
+ },
+};
+
+Object.setPrototypeOf(
+ TokenAuthenticatedRESTRequest.prototype,
+ RESTRequest.prototype
+);